@highlight-run/rrweb 1.2.1 → 2.0.0-lambda.1

package/dist/plugins/record/observers/canvas/canvas-manager.d.ts

@@ -1,32 +0,0 @@
-import { blockClass, canvasMutationCallback, IWindow, Mirror } from '../../../types';
-export declare type RafStamps = {
-    latestId: number;
-    invokeId: number | null;
-};
-export declare class CanvasManager {
-    private pendingCanvasMutations;
-    private rafStamps;
-    private mirror;
-    private mutationCb;
-    private resetObservers?;
-    private frozen;
-    private locked;
-    reset(): void;
-    freeze(): void;
-    unfreeze(): void;
-    lock(): void;
-    unlock(): void;
-    constructor(options: {
-        recordCanvas: boolean | number;
-        mutationCb: canvasMutationCallback;
-        win: IWindow;
-        blockClass: blockClass;
-        mirror: Mirror;
-    });
-    private processMutation;
-    private initCanvasMutationObserver;
-    private startPendingCanvasMutationFlusher;
-    private startRAFTimestamping;
-    flushPendingCanvasMutations(): void;
-    flushPendingCanvasMutationFor(canvas: HTMLCanvasElement, id: number): void;
-}

package/dist/plugins/record/observers/canvas/canvas.d.ts

@@ -1,2 +0,0 @@
-import { blockClass, IWindow, listenerHandler } from '../../../types';
-export default function initCanvasContextObserver(win: IWindow, blockClass: blockClass): listenerHandler;

package/dist/plugins/record/observers/canvas/serialize-args.d.ts

@@ -1,6 +0,0 @@
-import { IWindow, SerializedWebGlArg } from '../../../types';
-export declare function variableListFor(ctx: WebGLRenderingContext | WebGL2RenderingContext, ctor: string): any[];
-export declare const saveWebGLVar: (value: any, win: IWindow, ctx: WebGL2RenderingContext | WebGLRenderingContext) => number | void;
-export declare function serializeArg(value: any, win: IWindow, ctx: WebGL2RenderingContext | WebGLRenderingContext): SerializedWebGlArg;
-export declare const serializeArgs: (args: Array<any>, win: IWindow, ctx: WebGLRenderingContext | WebGL2RenderingContext) => SerializedWebGlArg[];
-export declare const isInstanceOfWebGLObject: (value: any, win: IWindow) => value is WebGLActiveInfo | WebGLBuffer | WebGLFramebuffer | WebGLProgram | WebGLRenderbuffer | WebGLShader | WebGLShaderPrecisionFormat | WebGLTexture | WebGLUniformLocation | WebGLVertexArrayObject;

package/dist/plugins/record/observers/canvas/webgl.d.ts

@@ -1,2 +0,0 @@
-import { blockClass, canvasManagerMutationCallback, IWindow, listenerHandler, Mirror } from '../../../types';
-export default function initCanvasWebGLMutationObserver(cb: canvasManagerMutationCallback, win: IWindow, blockClass: blockClass, mirror: Mirror): listenerHandler;

package/dist/plugins/record/shadow-dom-manager.d.ts

@@ -1,34 +0,0 @@
-import { mutationCallBack, blockClass, maskTextClass, Mirror, scrollCallback, SamplingStrategy } from '../types';
-import { MaskInputOptions, SlimDOMOptions, MaskTextFn, MaskInputFn } from '../snapshot';
-import { IframeManager } from './iframe-manager';
-import { CanvasManager } from './observers/canvas/canvas-manager';
-declare type BypassOptions = {
-    blockClass: blockClass;
-    blockSelector: string | null;
-    maskTextClass: maskTextClass;
-    maskTextSelector: string | null;
-    inlineStylesheet: boolean;
-    maskInputOptions: MaskInputOptions;
-    maskTextFn: MaskTextFn | undefined;
-    maskInputFn: MaskInputFn | undefined;
-    recordCanvas: boolean;
-    sampling: SamplingStrategy;
-    slimDOMOptions: SlimDOMOptions;
-    iframeManager: IframeManager;
-    canvasManager: CanvasManager;
-    enableStrictPrivacy: boolean;
-};
-export declare class ShadowDomManager {
-    private mutationCb;
-    private scrollCb;
-    private bypassOptions;
-    private mirror;
-    constructor(options: {
-        mutationCb: mutationCallBack;
-        scrollCb: scrollCallback;
-        bypassOptions: BypassOptions;
-        mirror: Mirror;
-    });
-    addShadowRoot(shadowRoot: ShadowRoot, doc: Document): void;
-}
-export {};

