@highlight-run/rrweb 1.2.1 → 2.0.4

package/es/rrweb/packages/rrweb/src/replay/machine.js

@@ -0,0 +1,281 @@
+import { interpret as v, createMachine as s, assign as o } from './../../../../ext/@xstate/fsm/es/index.js';
+import { EventType, IncrementalSource, ReplayerEvents } from '../types.js';
+import { addDelay } from './timer.js';
+
+function discardPriorSnapshots(events, baselineTime) {
+    for (let idx = events.length - 1; idx >= 0; idx--) {
+        const event = events[idx];
+        if (event.type === EventType.Meta) {
+            if (event.timestamp <= baselineTime) {
+                return events.slice(idx);
+            }
+        }
+    }
+    return events;
+}
+function createPlayerService(context, { getCastFn, applyEventsSynchronously, emitter }) {
+    const playerMachine = s({
+        id: 'player',
+        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: (ctx, event) => {
+                    if (event.type === 'CAST_EVENT') {
+                        return event.payload.event;
+                    }
+                    return ctx.lastPlayedEvent;
+                },
+            }),
+            recordTimeOffset: o((ctx, event) => {
+                let timeOffset = ctx.timeOffset;
+                if ('payload' in event && 'timeOffset' in event.payload) {
+                    timeOffset = event.payload.timeOffset;
+                }
+                return Object.assign(Object.assign({}, ctx), { timeOffset, baselineTime: ctx.events[0].timestamp + timeOffset });
+            }),
+            play(ctx) {
+                var _a;
+                const { timer, events, baselineTime, lastPlayedEvent } = ctx;
+                timer.clear();
+                for (const event of events) {
+                    addDelay(event, baselineTime);
+                }
+                const neededEvents = discardPriorSnapshots(events, baselineTime);
+                let 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 +
+                            ((_a = lastPlayedEvent.data.positions[0]) === null || _a === void 0 ? void 0 : _a.timeOffset);
+                }
+                if (baselineTime < (lastPlayedTimestamp || 0)) {
+                    emitter.emit(ReplayerEvents.PlayBack);
+                }
+                const syncEvents = new Array();
+                const actions = new Array();
+                for (const event of neededEvents) {
+                    if (lastPlayedTimestamp &&
+                        lastPlayedTimestamp < baselineTime &&
+                        (event.timestamp <= lastPlayedTimestamp ||
+                            event === lastPlayedEvent)) {
+                        continue;
+                    }
+                    if (event.timestamp < baselineTime) {
+                        syncEvents.push(event);
+                    }
+                    else {
+                        const castFn = getCastFn(event, false);
+                        actions.push({
+                            doAction: () => {
+                                castFn();
+                            },
+                            delay: event.delay,
+                        });
+                    }
+                }
+                applyEventsSynchronously(syncEvents);
+                emitter.emit(ReplayerEvents.Flush);
+                timer.addActions(actions);
+                timer.start();
+            },
+            pause(ctx) {
+                ctx.timer.clear();
+            },
+            resetLastPlayedEvent: o((ctx) => {
+                return Object.assign(Object.assign({}, ctx), { lastPlayedEvent: null });
+            }),
+            startLive: o({
+                baselineTime: (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((ctx, machineEvent) => {
+                const { events: curEvents, timer, baselineTime } = ctx;
+                if (machineEvent.type === 'REPLACE_EVENTS') {
+                    const { events: newEvents } = machineEvent.payload;
+                    curEvents.length = 0;
+                    const actions = [];
+                    for (const event of newEvents) {
+                        addDelay(event, baselineTime);
+                        curEvents.push(event);
+                        if (event.timestamp >= timer.timeOffset + baselineTime) {
+                            const castFn = getCastFn(event, false);
+                            actions.push({
+                                doAction: () => {
+                                    castFn();
+                                },
+                                delay: event.delay,
+                            });
+                        }
+                    }
+                    if (timer.isActive()) {
+                        timer.replaceActions(actions);
+                    }
+                }
+                return Object.assign(Object.assign({}, ctx), { events: curEvents });
+            }),
+            addEvent: o((ctx, machineEvent) => {
+                const { baselineTime, timer, events } = ctx;
+                if (machineEvent.type === 'ADD_EVENT') {
+                    const { event } = machineEvent.payload;
+                    addDelay(event, baselineTime);
+                    let end = events.length - 1;
+                    if (!events[end] || events[end].timestamp <= event.timestamp) {
+                        events.push(event);
+                    }
+                    else {
+                        let insertionIndex = -1;
+                        let start = 0;
+                        while (start <= end) {
+                            const mid = Math.floor((start + end) / 2);
+                            if (events[mid].timestamp <= event.timestamp) {
+                                start = mid + 1;
+                            }
+                            else {
+                                end = mid - 1;
+                            }
+                        }
+                        if (insertionIndex === -1) {
+                            insertionIndex = start;
+                        }
+                        events.splice(insertionIndex, 0, event);
+                    }
+                    const isSync = event.timestamp < baselineTime;
+                    const castFn = getCastFn(event, isSync);
+                    if (isSync) {
+                        castFn();
+                    }
+                    else if (timer.isActive()) {
+                        timer.addAction({
+                            doAction: () => {
+                                castFn();
+                            },
+                            delay: event.delay,
+                        });
+                    }
+                }
+                return Object.assign(Object.assign({}, ctx), { events });
+            }),
+        },
+    });
+    return v(playerMachine);
+}
+function createSpeedService(context) {
+    const speedMachine = s({
+        id: 'speed',
+        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: (ctx, event) => {
+                if ('payload' in event) {
+                    ctx.timer.setSpeed(event.payload.speed);
+                }
+            },
+            recordSpeed: o({
+                normalSpeed: (ctx) => ctx.timer.speed,
+            }),
+            restoreSpeed: (ctx) => {
+                ctx.timer.setSpeed(ctx.normalSpeed);
+            },
+        },
+    });
+    return v(speedMachine);
+}
+
+export { createPlayerService, createSpeedService, discardPriorSnapshots };