package/dist/plugins/replay/canvas/2d.d.ts

@@ -1,9 +0,0 @@
-import { Replayer } from '../';
-import { canvasMutationCommand } from '../../types';
-export default function canvasMutation({ event, mutation, target, imageMap, errorHandler, }: {
-    event: Parameters<Replayer['applyIncremental']>[0];
-    mutation: canvasMutationCommand;
-    target: HTMLCanvasElement;
-    imageMap: Replayer['imageMap'];
-    errorHandler: Replayer['warnCanvasMutationFailed'];
-}): void;

package/dist/plugins/replay/canvas/index.d.ts

@@ -1,9 +0,0 @@
-import { Replayer } from '..';
-import { canvasMutationData } from '../../types';
-export default function canvasMutation({ event, mutation, target, imageMap, errorHandler, }: {
-    event: Parameters<Replayer['applyIncremental']>[0];
-    mutation: canvasMutationData;
-    target: HTMLCanvasElement;
-    imageMap: Replayer['imageMap'];
-    errorHandler: Replayer['warnCanvasMutationFailed'];
-}): void;

package/dist/plugins/replay/canvas/webgl.d.ts

@@ -1,11 +0,0 @@
-import { Replayer } from '../';
-import { CanvasContext, canvasMutationCommand, SerializedWebGlArg } from '../../types';
-export declare function variableListFor(ctx: WebGLRenderingContext | WebGL2RenderingContext, ctor: string): any[];
-export declare function deserializeArg(imageMap: Replayer['imageMap'], ctx: WebGLRenderingContext | WebGL2RenderingContext): (arg: SerializedWebGlArg) => any;
-export default function webglMutation({ mutation, target, type, imageMap, errorHandler, }: {
-    mutation: canvasMutationCommand;
-    target: HTMLCanvasElement;
-    type: CanvasContext;
-    imageMap: Replayer['imageMap'];
-    errorHandler: Replayer['warnCanvasMutationFailed'];
-}): void;

package/dist/plugins/replay/index.d.ts

@@ -1,82 +0,0 @@
-import { Timer } from './timer';
-import { createPlayerService, createSpeedService } from './machine';
-import { eventWithTime, playerConfig, playerMetaData, Handler, Mirror, SessionInterval } from '../types';
-import './styles/style.css';
-export declare class Replayer {
-    wrapper: HTMLDivElement;
-    iframe: HTMLIFrameElement;
-    service: ReturnType<typeof createPlayerService>;
-    speedService: ReturnType<typeof createSpeedService>;
-    get timer(): Timer;
-    config: playerConfig;
-    private mouse;
-    private mouseTail;
-    private tailPositions;
-    private emitter;
-    private nextUserInteractionEvent;
-    private activityIntervals;
-    private inactiveEndTimestamp;
-    private legacy_missingNodeRetryMap;
-    private treeIndex;
-    private fragmentParentMap;
-    private elementStateMap;
-    private virtualStyleRulesMap;
-    private cache;
-    private imageMap;
-    private mirror;
-    private firstFullSnapshot;
-    private newDocumentQueue;
-    private mousePos;
-    private touchActive;
-    constructor(events: Array<eventWithTime | string>, config?: Partial<playerConfig>);
-    on(event: string, handler: Handler): this;
-    off(event: string, handler: Handler): this;
-    setConfig(config: Partial<playerConfig>): void;
-    getActivityIntervals(): Array<SessionInterval>;
-    getMetaData(): playerMetaData;
-    getCurrentTime(): number;
-    getTimeOffset(): number;
-    getMirror(): Mirror;
-    play(timeOffset?: number): void;
-    pause(timeOffset?: number): void;
-    resume(timeOffset?: number): void;
-    startLive(baselineTime?: number): void;
-    addEvent(rawEvent: eventWithTime | string): void;
-    replaceEvents(events: eventWithTime[]): void;
-    enableInteract(): void;
-    disableInteract(): void;
-    resetCache(): void;
-    private setupDom;
-    private handleResize;
-    private applyEventsSynchronously;
-    private getCastFn;
-    private handleInactivity;
-    private rebuildFullSnapshot;
-    private insertStyleRules;
-    private attachDocumentToIframe;
-    private collectIframeAndAttachDocument;
-    private waitForStylesheetLoad;
-    private hasImageArg;
-    private getImageArgs;
-    private preloadAllImages;
-    private preloadImages;
-    private applyIncremental;
-    private applyMutation;
-    private applyScroll;
-    private applyInput;
-    private legacy_resolveMissingNode;
-    private moveAndHover;
-    private drawMouseTail;
-    private hoverElements;
-    private isUserInteraction;
-    private backToNormal;
-    private restoreRealParent;
-    private storeState;
-    private restoreState;
-    private restoreNodeSheet;
-    private warnNodeNotFound;
-    private warnCanvasMutationFailed;
-    private debugNodeNotFound;
-    private warn;
-    private debug;
-}

package/dist/plugins/replay/machine.d.ts

@@ -1,85 +0,0 @@
-import { StateMachine } from '@xstate/fsm';
-import { playerConfig, eventWithTime, Emitter } from '../types';
-import { Timer } from './timer';
-export declare type PlayerContext = {
-    events: eventWithTime[];
-    timer: Timer;
-    timeOffset: number;
-    baselineTime: number;
-    lastPlayedEvent: eventWithTime | null;
-};
-export declare type PlayerEvent = {
-    type: 'PLAY';
-    payload: {
-        timeOffset: number;
-    };
-} | {
-    type: 'CAST_EVENT';
-    payload: {
-        event: eventWithTime;
-    };
-} | {
-    type: 'PAUSE';
-} | {
-    type: 'TO_LIVE';
-    payload: {
-        baselineTime?: number;
-    };
-} | {
-    type: 'ADD_EVENT';
-    payload: {
-        event: eventWithTime;
-    };
-} | {
-    type: 'REPLACE_EVENTS';
-    payload: {
-        events: eventWithTime[];
-    };
-} | {
-    type: 'END';
-};
-export declare type PlayerState = {
-    value: 'playing';
-    context: PlayerContext;
-} | {
-    value: 'paused';
-    context: PlayerContext;
-} | {
-    value: 'live';
-    context: PlayerContext;
-};
-export declare function discardPriorSnapshots(events: eventWithTime[], baselineTime: number): eventWithTime[];
-declare type PlayerAssets = {
-    emitter: Emitter;
-    applyEventsSynchronously(events: Array<eventWithTime>): void;
-    getCastFn(event: eventWithTime, isSync: boolean): () => void;
-};
-export declare function createPlayerService(context: PlayerContext, { getCastFn, applyEventsSynchronously, emitter }: PlayerAssets): StateMachine.Service<PlayerContext, PlayerEvent, PlayerState>;
-export declare type SpeedContext = {
-    normalSpeed: playerConfig['speed'];
-    timer: Timer;
-};
-export declare type SpeedEvent = {
-    type: 'FAST_FORWARD';
-    payload: {
-        speed: playerConfig['speed'];
-    };
-} | {
-    type: 'BACK_TO_NORMAL';
-} | {
-    type: 'SET_SPEED';
-    payload: {
-        speed: playerConfig['speed'];
-    };
-};
-export declare type SpeedState = {
-    value: 'normal';
-    context: SpeedContext;
-} | {
-    value: 'skipping';
-    context: SpeedContext;
-};
-export declare function createSpeedService(context: SpeedContext): StateMachine.Service<SpeedContext, SpeedEvent, SpeedState>;
-export declare type PlayerMachineState = StateMachine.State<PlayerContext, PlayerEvent, PlayerState>;
-export declare type SpeedMachineState = StateMachine.State<SpeedContext, SpeedEvent, SpeedState>;
-export {};

package/dist/plugins/replay/smoothscroll.d.ts

@@ -1 +0,0 @@
-export declare function polyfill(w?: Window, d?: Document): void;

package/dist/plugins/replay/styles/inject-style.d.ts

@@ -1,2 +0,0 @@
-declare const rules: (blockClass: string) => string[];
-export default rules;

package/dist/plugins/replay/timer.d.ts

@@ -1,19 +0,0 @@
-import { actionWithDelay, eventWithTime } from '../types';
-export declare class Timer {
-    timeOffset: number;
-    speed: number;
-    private actions;
-    private raf;
-    private liveMode;
-    constructor(actions: actionWithDelay[] | undefined, speed: number);
-    addAction(action: actionWithDelay): void;
-    addActions(actions: actionWithDelay[]): void;
-    replaceActions(actions: actionWithDelay[]): void;
-    start(): void;
-    clear(): void;
-    setSpeed(speed: number): void;
-    toggleLiveMode(mode: boolean): void;
-    isActive(): boolean;
-    private findActionIndex;
-}
-export declare function addDelay(event: eventWithTime, baselineTime: number): number;