package/es/rrweb/packages/rrweb/src/replay/smoothscroll.js

@@ -0,0 +1,219 @@
+function polyfill(w = window, d = document) {
+    if ('scrollBehavior' in d.documentElement.style &&
+        w.__forceSmoothScrollPolyfill__ !== true) {
+        return;
+    }
+    const Element = w.HTMLElement || w.Element;
+    const SCROLL_TIME = 468;
+    const original = {
+        scroll: w.scroll || w.scrollTo,
+        scrollBy: w.scrollBy,
+        elementScroll: Element.prototype.scroll || scrollElement,
+        scrollIntoView: Element.prototype.scrollIntoView,
+    };
+    const now = w.performance && w.performance.now
+        ? w.performance.now.bind(w.performance)
+        : Date.now;
+    function isMicrosoftBrowser(userAgent) {
+        const userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];
+        return new RegExp(userAgentPatterns.join('|')).test(userAgent);
+    }
+    const 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) {
+        const overflowValue = w.getComputedStyle(el, null)['overflow' + axis];
+        return overflowValue === 'auto' || overflowValue === 'scroll';
+    }
+    function isScrollable(el) {
+        const isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');
+        const 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) {
+        const time = now();
+        let value;
+        let currentX;
+        let currentY;
+        let 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) {
+        let scrollable;
+        let startX;
+        let startY;
+        let method;
+        const 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;
+        }
+        const left = arguments[0].left;
+        const 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;
+        }
+        const scrollableParent = findScrollableParent(this);
+        const parentRects = scrollableParent.getBoundingClientRect();
+        const 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',
+            });
+        }
+    };
+}
+
+export { polyfill };

package/es/rrweb/packages/rrweb/src/replay/styles/inject-style.js

@@ -0,0 +1,8 @@
+const rules = (blockClass) => [
+    `.${blockClass} { background: currentColor }`,
+    'noscript { display: none !important; }',
+    `.${blockClass} { background: currentColor; border-radius: 5px; }`,
+    `.${blockClass}:hover::after {content: 'Redacted'; color: white; background: black; text-align: center; width: 100%; display: block;}`,
+];
+
+export { rules as default };

package/es/rrweb/packages/rrweb/src/replay/timer.js

@@ -0,0 +1,92 @@
+import { EventType, IncrementalSource } from '../types.js';
+
+class Timer {
+    constructor(actions = [], speed) {
+        this.timeOffset = 0;
+        this.raf = null;
+        this.actions = actions;
+        this.speed = speed;
+    }
+    addAction(action) {
+        const index = this.findActionIndex(action);
+        this.actions.splice(index, 0, action);
+    }
+    addActions(actions) {
+        this.actions = this.actions.concat(actions);
+    }
+    replaceActions(actions) {
+        this.actions.length = 0;
+        this.actions.splice(0, 0, ...actions);
+    }
+    start() {
+        this.timeOffset = 0;
+        let lastTimestamp = performance.now();
+        const { actions } = this;
+        const self = this;
+        function check() {
+            const time = performance.now();
+            self.timeOffset += (time - lastTimestamp) * self.speed;
+            lastTimestamp = time;
+            while (actions.length) {
+                const 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);
+    }
+    clear() {
+        if (this.raf) {
+            cancelAnimationFrame(this.raf);
+            this.raf = null;
+        }
+        this.actions.length = 0;
+    }
+    setSpeed(speed) {
+        this.speed = speed;
+    }
+    toggleLiveMode(mode) {
+        this.liveMode = mode;
+    }
+    isActive() {
+        return this.raf !== null;
+    }
+    findActionIndex(action) {
+        let start = 0;
+        let end = this.actions.length - 1;
+        while (start <= end) {
+            const 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;
+    }
+}
+function addDelay(event, baselineTime) {
+    if (event.type === EventType.IncrementalSnapshot &&
+        event.data.source === IncrementalSource.MouseMove) {
+        const firstOffset = event.data.positions[0].timeOffset;
+        const firstTimestamp = event.timestamp + firstOffset;
+        event.delay = firstTimestamp - baselineTime;
+        return firstTimestamp - baselineTime;
+    }
+    event.delay = event.timestamp - baselineTime;
+    return event.delay;
+}
+
+export { Timer, addDelay };

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 };