package/dist/plugins/replay/virtual-styles.d.ts

@@ -1,43 +0,0 @@
-import { INode } from '../snapshot';
-export declare enum StyleRuleType {
-    Insert = 0,
-    Remove = 1,
-    Snapshot = 2,
-    SetProperty = 3,
-    RemoveProperty = 4
-}
-declare type InsertRule = {
-    cssText: string;
-    type: StyleRuleType.Insert;
-    index?: number | number[];
-};
-declare type RemoveRule = {
-    type: StyleRuleType.Remove;
-    index: number | number[];
-};
-declare type SnapshotRule = {
-    type: StyleRuleType.Snapshot;
-    cssTexts: string[];
-};
-declare type SetPropertyRule = {
-    type: StyleRuleType.SetProperty;
-    index: number[];
-    property: string;
-    value: string | null;
-    priority: string | undefined;
-};
-declare type RemovePropertyRule = {
-    type: StyleRuleType.RemoveProperty;
-    index: number[];
-    property: string;
-};
-export declare type VirtualStyleRules = Array<InsertRule | RemoveRule | SnapshotRule | SetPropertyRule | RemovePropertyRule>;
-export declare type VirtualStyleRulesMap = Map<INode, VirtualStyleRules>;
-export declare function getNestedRule(rules: CSSRuleList, position: number[]): CSSGroupingRule;
-export declare function getPositionsAndIndex(nestedIndex: number[]): {
-    positions: number[];
-    index: number | undefined;
-};
-export declare function applyVirtualStyleRulesToNode(storedRules: VirtualStyleRules, styleNode: HTMLStyleElement): void;
-export declare function storeCSSRules(parentElement: HTMLStyleElement, virtualStyleRulesMap: VirtualStyleRulesMap): void;
-export {};

package/dist/plugins/rrdom/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/plugins/rrdom/tree-node.d.ts

@@ -1,20 +0,0 @@
-export declare type AnyObject = {
-    [key: string]: any;
-    __rrdom__?: RRdomTreeNode;
-};
-export declare class RRdomTreeNode implements AnyObject {
-    parent: AnyObject | null;
-    previousSibling: AnyObject | null;
-    nextSibling: AnyObject | null;
-    firstChild: AnyObject | null;
-    lastChild: AnyObject | null;
-    childrenVersion: number;
-    childIndexCachedUpTo: AnyObject | null;
-    cachedIndex: number;
-    cachedIndexVersion: number;
-    get isAttached(): boolean;
-    get hasChildren(): boolean;
-    childrenChanged(): void;
-    getCachedIndex(parentNode: AnyObject): number;
-    setCachedIndex(parentNode: AnyObject, index: number): void;
-}

package/dist/plugins/sequential-id/record/index.d.ts

@@ -1,6 +0,0 @@
-import { RecordPlugin } from '../../../types';
-export declare type SequentialIdOptions = {
-    key: string;
-};
-export declare const PLUGIN_NAME = "rrweb/sequential-id@1";
-export declare const getRecordSequentialIdPlugin: (options?: Partial<SequentialIdOptions>) => RecordPlugin;

package/dist/plugins/sequential-id/replay/index.d.ts

@@ -1,7 +0,0 @@
-import type { SequentialIdOptions } from '../record';
-import { ReplayPlugin } from '../../../types';
-declare type Options = SequentialIdOptions & {
-    warnOnMissingId: boolean;
-};
-export declare const getReplaySequentialIdPlugin: (options?: Partial<Options>) => ReplayPlugin;
-export {};

package/dist/plugins/snapshot/css.d.ts

@@ -1,92 +0,0 @@
-export interface ParserOptions {
-    silent?: boolean;
-    source?: string;
-}
-export interface ParserError {
-    message?: string;
-    reason?: string;
-    filename?: string;
-    line?: number;
-    column?: number;
-    source?: string;
-}
-export interface Loc {
-    line?: number;
-    column?: number;
-}
-export interface Node {
-    type?: string;
-    parent?: Node;
-    position?: {
-        start?: Loc;
-        end?: Loc;
-        source?: string;
-        content?: string;
-    };
-}
-export interface Rule extends Node {
-    selectors?: string[];
-    declarations?: Array<Declaration | Comment>;
-}
-export interface Declaration extends Node {
-    property?: string;
-    value?: string;
-}
-export interface Comment extends Node {
-    comment?: string;
-}
-export interface Charset extends Node {
-    charset?: string;
-}
-export interface CustomMedia extends Node {
-    name?: string;
-    media?: string;
-}
-export interface Document extends Node {
-    document?: string;
-    vendor?: string;
-    rules?: Array<Rule | Comment | AtRule>;
-}
-export interface FontFace extends Node {
-    declarations?: Array<Declaration | Comment>;
-}
-export interface Host extends Node {
-    rules?: Array<Rule | Comment | AtRule>;
-}
-export interface Import extends Node {
-    import?: string;
-}
-export interface KeyFrames extends Node {
-    name?: string;
-    vendor?: string;
-    keyframes?: Array<KeyFrame | Comment>;
-}
-export interface KeyFrame extends Node {
-    values?: string[];
-    declarations?: Array<Declaration | Comment>;
-}
-export interface Media extends Node {
-    media?: string;
-    rules?: Array<Rule | Comment | AtRule>;
-}
-export interface Namespace extends Node {
-    namespace?: string;
-}
-export interface Page extends Node {
-    selectors?: string[];
-    declarations?: Array<Declaration | Comment>;
-}
-export interface Supports extends Node {
-    supports?: string;
-    rules?: Array<Rule | Comment | AtRule>;
-}
-export declare type AtRule = Charset | CustomMedia | Document | FontFace | Host | Import | KeyFrames | Media | Namespace | Page | Supports;
-export interface StyleRules {
-    source?: string;
-    rules: Array<Rule | Comment | AtRule>;
-    parsingErrors?: ParserError[];
-}
-export interface Stylesheet extends Node {
-    stylesheet?: StyleRules;
-}
-export declare function parse(css: string, options?: ParserOptions): Stylesheet;

package/dist/plugins/snapshot/index.d.ts

@@ -1,5 +0,0 @@
-import snapshot, { serializeNodeWithId, transformAttribute, visitSnapshot, cleanupSnapshot, needMaskingText, IGNORED_NODE } from './snapshot';
-import rebuild, { buildNodeWithSN, addHoverClass, createCache } from './rebuild';
-export * from './types';
-export * from './utils';
-export { snapshot, serializeNodeWithId, rebuild, buildNodeWithSN, addHoverClass, createCache, transformAttribute, visitSnapshot, cleanupSnapshot, needMaskingText, IGNORED_NODE, };

package/dist/plugins/snapshot/rebuild.d.ts

@@ -1,19 +0,0 @@
-import { serializedNodeWithId, idNodeMap, INode, BuildCache } from './types';
-export declare function addHoverClass(cssText: string, cache: BuildCache): string;
-export declare function createCache(): BuildCache;
-export declare function buildNodeWithSN(n: serializedNodeWithId, options: {
-    doc: Document;
-    map: idNodeMap;
-    skipChild?: boolean;
-    hackCss: boolean;
-    afterAppend?: (n: INode) => unknown;
-    cache: BuildCache;
-}): INode | null;
-declare function rebuild(n: serializedNodeWithId, options: {
-    doc: Document;
-    onVisit?: (node: INode) => unknown;
-    hackCss?: boolean;
-    afterAppend?: (n: INode) => unknown;
-    cache: BuildCache;
-}): [Node | null, idNodeMap];
-export default rebuild;

package/dist/plugins/snapshot/snapshot.d.ts

@@ -1,49 +0,0 @@
-import { serializedNodeWithId, INode, idNodeMap, MaskInputOptions, SlimDOMOptions, MaskTextFn, MaskInputFn, KeepIframeSrcFn } from './types';
-export declare const IGNORED_NODE = -2;
-export declare function absoluteToStylesheet(cssText: string | null, href: string): string;
-export declare function absoluteToDoc(doc: Document, attributeValue: string): string;
-export declare function transformAttribute(doc: Document, tagName: string, name: string, value: string): string;
-export declare function _isBlockedElement(element: HTMLElement, blockClass: string | RegExp, blockSelector: string | null): boolean;
-export declare function needMaskingText(node: Node | null, maskTextClass: string | RegExp, maskTextSelector: string | null): boolean;
-export declare function serializeNodeWithId(n: Node | INode, options: {
-    doc: Document;
-    map: idNodeMap;
-    blockClass: string | RegExp;
-    blockSelector: string | null;
-    maskTextClass: string | RegExp;
-    maskTextSelector: string | null;
-    skipChild: boolean;
-    inlineStylesheet: boolean;
-    maskInputOptions?: MaskInputOptions;
-    maskTextFn: MaskTextFn | undefined;
-    maskInputFn: MaskInputFn | undefined;
-    slimDOMOptions: SlimDOMOptions;
-    keepIframeSrcFn?: KeepIframeSrcFn;
-    recordCanvas?: boolean;
-    preserveWhiteSpace?: boolean;
-    onSerialize?: (n: INode) => unknown;
-    onIframeLoad?: (iframeINode: INode, node: serializedNodeWithId) => unknown;
-    iframeLoadTimeout?: number;
-    enableStrictPrivacy: boolean;
-}): serializedNodeWithId | null;
-declare function snapshot(n: Document, options?: {
-    blockClass?: string | RegExp;
-    blockSelector?: string | null;
-    maskTextClass?: string | RegExp;
-    maskTextSelector?: string | null;
-    inlineStylesheet?: boolean;
-    maskAllInputs?: boolean | MaskInputOptions;
-    maskTextFn?: MaskTextFn;
-    maskInputFn?: MaskTextFn;
-    slimDOM?: boolean | SlimDOMOptions;
-    recordCanvas?: boolean;
-    preserveWhiteSpace?: boolean;
-    onSerialize?: (n: INode) => unknown;
-    onIframeLoad?: (iframeINode: INode, node: serializedNodeWithId) => unknown;
-    iframeLoadTimeout?: number;
-    keepIframeSrcFn?: KeepIframeSrcFn;
-    enableStrictPrivacy: boolean;
-}): [serializedNodeWithId | null, idNodeMap];
-export declare function visitSnapshot(node: serializedNodeWithId, onVisit: (node: serializedNodeWithId) => unknown): void;
-export declare function cleanupSnapshot(): void;
-export default snapshot;

package/dist/plugins/snapshot/types.d.ts

@@ -1,99 +0,0 @@
-export declare enum NodeType {
-    Document = 0,
-    DocumentType = 1,
-    Element = 2,
-    Text = 3,
-    CDATA = 4,
-    Comment = 5
-}
-export declare type documentNode = {
-    type: NodeType.Document;
-    childNodes: serializedNodeWithId[];
-    compatMode?: string;
-};
-export declare type documentTypeNode = {
-    type: NodeType.DocumentType;
-    name: string;
-    publicId: string;
-    systemId: string;
-};
-export declare type attributes = {
-    [key: string]: string | number | boolean;
-};
-export declare type elementNode = {
-    type: NodeType.Element;
-    tagName: string;
-    attributes: attributes;
-    childNodes: serializedNodeWithId[];
-    isSVG?: true;
-    needBlock?: boolean;
-};
-export declare type textNode = {
-    type: NodeType.Text;
-    textContent: string;
-    isStyle?: true;
-};
-export declare type cdataNode = {
-    type: NodeType.CDATA;
-    textContent: '';
-};
-export declare type commentNode = {
-    type: NodeType.Comment;
-    textContent: string;
-};
-export declare type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
-    rootId?: number;
-    isShadowHost?: boolean;
-    isShadow?: boolean;
-};
-export declare type serializedNodeWithId = serializedNode & {
-    id: number;
-};
-export declare type tagMap = {
-    [key: string]: string;
-};
-export interface INode extends Node {
-    __sn: serializedNodeWithId;
-}
-export interface ICanvas extends HTMLCanvasElement {
-    __context: string;
-}
-export declare type idNodeMap = {
-    [key: number]: INode;
-};
-export declare type MaskInputOptions = Partial<{
-    color: boolean;
-    date: boolean;
-    'datetime-local': boolean;
-    email: boolean;
-    month: boolean;
-    number: boolean;
-    range: boolean;
-    search: boolean;
-    tel: boolean;
-    text: boolean;
-    time: boolean;
-    url: boolean;
-    week: boolean;
-    textarea: boolean;
-    select: boolean;
-    password: boolean;
-}>;
-export declare type SlimDOMOptions = Partial<{
-    script: boolean;
-    comment: boolean;
-    headFavicon: boolean;
-    headWhitespace: boolean;
-    headMetaDescKeywords: boolean;
-    headMetaSocial: boolean;
-    headMetaRobots: boolean;
-    headMetaHttpEquiv: boolean;
-    headMetaAuthorship: boolean;
-    headMetaVerification: boolean;
-}>;
-export declare type MaskTextFn = (text: string) => string;
-export declare type MaskInputFn = (text: string) => string;
-export declare type KeepIframeSrcFn = (src: string) => boolean;
-export declare type BuildCache = {
-    stylesWithHoverClass: Map<string, string>;
-};