@sprig-technologies/sprig-browser 2.24.7 → 2.24.8

package/dist/index.d.ts

@@ -1,3 +1,1635 @@
+declare enum NodeType {
+    Document = 0,
+    DocumentType = 1,
+    Element = 2,
+    Text = 3,
+    CDATA = 4,
+    Comment = 5
+}
+type documentNode = {
+    type: NodeType.Document;
+    childNodes: serializedNodeWithId[];
+    compatMode?: string;
+};
+type documentTypeNode = {
+    type: NodeType.DocumentType;
+    name: string;
+    publicId: string;
+    systemId: string;
+};
+type attributes = {
+    [key: string]: string | number | true | null;
+};
+type elementNode = {
+    type: NodeType.Element;
+    tagName: string;
+    attributes: attributes;
+    childNodes: serializedNodeWithId[];
+    isSVG?: true;
+    needBlock?: boolean;
+};
+type textNode = {
+    type: NodeType.Text;
+    textContent: string;
+    isStyle?: true;
+};
+type cdataNode = {
+    type: NodeType.CDATA;
+    textContent: '';
+};
+type commentNode = {
+    type: NodeType.Comment;
+    textContent: string;
+};
+type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
+    rootId?: number;
+    isShadowHost?: boolean;
+    isShadow?: boolean;
+};
+type serializedNodeWithId = serializedNode & {
+    id: number;
+};
+interface INode extends Node {
+    __sn: serializedNodeWithId;
+}
+interface IMirror<TNode> {
+    getId(n: TNode | undefined | null): number;
+    getNode(id: number): TNode | null;
+    getIds(): number[];
+    getMeta(n: TNode): serializedNodeWithId | null;
+    removeNodeFromMap(n: TNode): void;
+    has(id: number): boolean;
+    hasNode(node: TNode): boolean;
+    add(n: TNode, meta: serializedNodeWithId): void;
+    replace(id: number, n: TNode): void;
+    reset(): void;
+}
+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;
+}>;
+type SlimDOMOptions = Partial<{
+    script: boolean;
+    comment: boolean;
+    headFavicon: boolean;
+    headWhitespace: boolean;
+    headMetaDescKeywords: boolean;
+    headMetaSocial: boolean;
+    headMetaRobots: boolean;
+    headMetaHttpEquiv: boolean;
+    headMetaAuthorship: boolean;
+    headMetaVerification: boolean;
+}>;
+type DataURLOptions = Partial<{
+    type: string;
+    quality: number;
+}>;
+type MaskTextFn = (text: string) => string;
+type MaskInputFn = (text: string, element: HTMLElement) => string;
+
+declare class Mirror$1 implements IMirror<Node> {
+    private idNodeMap;
+    private nodeMetaMap;
+    getId(n: Node | undefined | null): number;
+    getNode(id: number): Node | null;
+    getIds(): number[];
+    getMeta(n: Node): serializedNodeWithId | null;
+    removeNodeFromMap(n: Node): void;
+    has(id: number): boolean;
+    hasNode(node: Node): boolean;
+    add(n: Node, meta: serializedNodeWithId): void;
+    replace(id: number, n: Node): void;
+    reset(): void;
+}
+
+declare enum EventType {
+    DomContentLoaded = 0,
+    Load = 1,
+    FullSnapshot = 2,
+    IncrementalSnapshot = 3,
+    Meta = 4,
+    Custom = 5,
+    Plugin = 6
+}
+type domContentLoadedEvent = {
+    type: EventType.DomContentLoaded;
+    data: unknown;
+};
+type loadedEvent = {
+    type: EventType.Load;
+    data: unknown;
+};
+type fullSnapshotEvent = {
+    type: EventType.FullSnapshot;
+    data: {
+        node: serializedNodeWithId;
+        initialOffset: {
+            top: number;
+            left: number;
+        };
+    };
+};
+type incrementalSnapshotEvent = {
+    type: EventType.IncrementalSnapshot;
+    data: incrementalData;
+};
+type metaEvent = {
+    type: EventType.Meta;
+    data: {
+        href: string;
+        width: number;
+        height: number;
+    };
+};
+type customEvent<T = unknown> = {
+    type: EventType.Custom;
+    data: {
+        tag: string;
+        payload: T;
+    };
+};
+type pluginEvent<T = unknown> = {
+    type: EventType.Plugin;
+    data: {
+        plugin: string;
+        payload: T;
+    };
+};
+declare enum IncrementalSource {
+    Mutation = 0,
+    MouseMove = 1,
+    MouseInteraction = 2,
+    Scroll = 3,
+    ViewportResize = 4,
+    Input = 5,
+    TouchMove = 6,
+    MediaInteraction = 7,
+    StyleSheetRule = 8,
+    CanvasMutation = 9,
+    Font = 10,
+    Log = 11,
+    Drag = 12,
+    StyleDeclaration = 13,
+    Selection = 14,
+    AdoptedStyleSheet = 15
+}
+type mutationData = {
+    source: IncrementalSource.Mutation;
+} & mutationCallbackParam;
+type mousemoveData = {
+    source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
+    positions: mousePosition[];
+};
+type mouseInteractionData = {
+    source: IncrementalSource.MouseInteraction;
+} & mouseInteractionParam;
+type scrollData = {
+    source: IncrementalSource.Scroll;
+} & scrollPosition;
+type viewportResizeData = {
+    source: IncrementalSource.ViewportResize;
+} & viewportResizeDimension;
+type inputData = {
+    source: IncrementalSource.Input;
+    id: number;
+} & inputValue;
+type mediaInteractionData = {
+    source: IncrementalSource.MediaInteraction;
+} & mediaInteractionParam;
+type styleSheetRuleData = {
+    source: IncrementalSource.StyleSheetRule;
+} & styleSheetRuleParam;
+type styleDeclarationData = {
+    source: IncrementalSource.StyleDeclaration;
+} & styleDeclarationParam;
+type canvasMutationData = {
+    source: IncrementalSource.CanvasMutation;
+} & canvasMutationParam;
+type fontData = {
+    source: IncrementalSource.Font;
+} & fontParam;
+type selectionData = {
+    source: IncrementalSource.Selection;
+} & selectionParam;
+type adoptedStyleSheetData = {
+    source: IncrementalSource.AdoptedStyleSheet;
+} & adoptedStyleSheetParam;
+type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData;
+type event = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;
+type eventWithTime = event & {
+    timestamp: number;
+    delay?: number;
+};
+type canvasEventWithTime = eventWithTime & {
+    type: EventType.IncrementalSnapshot;
+    data: canvasMutationData;
+};
+type blockClass = string | RegExp;
+type maskTextClass = string | RegExp;
+type SamplingStrategy = Partial<{
+    mousemove: boolean | number;
+    mousemoveCallback: number;
+    mouseInteraction: boolean | Record<string, boolean | undefined>;
+    scroll: number;
+    media: number;
+    input: 'all' | 'last';
+    canvas: 'all' | number;
+}>;
+interface ICrossOriginIframeMirror {
+    getId(iframe: HTMLIFrameElement, remoteId: number, parentToRemoteMap?: Map<number, number>, remoteToParentMap?: Map<number, number>): number;
+    getIds(iframe: HTMLIFrameElement, remoteId: number[]): number[];
+    getRemoteId(iframe: HTMLIFrameElement, parentId: number, map?: Map<number, number>): number;
+    getRemoteIds(iframe: HTMLIFrameElement, parentId: number[]): number[];
+    reset(iframe?: HTMLIFrameElement): void;
+}
+type RecordPlugin<TOptions = unknown> = {
+    name: string;
+    observer?: (cb: (...args: Array<unknown>) => void, win: IWindow, options: TOptions) => listenerHandler;
+    eventProcessor?: <TExtend>(event: eventWithTime) => eventWithTime & TExtend;
+    getMirror?: (mirrors: {
+        nodeMirror: Mirror$1;
+        crossOriginIframeMirror: ICrossOriginIframeMirror;
+        crossOriginIframeStyleMirror: ICrossOriginIframeMirror;
+    }) => void;
+    options: TOptions;
+};
+type hooksParam = {
+    mutation?: mutationCallBack;
+    mousemove?: mousemoveCallBack;
+    mouseInteraction?: mouseInteractionCallBack;
+    scroll?: scrollCallback;
+    viewportResize?: viewportResizeCallback;
+    input?: inputCallback;
+    mediaInteaction?: mediaInteractionCallback;
+    styleSheetRule?: styleSheetRuleCallback;
+    styleDeclaration?: styleDeclarationCallback;
+    canvasMutation?: canvasMutationCallback;
+    font?: fontCallback;
+    selection?: selectionCallback;
+};
+type textMutation = {
+    id: number;
+    value: string | null;
+};
+type styleOMValue = {
+    [key: string]: styleValueWithPriority | string | false;
+};
+type styleValueWithPriority = [string, string];
+type attributeMutation = {
+    id: number;
+    attributes: {
+        [key: string]: string | styleOMValue | null;
+    };
+};
+type removedNodeMutation = {
+    parentId: number;
+    id: number;
+    isShadow?: boolean;
+};
+type addedNodeMutation = {
+    parentId: number;
+    previousId?: number | null;
+    nextId: number | null;
+    node: serializedNodeWithId;
+};
+type mutationCallbackParam = {
+    texts: textMutation[];
+    attributes: attributeMutation[];
+    removes: removedNodeMutation[];
+    adds: addedNodeMutation[];
+    isAttachIframe?: true;
+};
+type mutationCallBack = (m: mutationCallbackParam) => void;
+type mousemoveCallBack = (p: mousePosition[], source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag) => void;
+type mousePosition = {
+    x: number;
+    y: number;
+    id: number;
+    timeOffset: number;
+};
+declare enum MouseInteractions {
+    MouseUp = 0,
+    MouseDown = 1,
+    Click = 2,
+    ContextMenu = 3,
+    DblClick = 4,
+    Focus = 5,
+    Blur = 6,
+    TouchStart = 7,
+    TouchMove_Departed = 8,
+    TouchEnd = 9,
+    TouchCancel = 10
+}
+declare enum PointerTypes {
+    Mouse = 0,
+    Pen = 1,
+    Touch = 2
+}
+declare enum CanvasContext {
+    '2D' = 0,
+    WebGL = 1,
+    WebGL2 = 2
+}
+type mouseInteractionParam = {
+    type: MouseInteractions;
+    id: number;
+    x: number;
+    y: number;
+    pointerType?: PointerTypes;
+};
+type mouseInteractionCallBack = (d: mouseInteractionParam) => void;
+type scrollPosition = {
+    id: number;
+    x: number;
+    y: number;
+};
+type scrollCallback = (p: scrollPosition) => void;
+type styleSheetAddRule = {
+    rule: string;
+    index?: number | number[];
+};
+type styleSheetDeleteRule = {
+    index: number | number[];
+};
+type styleSheetRuleParam = {
+    id?: number;
+    styleId?: number;
+    removes?: styleSheetDeleteRule[];
+    adds?: styleSheetAddRule[];
+    replace?: string;
+    replaceSync?: string;
+};
+type styleSheetRuleCallback = (s: styleSheetRuleParam) => void;
+type adoptedStyleSheetParam = {
+    id: number;
+    styles?: {
+        styleId: number;
+        rules: styleSheetAddRule[];
+    }[];
+    styleIds: number[];
+};
+type styleDeclarationParam = {
+    id?: number;
+    styleId?: number;
+    index: number[];
+    set?: {
+        property: string;
+        value: string | null;
+        priority: string | undefined;
+    };
+    remove?: {
+        property: string;
+    };
+};
+type styleDeclarationCallback = (s: styleDeclarationParam) => void;
+type canvasMutationCommand = {
+    property: string;
+    args: Array<unknown>;
+    setter?: true;
+};
+type canvasMutationParam = {
+    id: number;
+    type: CanvasContext;
+    commands: canvasMutationCommand[];
+} | ({
+    id: number;
+    type: CanvasContext;
+} & canvasMutationCommand);
+type canvasMutationCallback = (p: canvasMutationParam) => void;
+type fontParam = {
+    family: string;
+    fontSource: string;
+    buffer: boolean;
+    descriptors?: FontFaceDescriptors;
+};
+type fontCallback = (p: fontParam) => void;
+type viewportResizeDimension = {
+    width: number;
+    height: number;
+};
+type viewportResizeCallback = (d: viewportResizeDimension) => void;
+type inputValue = {
+    text: string;
+    isChecked: boolean;
+    userTriggered?: boolean;
+};
+type inputCallback = (v: inputValue & {
+    id: number;
+}) => void;
+declare const enum MediaInteractions {
+    Play = 0,
+    Pause = 1,
+    Seeked = 2,
+    VolumeChange = 3,
+    RateChange = 4
+}
+type mediaInteractionParam = {
+    type: MediaInteractions;
+    id: number;
+    currentTime?: number;
+    volume?: number;
+    muted?: boolean;
+    playbackRate?: number;
+};
+type mediaInteractionCallback = (p: mediaInteractionParam) => void;
+type DocumentDimension = {
+    x: number;
+    y: number;
+    relativeScale: number;
+    absoluteScale: number;
+};
+type SelectionRange = {
+    start: number;
+    startOffset: number;
+    end: number;
+    endOffset: number;
+};
+type selectionParam = {
+    ranges: Array<SelectionRange>;
+};
+type selectionCallback = (p: selectionParam) => void;
+type DeprecatedMirror = {
+    map: {
+        [key: number]: INode;
+    };
+    getId: (n: Node) => number;
+    getNode: (id: number) => INode | null;
+    removeNodeFromMap: (n: Node) => void;
+    has: (id: number) => boolean;
+    reset: () => void;
+};
+type throttleOptions = {
+    leading?: boolean;
+    trailing?: boolean;
+};
+type listenerHandler = () => void;
+type hookResetter = () => void;
+type playerMetaData = {
+    startTime: number;
+    endTime: number;
+    totalTime: number;
+};
+type actionWithDelay = {
+    doAction: () => void;
+    delay: number;
+};
+type Handler = (event?: unknown) => void;
+type Emitter$1 = {
+    on(type: string, handler: Handler): void;
+    emit(type: string, event?: unknown): void;
+    off(type: string, handler: Handler): void;
+};
+declare enum ReplayerEvents {
+    Start = "start",
+    Pause = "pause",
+    Resume = "resume",
+    Resize = "resize",
+    Finish = "finish",
+    FullsnapshotRebuilded = "fullsnapshot-rebuilded",
+    LoadStylesheetStart = "load-stylesheet-start",
+    LoadStylesheetEnd = "load-stylesheet-end",
+    SkipStart = "skip-start",
+    SkipEnd = "skip-end",
+    MouseInteraction = "mouse-interaction",
+    EventCast = "event-cast",
+    CustomEvent = "custom-event",
+    Flush = "flush",
+    StateChange = "state-change",
+    PlayBack = "play-back",
+    Destroy = "destroy"
+}
+type KeepIframeSrcFn = (src: string) => boolean;
+declare global {
+    interface Window {
+        FontFace: typeof FontFace;
+    }
+}
+type IWindow = Window & typeof globalThis;
+
+type PackFn = (event: eventWithTime) => string;
+type UnpackFn = (raw: string) => eventWithTime;
+
+interface IRRNode {
+    parentElement: IRRNode | null;
+    parentNode: IRRNode | null;
+    ownerDocument: IRRDocument;
+    readonly childNodes: IRRNode[];
+    readonly ELEMENT_NODE: number;
+    readonly TEXT_NODE: number;
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly RRNodeType: NodeType;
+    firstChild: IRRNode | null;
+    lastChild: IRRNode | null;
+    previousSibling: IRRNode | null;
+    nextSibling: IRRNode | null;
+    textContent: string | null;
+    contains(node: IRRNode): boolean;
+    appendChild(newChild: IRRNode): IRRNode;
+    insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+    removeChild(node: IRRNode): IRRNode;
+    toString(): string;
+}
+interface IRRDocument extends IRRNode {
+    documentElement: IRRElement | null;
+    body: IRRElement | null;
+    head: IRRElement | null;
+    implementation: IRRDocument;
+    firstElementChild: IRRElement | null;
+    readonly nodeName: '#document';
+    compatMode: 'BackCompat' | 'CSS1Compat';
+    createDocument(_namespace: string | null, _qualifiedName: string | null, _doctype?: DocumentType | null): IRRDocument;
+    createDocumentType(qualifiedName: string, publicId: string, systemId: string): IRRDocumentType;
+    createElement(tagName: string): IRRElement;
+    createElementNS(_namespaceURI: string, qualifiedName: string): IRRElement;
+    createTextNode(data: string): IRRText;
+    createComment(data: string): IRRComment;
+    createCDATASection(data: string): IRRCDATASection;
+    open(): void;
+    close(): void;
+    write(content: string): void;
+}
+interface IRRElement extends IRRNode {
+    tagName: string;
+    attributes: Record<string, string>;
+    shadowRoot: IRRElement | null;
+    scrollLeft?: number;
+    scrollTop?: number;
+    id: string;
+    className: string;
+    classList: ClassList;
+    style: CSSStyleDeclaration;
+    attachShadow(init: ShadowRootInit): IRRElement;
+    getAttribute(name: string): string | null;
+    setAttribute(name: string, attribute: string): void;
+    setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
+    removeAttribute(name: string): void;
+    dispatchEvent(event: Event): boolean;
+}
+interface IRRDocumentType extends IRRNode {
+    readonly name: string;
+    readonly publicId: string;
+    readonly systemId: string;
+}
+interface IRRText extends IRRNode {
+    readonly nodeName: '#text';
+    data: string;
+}
+interface IRRComment extends IRRNode {
+    readonly nodeName: '#comment';
+    data: string;
+}
+interface IRRCDATASection extends IRRNode {
+    readonly nodeName: '#cdata-section';
+    data: string;
+}
+declare class BaseRRNode implements IRRNode {
+    parentElement: IRRNode | null;
+    parentNode: IRRNode | null;
+    ownerDocument: IRRDocument;
+    firstChild: IRRNode | null;
+    lastChild: IRRNode | null;
+    previousSibling: IRRNode | null;
+    nextSibling: IRRNode | null;
+    textContent: string | null;
+    readonly ELEMENT_NODE: number;
+    readonly TEXT_NODE: number;
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly RRNodeType: NodeType;
+    constructor(..._args: any[]);
+    get childNodes(): IRRNode[];
+    contains(node: IRRNode): boolean;
+    appendChild(_newChild: IRRNode): IRRNode;
+    insertBefore(_newChild: IRRNode, _refChild: IRRNode | null): IRRNode;
+    removeChild(_node: IRRNode): IRRNode;
+    toString(): string;
+}
+declare class ClassList {
+    private onChange;
+    classes: string[];
+    constructor(classText?: string, onChange?: ((newClassText: string) => void) | undefined);
+    add: (...classNames: string[]) => void;
+    remove: (...classNames: string[]) => void;
+}
+type CSSStyleDeclaration = Record<string, string> & {
+    setProperty: (name: string, value: string | null, priority?: string | null) => void;
+    removeProperty: (name: string) => string;
+};
+
+declare const RRDocument_base: {
+    new (...args: any[]): {
+        readonly nodeType: number;
+        readonly nodeName: "#document";
+        readonly compatMode: "BackCompat" | "CSS1Compat";
+        readonly RRNodeType: NodeType.Document;
+        readonly documentElement: IRRElement | null;
+        readonly body: IRRElement | null;
+        readonly head: IRRElement | null;
+        readonly implementation: IRRDocument;
+        readonly firstElementChild: IRRElement | null;
+        appendChild(newChild: IRRNode): IRRNode;
+        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+        removeChild(node: IRRNode): IRRNode;
+        open(): void;
+        close(): void;
+        write(content: string): void;
+        createDocument(_namespace: string | null, _qualifiedName: string | null, _doctype?: DocumentType | null | undefined): IRRDocument;
+        createDocumentType(qualifiedName: string, publicId: string, systemId: string): IRRDocumentType;
+        createElement(tagName: string): IRRElement;
+        createElementNS(_namespaceURI: string, qualifiedName: string): IRRElement;
+        createTextNode(data: string): IRRText;
+        createComment(data: string): IRRComment;
+        createCDATASection(data: string): IRRCDATASection;
+        toString(): string;
+        parentElement: IRRNode | null;
+        parentNode: IRRNode | null;
+        ownerDocument: IRRDocument;
+        readonly childNodes: IRRNode[];
+        readonly ELEMENT_NODE: number;
+        readonly TEXT_NODE: number;
+        firstChild: IRRNode | null;
+        lastChild: IRRNode | null;
+        previousSibling: IRRNode | null;
+        nextSibling: IRRNode | null;
+        textContent: string | null;
+        contains(node: IRRNode): boolean;
+    };
+} & typeof BaseRRNode;
+declare class RRDocument extends RRDocument_base {
+    private UNSERIALIZED_STARTING_ID;
+    private _unserializedId;
+    get unserializedId(): number;
+    mirror: Mirror;
+    scrollData: scrollData | null;
+    constructor(mirror?: Mirror);
+    createDocument(_namespace: string | null, _qualifiedName: string | null, _doctype?: DocumentType | null): RRDocument;
+    createDocumentType(qualifiedName: string, publicId: string, systemId: string): {
+        readonly nodeType: number;
+        readonly RRNodeType: NodeType.DocumentType;
+        readonly nodeName: string;
+        readonly name: string;
+        readonly publicId: string;
+        readonly systemId: string;
+        toString(): string;
+        parentElement: IRRNode | null;
+        parentNode: IRRNode | null;
+        ownerDocument: IRRDocument;
+        readonly childNodes: IRRNode[];
+        readonly ELEMENT_NODE: number;
+        readonly TEXT_NODE: number;
+        firstChild: IRRNode | null;
+        lastChild: IRRNode | null;
+        previousSibling: IRRNode | null;
+        nextSibling: IRRNode | null;
+        textContent: string | null;
+        contains(node: IRRNode): boolean;
+        appendChild(newChild: IRRNode): IRRNode;
+        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+        removeChild(node: IRRNode): IRRNode;
+    } & BaseRRNode;
+    createElement<K extends keyof HTMLElementTagNameMap>(tagName: K): RRElementType<K>;
+    createElement(tagName: string): RRElement;
+    createComment(data: string): {
+        readonly nodeType: number;
+        readonly nodeName: "#comment";
+        readonly RRNodeType: NodeType.Comment;
+        data: string;
+        textContent: string;
+        toString(): string;
+        parentElement: IRRNode | null;
+        parentNode: IRRNode | null;
+        ownerDocument: IRRDocument;
+        readonly childNodes: IRRNode[];
+        readonly ELEMENT_NODE: number;
+        readonly TEXT_NODE: number;
+        firstChild: IRRNode | null;
+        lastChild: IRRNode | null;
+        previousSibling: IRRNode | null;
+        nextSibling: IRRNode | null;
+        contains(node: IRRNode): boolean;
+        appendChild(newChild: IRRNode): IRRNode;
+        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+        removeChild(node: IRRNode): IRRNode;
+    } & BaseRRNode;
+    createCDATASection(data: string): {
+        readonly nodeName: "#cdata-section";
+        readonly nodeType: number;
+        readonly RRNodeType: NodeType.CDATA;
+        data: string;
+        textContent: string;
+        toString(): string;
+        parentElement: IRRNode | null;
+        parentNode: IRRNode | null;
+        ownerDocument: IRRDocument;
+        readonly childNodes: IRRNode[];
+        readonly ELEMENT_NODE: number;
+        readonly TEXT_NODE: number;
+        firstChild: IRRNode | null;
+        lastChild: IRRNode | null;
+        previousSibling: IRRNode | null;
+        nextSibling: IRRNode | null;
+        contains(node: IRRNode): boolean;
+        appendChild(newChild: IRRNode): IRRNode;
+        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+        removeChild(node: IRRNode): IRRNode;
+    } & BaseRRNode;
+    createTextNode(data: string): {
+        readonly nodeType: number;
+        readonly nodeName: "#text";
+        readonly RRNodeType: NodeType.Text;
+        data: string;
+        textContent: string;
+        toString(): string;
+        parentElement: IRRNode | null;
+        parentNode: IRRNode | null;
+        ownerDocument: IRRDocument;
+        readonly childNodes: IRRNode[];
+        readonly ELEMENT_NODE: number;
+        readonly TEXT_NODE: number;
+        firstChild: IRRNode | null;
+        lastChild: IRRNode | null;
+        previousSibling: IRRNode | null;
+        nextSibling: IRRNode | null;
+        contains(node: IRRNode): boolean;
+        appendChild(newChild: IRRNode): IRRNode;
+        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+        removeChild(node: IRRNode): IRRNode;
+    } & BaseRRNode;
+    destroyTree(): void;
+    open(): void;
+}
+declare const RRElement_base: {
+    new (tagName: string): {
+        readonly nodeType: number;
+        readonly RRNodeType: NodeType.Element;
+        readonly nodeName: string;
+        tagName: string;
+        attributes: Record<string, string>;
+        shadowRoot: IRRElement | null;
+        scrollLeft?: number | undefined;
+        scrollTop?: number | undefined;
+        textContent: string;
+        readonly classList: ClassList;
+        readonly id: string;
+        readonly className: string;
+        readonly style: CSSStyleDeclaration;
+        getAttribute(name: string): string | null;
+        setAttribute(name: string, attribute: string): void;
+        setAttributeNS(_namespace: string | null, qualifiedName: string, value: string): void;
+        removeAttribute(name: string): void;
+        appendChild(newChild: IRRNode): IRRNode;
+        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+        removeChild(node: IRRNode): IRRNode;
+        attachShadow(_init: ShadowRootInit): IRRElement;
+        dispatchEvent(_event: Event): boolean;
+        toString(): string;
+        parentElement: IRRNode | null;
+        parentNode: IRRNode | null;
+        ownerDocument: IRRDocument;
+        readonly childNodes: IRRNode[];
+        readonly ELEMENT_NODE: number;
+        readonly TEXT_NODE: number;
+        firstChild: IRRNode | null;
+        lastChild: IRRNode | null;
+        previousSibling: IRRNode | null;
+        nextSibling: IRRNode | null;
+        contains(node: IRRNode): boolean;
+    };
+} & typeof BaseRRNode;
+declare class RRElement extends RRElement_base {
+    inputData: inputData | null;
+    scrollData: scrollData | null;
+}
+declare const RRMediaElement_base: {
+    new (...args: any[]): {
+        currentTime?: number | undefined;
+        volume?: number | undefined;
+        paused?: boolean | undefined;
+        muted?: boolean | undefined;
+        playbackRate?: number | undefined;
+        attachShadow(_init: ShadowRootInit): IRRElement;
+        play(): void;
+        pause(): void;
+        tagName: string;
+        attributes: Record<string, string>;
+        shadowRoot: IRRElement | null;
+        scrollLeft?: number | undefined;
+        scrollTop?: number | undefined;
+        id: string;
+        className: string;
+        classList: ClassList;
+        style: CSSStyleDeclaration;
+        getAttribute(name: string): string | null;
+        setAttribute(name: string, attribute: string): void;
+        setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
+        removeAttribute(name: string): void;
+        dispatchEvent(event: Event): boolean;
+        parentElement: IRRNode | null;
+        parentNode: IRRNode | null;
+        ownerDocument: IRRDocument;
+        readonly childNodes: IRRNode[];
+        readonly ELEMENT_NODE: number;
+        readonly TEXT_NODE: number;
+        readonly nodeType: number;
+        readonly nodeName: string;
+        readonly RRNodeType: NodeType;
+        firstChild: IRRNode | null;
+        lastChild: IRRNode | null;
+        previousSibling: IRRNode | null;
+        nextSibling: IRRNode | null;
+        textContent: string | null;
+        contains(node: IRRNode): boolean;
+        appendChild(newChild: IRRNode): IRRNode;
+        insertBefore(newChild: IRRNode, refChild: IRRNode | null): IRRNode;
+        removeChild(node: IRRNode): IRRNode;
+        toString(): string;
+    };
+} & typeof RRElement;
+declare class RRMediaElement extends RRMediaElement_base {
+}
+declare class RRCanvasElement extends RRElement implements IRRElement {
+    rr_dataURL: string | null;
+    canvasMutations: {
+        event: canvasEventWithTime;
+        mutation: canvasMutationData;
+    }[];
+    getContext(): RenderingContext | null;
+}
+declare class RRStyleElement extends RRElement {
+    rules: (styleSheetRuleData | styleDeclarationData)[];
+}
+declare class RRIFrameElement extends RRElement {
+    contentDocument: RRDocument;
+    constructor(upperTagName: string, mirror: Mirror);
+}
+interface RRElementTagNameMap {
+    audio: RRMediaElement;
+    canvas: RRCanvasElement;
+    iframe: RRIFrameElement;
+    style: RRStyleElement;
+    video: RRMediaElement;
+}
+type RRElementType<K extends keyof HTMLElementTagNameMap> = K extends keyof RRElementTagNameMap ? RRElementTagNameMap[K] : RRElement;
+declare class Mirror implements IMirror<BaseRRNode> {
+    private idNodeMap;
+    private nodeMetaMap;
+    getId(n: BaseRRNode | undefined | null): number;
+    getNode(id: number): BaseRRNode | null;
+    getIds(): number[];
+    getMeta(n: BaseRRNode): serializedNodeWithId | null;
+    removeNodeFromMap(n: BaseRRNode): void;
+    has(id: number): boolean;
+    hasNode(node: BaseRRNode): boolean;
+    add(n: BaseRRNode, meta: serializedNodeWithId): void;
+    replace(id: number, n: BaseRRNode): void;
+    reset(): void;
+}
+
+declare function on(type: string, fn: EventListenerOrEventListenerObject, target?: Document | IWindow): listenerHandler;
+declare let _mirror: DeprecatedMirror;
+declare function throttle<T>(func: (arg: T) => void, wait: number, options?: throttleOptions): (...args: T[]) => void;
+declare function hookSetter<T>(target: T, key: string | number | symbol, d: PropertyDescriptor, isRevoked?: boolean, win?: Window & typeof globalThis): hookResetter;
+declare function patch(source: {
+    [key: string]: any;
+}, name: string, replacement: (...args: unknown[]) => unknown): () => void;
+declare let nowTimestamp: () => number;
+
+declare function getWindowScroll(win: Window): {
+    left: number;
+    top: number;
+};
+declare function getWindowHeight(): number;
+declare function getWindowWidth(): number;
+declare function isBlocked(node: Node | null, blockClass: blockClass, blockSelector: string | null, checkAncestors: boolean): boolean;
+declare function isSerialized(n: Node, mirror: Mirror$1): boolean;
+declare function isIgnored(n: Node, mirror: Mirror$1): boolean;
+declare function isAncestorRemoved(target: Node, mirror: Mirror$1): boolean;
+declare function legacy_isTouchEvent(event: MouseEvent | TouchEvent | PointerEvent): event is TouchEvent;
+declare function polyfill(win?: Window & typeof globalThis): void;
+type ResolveTree = {
+    value: addedNodeMutation;
+    children: ResolveTree[];
+    parent: ResolveTree | null;
+};
+declare function queueToResolveTrees(queue: addedNodeMutation[]): ResolveTree[];
+declare function iterateResolveTree(tree: ResolveTree, cb: (mutation: addedNodeMutation) => unknown): void;
+type AppendedIframe = {
+    mutationInQueue: addedNodeMutation;
+    builtNode: HTMLIFrameElement | RRIFrameElement;
+};
+declare function isSerializedIframe<TNode extends Node | BaseRRNode>(n: TNode, mirror: IMirror<TNode>): boolean;
+declare function isSerializedStylesheet<TNode extends Node | BaseRRNode>(n: TNode, mirror: IMirror<TNode>): boolean;
+declare function getBaseDimension(node: Node, rootIframe: Node): DocumentDimension;
+declare function hasShadowRoot<T extends Node | BaseRRNode>(n: T): n is T & {
+    shadowRoot: ShadowRoot;
+};
+declare function getNestedRule(rules: CSSRuleList, position: number[]): CSSGroupingRule;
+declare function getPositionsAndIndex(nestedIndex: number[]): {
+    positions: number[];
+    index: number | undefined;
+};
+declare function uniqueTextMutations(mutations: textMutation[]): textMutation[];
+declare class StyleSheetMirror {
+    private id;
+    private styleIDMap;
+    private idStyleMap;
+    getId(stylesheet: CSSStyleSheet): number;
+    has(stylesheet: CSSStyleSheet): boolean;
+    add(stylesheet: CSSStyleSheet, id?: number): number;
+    getStyle(id: number): CSSStyleSheet | null;
+    reset(): void;
+    generateId(): number;
+}
+declare function getShadowHost(n: Node): Element | null;
+declare function getRootShadowHost(n: Node): Node;
+declare function shadowHostInDom(n: Node): boolean;
+declare function inDom(n: Node): boolean;
+
+type utils_d_AppendedIframe = AppendedIframe;
+type utils_d_StyleSheetMirror = StyleSheetMirror;
+declare const utils_d_StyleSheetMirror: typeof StyleSheetMirror;
+declare const utils_d__mirror: typeof _mirror;
+declare const utils_d_getBaseDimension: typeof getBaseDimension;
+declare const utils_d_getNestedRule: typeof getNestedRule;
+declare const utils_d_getPositionsAndIndex: typeof getPositionsAndIndex;
+declare const utils_d_getRootShadowHost: typeof getRootShadowHost;
+declare const utils_d_getShadowHost: typeof getShadowHost;
+declare const utils_d_getWindowHeight: typeof getWindowHeight;
+declare const utils_d_getWindowScroll: typeof getWindowScroll;
+declare const utils_d_getWindowWidth: typeof getWindowWidth;
+declare const utils_d_hasShadowRoot: typeof hasShadowRoot;
+declare const utils_d_hookSetter: typeof hookSetter;
+declare const utils_d_inDom: typeof inDom;
+declare const utils_d_isAncestorRemoved: typeof isAncestorRemoved;
+declare const utils_d_isBlocked: typeof isBlocked;
+declare const utils_d_isIgnored: typeof isIgnored;
+declare const utils_d_isSerialized: typeof isSerialized;
+declare const utils_d_isSerializedIframe: typeof isSerializedIframe;
+declare const utils_d_isSerializedStylesheet: typeof isSerializedStylesheet;
+declare const utils_d_iterateResolveTree: typeof iterateResolveTree;
+declare const utils_d_legacy_isTouchEvent: typeof legacy_isTouchEvent;
+declare const utils_d_nowTimestamp: typeof nowTimestamp;
+declare const utils_d_on: typeof on;
+declare const utils_d_patch: typeof patch;
+declare const utils_d_polyfill: typeof polyfill;
+declare const utils_d_queueToResolveTrees: typeof queueToResolveTrees;
+declare const utils_d_shadowHostInDom: typeof shadowHostInDom;
+declare const utils_d_throttle: typeof throttle;
+declare const utils_d_uniqueTextMutations: typeof uniqueTextMutations;
+declare namespace utils_d {
+  export {
+    utils_d_AppendedIframe as AppendedIframe,
+    utils_d_StyleSheetMirror as StyleSheetMirror,
+    utils_d__mirror as _mirror,
+    utils_d_getBaseDimension as getBaseDimension,
+    utils_d_getNestedRule as getNestedRule,
+    utils_d_getPositionsAndIndex as getPositionsAndIndex,
+    utils_d_getRootShadowHost as getRootShadowHost,
+    utils_d_getShadowHost as getShadowHost,
+    utils_d_getWindowHeight as getWindowHeight,
+    utils_d_getWindowScroll as getWindowScroll,
+    utils_d_getWindowWidth as getWindowWidth,
+    utils_d_hasShadowRoot as hasShadowRoot,
+    utils_d_hookSetter as hookSetter,
+    utils_d_inDom as inDom,
+    utils_d_isAncestorRemoved as isAncestorRemoved,
+    utils_d_isBlocked as isBlocked,
+    utils_d_isIgnored as isIgnored,
+    utils_d_isSerialized as isSerialized,
+    utils_d_isSerializedIframe as isSerializedIframe,
+    utils_d_isSerializedStylesheet as isSerializedStylesheet,
+    utils_d_iterateResolveTree as iterateResolveTree,
+    utils_d_legacy_isTouchEvent as legacy_isTouchEvent,
+    utils_d_nowTimestamp as nowTimestamp,
+    utils_d_on as on,
+    utils_d_patch as patch,
+    utils_d_polyfill as polyfill,
+    utils_d_queueToResolveTrees as queueToResolveTrees,
+    utils_d_shadowHostInDom as shadowHostInDom,
+    utils_d_throttle as throttle,
+    utils_d_uniqueTextMutations as uniqueTextMutations,
+  };
+}
+
+declare class Timer {
+    timeOffset: number;
+    speed: number;
+    private actions;
+    private raf;
+    private lastTimestamp;
+    constructor(actions: actionWithDelay[] | undefined, config: {
+        speed: number;
+    });
+    addAction(action: actionWithDelay): void;
+    start(): void;
+    private rafCheck;
+    clear(): void;
+    setSpeed(speed: number): void;
+    isActive(): boolean;
+    private findActionIndex;
+}
+
+declare enum InterpreterStatus {
+    NotStarted = 0,
+    Running = 1,
+    Stopped = 2
+}
+declare type SingleOrArray<T> = T[] | T;
+interface EventObject {
+    type: string;
+}
+declare type InitEvent = {
+    type: 'xstate.init';
+};
+declare namespace StateMachine {
+    type Action<TContext extends object, TEvent extends EventObject> = string | AssignActionObject<TContext, TEvent> | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent>;
+    type ActionMap<TContext extends object, TEvent extends EventObject> = Record<string, Exclude<Action<TContext, TEvent>, string>>;
+    interface ActionObject<TContext extends object, TEvent extends EventObject> {
+        type: string;
+        exec?: ActionFunction<TContext, TEvent>;
+        [key: string]: any;
+    }
+    type ActionFunction<TContext extends object, TEvent extends EventObject> = (context: TContext, event: TEvent | InitEvent) => void;
+    type AssignAction = 'xstate.assign';
+    interface AssignActionObject<TContext extends object, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+        type: AssignAction;
+        assignment: Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent>;
+    }
+    type Transition<TContext extends object, TEvent extends EventObject> = string | {
+        target?: string;
+        actions?: SingleOrArray<Action<TContext, TEvent>>;
+        cond?: (context: TContext, event: TEvent) => boolean;
+    };
+    interface State<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext>> {
+        value: TState['value'];
+        context: TContext;
+        actions: Array<ActionObject<TContext, TEvent>>;
+        changed?: boolean | undefined;
+        matches: <TSV extends TState['value']>(value: TSV) => this is TState extends {
+            value: TSV;
+        } ? TState & {
+            value: TSV;
+        } : never;
+    }
+    type AnyState = State<any, any, any>;
+    interface Config<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext> = {
+        value: any;
+        context: TContext;
+    }> {
+        id?: string;
+        initial: string;
+        context?: TContext;
+        states: {
+            [key in TState['value']]: {
+                on?: {
+                    [K in TEvent['type']]?: SingleOrArray<Transition<TContext, TEvent extends {
+                        type: K;
+                    } ? TEvent : never>>;
+                };
+                exit?: SingleOrArray<Action<TContext, TEvent>>;
+                entry?: SingleOrArray<Action<TContext, TEvent>>;
+            };
+        };
+    }
+    interface Machine<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext>> {
+        config: StateMachine.Config<TContext, TEvent, TState>;
+        initialState: State<TContext, TEvent, TState>;
+        transition: (state: string | State<TContext, TEvent, TState>, event: TEvent['type'] | TEvent) => State<TContext, TEvent, TState>;
+    }
+    type StateListener<T extends AnyState> = (state: T) => void;
+    interface Service<TContext extends object, TEvent extends EventObject, TState extends Typestate<TContext> = {
+        value: any;
+        context: TContext;
+    }> {
+        send: (event: TEvent | TEvent['type']) => void;
+        subscribe: (listener: StateListener<State<TContext, TEvent, TState>>) => {
+            unsubscribe: () => void;
+        };
+        start: (initialState?: TState['value'] | {
+            context: TContext;
+            value: TState['value'];
+        }) => Service<TContext, TEvent, TState>;
+        stop: () => Service<TContext, TEvent, TState>;
+        readonly status: InterpreterStatus;
+        readonly state: State<TContext, TEvent, TState>;
+    }
+    type Assigner<TContext extends object, TEvent extends EventObject> = (context: TContext, event: TEvent) => Partial<TContext>;
+    type PropertyAssigner<TContext extends object, TEvent extends EventObject> = {
+        [K in keyof TContext]?: ((context: TContext, event: TEvent) => TContext[K]) | TContext[K];
+    };
+}
+interface Typestate<TContext extends object> {
+    value: string;
+    context: TContext;
+}
+
+type PlayerContext = {
+    events: eventWithTime[];
+    timer: Timer;
+    timeOffset: number;
+    baselineTime: number;
+    lastPlayedEvent: eventWithTime | null;
+};
+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: 'END';
+};
+type PlayerState = {
+    value: 'playing';
+    context: PlayerContext;
+} | {
+    value: 'paused';
+    context: PlayerContext;
+} | {
+    value: 'live';
+    context: PlayerContext;
+};
+type PlayerAssets = {
+    emitter: Emitter$1;
+    applyEventsSynchronously(events: Array<eventWithTime>): void;
+    getCastFn(event: eventWithTime, isSync: boolean): () => void;
+};
+declare function createPlayerService(context: PlayerContext, { getCastFn, applyEventsSynchronously, emitter }: PlayerAssets): StateMachine.Service<PlayerContext, PlayerEvent, PlayerState>;
+type SpeedContext = {
+    normalSpeed: playerConfig['speed'];
+    timer: Timer;
+};
+type SpeedEvent = {
+    type: 'FAST_FORWARD';
+    payload: {
+        speed: playerConfig['speed'];
+    };
+} | {
+    type: 'BACK_TO_NORMAL';
+} | {
+    type: 'SET_SPEED';
+    payload: {
+        speed: playerConfig['speed'];
+    };
+};
+type SpeedState = {
+    value: 'normal';
+    context: SpeedContext;
+} | {
+    value: 'skipping';
+    context: SpeedContext;
+};
+declare function createSpeedService(context: SpeedContext): StateMachine.Service<SpeedContext, SpeedEvent, SpeedState>;
+
+declare class Replayer {
+    wrapper: HTMLDivElement;
+    iframe: HTMLIFrameElement;
+    service: ReturnType<typeof createPlayerService>;
+    speedService: ReturnType<typeof createSpeedService>;
+    get timer(): Timer;
+    config: playerConfig;
+    usingVirtualDom: boolean;
+    virtualDom: RRDocument;
+    private mouse;
+    private mouseTail;
+    private tailPositions;
+    private emitter;
+    private nextUserInteractionEvent;
+    private legacy_missingNodeRetryMap;
+    private cache;
+    private imageMap;
+    private canvasEventMap;
+    private mirror;
+    private styleMirror;
+    private firstFullSnapshot;
+    private newDocumentQueue;
+    private mousePos;
+    private touchActive;
+    private lastMouseDownEvent;
+    private lastHoveredRootNode;
+    private lastSelectionData;
+    private constructedStyleMutations;
+    private adoptedStyleSheets;
+    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;
+    getMetaData(): playerMetaData;
+    getCurrentTime(): number;
+    getTimeOffset(): number;
+    getMirror(): Mirror$1;
+    play(timeOffset?: number): void;
+    pause(timeOffset?: number): void;
+    resume(timeOffset?: number): void;
+    destroy(): void;
+    startLive(baselineTime?: number): void;
+    addEvent(rawEvent: eventWithTime | string): void;
+    enableInteract(): void;
+    disableInteract(): void;
+    resetCache(): void;
+    private setupDom;
+    private handleResize;
+    private applyEventsSynchronously;
+    private getCastFn;
+    private rebuildFullSnapshot;
+    private insertStyleRules;
+    private attachDocumentToIframe;
+    private collectIframeAndAttachDocument;
+    private waitForStylesheetLoad;
+    private preloadAllImages;
+    private preloadImages;
+    private deserializeAndPreloadCanvasEvents;
+    private applyIncremental;
+    private applyMutation;
+    private applyScroll;
+    private applyInput;
+    private applySelection;
+    private applyStyleSheetMutation;
+    private applyStyleSheetRule;
+    private applyStyleDeclaration;
+    private applyAdoptedStyleSheet;
+    private legacy_resolveMissingNode;
+    private moveAndHover;
+    private drawMouseTail;
+    private hoverElements;
+    private isUserInteraction;
+    private backToNormal;
+    private warnNodeNotFound;
+    private warnCanvasMutationFailed;
+    private debugNodeNotFound;
+    private warn;
+    private debug;
+}
+
+type recordOptions<T> = {
+    emit?: (e: T, isCheckout?: boolean) => void;
+    checkoutEveryNth?: number;
+    checkoutEveryNms?: number;
+    blockClass?: blockClass;
+    blockSelector?: string;
+    ignoreClass?: string;
+    ignoreSelector?: string;
+    maskTextClass?: maskTextClass;
+    maskTextSelector?: string;
+    maskAllInputs?: boolean;
+    maskInputOptions?: MaskInputOptions;
+    maskInputFn?: MaskInputFn;
+    maskTextFn?: MaskTextFn;
+    slimDOMOptions?: SlimDOMOptions | 'all' | true;
+    ignoreCSSAttributes?: Set<string>;
+    inlineStylesheet?: boolean;
+    hooks?: hooksParam;
+    packFn?: PackFn;
+    sampling?: SamplingStrategy;
+    dataURLOptions?: DataURLOptions;
+    recordCanvas?: boolean;
+    recordCrossOriginIframes?: boolean;
+    recordAfter?: 'DOMContentLoaded' | 'load';
+    userTriggeredOnInput?: boolean;
+    collectFonts?: boolean;
+    inlineImages?: boolean;
+    plugins?: RecordPlugin[];
+    mousemoveWait?: number;
+    keepIframeSrcFn?: KeepIframeSrcFn;
+    errorHandler?: ErrorHandler;
+};
+type ReplayPlugin = {
+    handler?: (event: eventWithTime, isSync: boolean, context: {
+        replayer: Replayer;
+    }) => void;
+    onBuild?: (node: Node | BaseRRNode, context: {
+        id: number;
+        replayer: Replayer;
+    }) => void;
+    getMirror?: (mirrors: {
+        nodeMirror: Mirror$1;
+    }) => void;
+};
+type playerConfig = {
+    speed: number;
+    maxSpeed: number;
+    root: Element;
+    loadTimeout: number;
+    skipInactive: boolean;
+    showWarning: boolean;
+    showDebug: boolean;
+    blockClass: string;
+    liveMode: boolean;
+    insertStyleRules: string[];
+    triggerFocus: boolean;
+    UNSAFE_replayCanvas: boolean;
+    pauseAnimation?: boolean;
+    mouseTail: boolean | {
+        duration?: number;
+        lineCap?: string;
+        lineWidth?: number;
+        strokeStyle?: string;
+    };
+    unpackFn?: UnpackFn;
+    useVirtualDom: boolean;
+    logger: {
+        log: (...args: Parameters<typeof console.log>) => void;
+        warn: (...args: Parameters<typeof console.warn>) => void;
+    };
+    plugins?: ReplayPlugin[];
+};
+declare global {
+    interface Window {
+        FontFace: typeof FontFace;
+    }
+}
+type ErrorHandler = (error: unknown) => void | boolean;
+
+declare function record<T = eventWithTime>(options?: recordOptions<T>): listenerHandler | undefined;
+declare namespace record {
+    var addCustomEvent: <T>(tag: string, payload: T) => void;
+    var freezePage: () => void;
+    var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
+    var mirror: Mirror$1;
+}
+
+declare const addCustomEvent: <T>(tag: string, payload: T) => void;
+declare const freezePage: () => void;
+
+declare const pack: PackFn;
+
+declare const unpack: UnpackFn;
+
+type StringifyOptions = {
+    stringLengthLimit?: number;
+    numOfKeysLimit: number;
+    depthOfLimit: number;
+};
+type LogRecordOptions = {
+    level?: LogLevel[];
+    lengthThreshold?: number;
+    stringifyOptions?: StringifyOptions;
+    logger?: Logger | 'console';
+};
+type LogData = {
+    level: LogLevel;
+    trace: string[];
+    payload: string[];
+};
+type Logger = {
+    assert?: typeof console.assert;
+    clear?: typeof console.clear;
+    count?: typeof console.count;
+    countReset?: typeof console.countReset;
+    debug?: typeof console.debug;
+    dir?: typeof console.dir;
+    dirxml?: typeof console.dirxml;
+    error?: typeof console.error;
+    group?: typeof console.group;
+    groupCollapsed?: typeof console.groupCollapsed;
+    groupEnd?: () => void;
+    info?: typeof console.info;
+    log?: typeof console.log;
+    table?: typeof console.table;
+    time?: typeof console.time;
+    timeEnd?: typeof console.timeEnd;
+    timeLog?: typeof console.timeLog;
+    trace?: typeof console.trace;
+    warn?: typeof console.warn;
+};
+type LogLevel = keyof Logger;
+declare const PLUGIN_NAME = "rrweb/console@1";
+declare const getRecordConsolePlugin: (options?: LogRecordOptions) => RecordPlugin;
+
+type ReplayLogger = Partial<Record<LogLevel, (data: LogData) => void>>;
+type LogReplayConfig = {
+    level?: LogLevel[];
+    replayLogger?: ReplayLogger;
+};
+declare const getReplayConsolePlugin: (options?: LogReplayConfig) => ReplayPlugin;
+
+type rrweb_EventType = EventType;
+declare const rrweb_EventType: typeof EventType;
+type rrweb_IncrementalSource = IncrementalSource;
+declare const rrweb_IncrementalSource: typeof IncrementalSource;
+type rrweb_LogData = LogData;
+type rrweb_LogLevel = LogLevel;
+type rrweb_Logger = Logger;
+type rrweb_MouseInteractions = MouseInteractions;
+declare const rrweb_MouseInteractions: typeof MouseInteractions;
+declare const rrweb_PLUGIN_NAME: typeof PLUGIN_NAME;
+type rrweb_Replayer = Replayer;
+declare const rrweb_Replayer: typeof Replayer;
+type rrweb_ReplayerEvents = ReplayerEvents;
+declare const rrweb_ReplayerEvents: typeof ReplayerEvents;
+type rrweb_StringifyOptions = StringifyOptions;
+declare const rrweb_addCustomEvent: typeof addCustomEvent;
+declare const rrweb_freezePage: typeof freezePage;
+declare const rrweb_getRecordConsolePlugin: typeof getRecordConsolePlugin;
+declare const rrweb_getReplayConsolePlugin: typeof getReplayConsolePlugin;
+declare const rrweb_pack: typeof pack;
+declare const rrweb_record: typeof record;
+type rrweb_recordOptions<T> = recordOptions<T>;
+declare const rrweb_unpack: typeof unpack;
+declare namespace rrweb {
+  export {
+    rrweb_EventType as EventType,
+    rrweb_IncrementalSource as IncrementalSource,
+    rrweb_LogData as LogData,
+    rrweb_LogLevel as LogLevel,
+    rrweb_Logger as Logger,
+    rrweb_MouseInteractions as MouseInteractions,
+    rrweb_PLUGIN_NAME as PLUGIN_NAME,
+    rrweb_Replayer as Replayer,
+    rrweb_ReplayerEvents as ReplayerEvents,
+    rrweb_StringifyOptions as StringifyOptions,
+    rrweb_addCustomEvent as addCustomEvent,
+    rrweb_freezePage as freezePage,
+    rrweb_getRecordConsolePlugin as getRecordConsolePlugin,
+    rrweb_getReplayConsolePlugin as getReplayConsolePlugin,
+    _mirror as mirror,
+    rrweb_pack as pack,
+    rrweb_record as record,
+    rrweb_recordOptions as recordOptions,
+    rrweb_unpack as unpack,
+    utils_d as utils,
+  };
+}
+
+interface XhrResponse {
+  body: Object | string;
+  statusCode: number;
+  method: string;
+  headers: XhrHeaders;
+  url: string;
+  rawRequest: XMLHttpRequest;
+}
+
+interface XhrHeaders {
+  [key: string]: string;
+}
+
+declare const isValidChunkSize: (chunkSize: any, { minChunkSize, maxChunkSize, }?: {
+    minChunkSize?: number | undefined;
+    maxChunkSize?: number | undefined;
+}) => chunkSize is number | null | undefined;
+declare const getChunkSizeError: (chunkSize: any, { minChunkSize, maxChunkSize, }?: {
+    minChunkSize?: number | undefined;
+    maxChunkSize?: number | undefined;
+}) => TypeError;
+declare type ChunkedStreamIterableOptions = {
+    defaultChunkSize?: number;
+    minChunkSize?: number;
+    maxChunkSize?: number;
+};
+declare class ChunkedStreamIterable implements AsyncIterable<Blob> {
+    protected readableStream: ReadableStream<Uint8Array | Blob>;
+    protected _chunkSize: number | undefined;
+    protected defaultChunkSize: number;
+    readonly minChunkSize: number;
+    readonly maxChunkSize: number;
+    constructor(readableStream: ReadableStream<Uint8Array | Blob>, options?: ChunkedStreamIterableOptions);
+    get chunkSize(): number;
+    set chunkSize(value: number);
+    get chunkByteSize(): number;
+    [Symbol.asyncIterator](): AsyncIterator<Blob>;
+}
+declare type EventName = 'attempt' | 'attemptFailure' | 'chunkSuccess' | 'error' | 'offline' | 'online' | 'progress' | 'success';
+declare type AllowedMethods = 'PUT' | 'POST' | 'PATCH';
+interface UpChunkOptions {
+    endpoint: string | ((file?: File) => Promise<string>);
+    file: File;
+    method?: AllowedMethods;
+    headers?: XhrHeaders | (() => XhrHeaders) | (() => Promise<XhrHeaders>);
+    maxFileSize?: number;
+    chunkSize?: number;
+    attempts?: number;
+    delayBeforeAttempt?: number;
+    retryCodes?: number[];
+    dynamicChunkSize?: boolean;
+    maxChunkSize?: number;
+    minChunkSize?: number;
+}
+declare class UpChunk {
+    static createUpload(options: UpChunkOptions): UpChunk;
+    endpoint: string | ((file?: File) => Promise<string>);
+    file: File;
+    headers: XhrHeaders | (() => XhrHeaders) | (() => Promise<XhrHeaders>);
+    method: AllowedMethods;
+    attempts: number;
+    delayBeforeAttempt: number;
+    retryCodes: number[];
+    dynamicChunkSize: boolean;
+    protected chunkedStreamIterable: ChunkedStreamIterable;
+    protected chunkedStreamIterator: AsyncIterator<Blob, any, undefined>;
+    protected pendingChunk?: Blob;
+    private chunkCount;
+    private maxFileBytes;
+    private endpointValue;
+    private totalChunks;
+    private attemptCount;
+    private offline;
+    private _paused;
+    private success;
+    private currentXhr?;
+    private lastChunkStart;
+    private nextChunkRangeStart;
+    private eventTarget;
+    constructor(options: UpChunkOptions);
+    protected get maxChunkSize(): number;
+    protected get minChunkSize(): number;
+    get chunkSize(): number;
+    set chunkSize(value: number);
+    get chunkByteSize(): number;
+    get totalChunkSize(): number;
+    /**
+     * Subscribe to an event
+     */
+    on(eventName: EventName, fn: (event: CustomEvent) => void): void;
+    /**
+     * Subscribe to an event once
+     */
+    once(eventName: EventName, fn: (event: CustomEvent) => void): void;
+    /**
+     * Unsubscribe to an event
+     */
+    off(eventName: EventName, fn: (event: CustomEvent) => void): void;
+    get paused(): boolean;
+    abort(): void;
+    pause(): void;
+    resume(): void;
+    /**
+     * Dispatch an event
+     */
+    private dispatch;
+    /**
+     * Validate options and throw errors if expectations are violated.
+     */
+    private validateOptions;
+    /**
+     * Endpoint can either be a URL or a function that returns a promise that resolves to a string.
+     */
+    private getEndpoint;
+    private xhrPromise;
+    /**
+     * Send chunk of the file with appropriate headers
+     */
+    protected sendChunk(chunk: Blob): Promise<XhrResponse>;
+    protected sendChunkWithRetries(chunk: Blob): Promise<boolean>;
+    /**
+     * Manage the whole upload by calling getChunk & sendChunk
+     * handle errors & retries and dispatch events
+     */
+    private sendChunks;
+}
+declare const createUpload$1: typeof UpChunk.createUpload;
+
+type _mux_upchunk_ChunkedStreamIterable = ChunkedStreamIterable;
+declare const _mux_upchunk_ChunkedStreamIterable: typeof ChunkedStreamIterable;
+type _mux_upchunk_ChunkedStreamIterableOptions = ChunkedStreamIterableOptions;
+type _mux_upchunk_UpChunk = UpChunk;
+declare const _mux_upchunk_UpChunk: typeof UpChunk;
+type _mux_upchunk_UpChunkOptions = UpChunkOptions;
+declare const _mux_upchunk_getChunkSizeError: typeof getChunkSizeError;
+declare const _mux_upchunk_isValidChunkSize: typeof isValidChunkSize;
+declare namespace _mux_upchunk {
+  export {
+    _mux_upchunk_ChunkedStreamIterable as ChunkedStreamIterable,
+    _mux_upchunk_ChunkedStreamIterableOptions as ChunkedStreamIterableOptions,
+    _mux_upchunk_UpChunk as UpChunk,
+    _mux_upchunk_UpChunkOptions as UpChunkOptions,
+    createUpload$1 as createUpload,
+    _mux_upchunk_getChunkSizeError as getChunkSizeError,
+    _mux_upchunk_isValidChunkSize as isValidChunkSize,
+  };
+}
+
 declare enum NOTIFICATION_TYPES {
     ACTIVATE = "ACTIVATE:experiment, user_id,attributes, variation, event",
     DECISION = "DECISION:type, userId, attributes, decisionInfo",
@@ -846,6 +2478,7 @@ declare const enum Platform {
 }
 declare const enum InstallationMethod {
     Npm = "web-npm",
+    NpmBundled = "web-npm-bundled",
     Gtm = "web-gtm",
     Segment = "web-segment",
     SegmentAndroid = "android-segment",
@@ -934,6 +2567,7 @@ interface Config {
     path?: string;
     platform?: Platform;
     previewKey?: string | null;
+    previewLanguage?: string;
     replayNonce?: string;
     replaySettings?: object;
     requireUserIdForTracking: boolean;
@@ -1027,44 +2661,6 @@ declare namespace optimizely {
   }
 }
 
-declare namespace upchunk {
-  type AllowedMethods = "PUT" | "POST" | "PATCH";
-
-  //Adapted from here: https://github.com/muxinc/upchunk/blob/master/src/upchunk.ts
-  interface UpChunkOptions {
-    endpoint: string | ((file?: File) => Promise<string>);
-    file: File;
-    method?: AllowedMethods;
-    headers?: Headers;
-    maxFileSize?: number;
-    chunkSize?: number;
-    attempts?: number;
-    delayBeforeAttempt?: number;
-    retryCodes?: number[];
-    dynamicChunkSize?: boolean;
-    maxChunkSize?: number;
-    minChunkSize?: number;
-  }
-
-  type UpChunkEventName =
-    | "attempt"
-    | "attemptFailure"
-    | "chunkSuccess"
-    | "error"
-    | "offline"
-    | "online"
-    | "progress"
-    | "success";
-
-  interface UpChunk {
-    startTime: number;
-    on: (eventName: UpChunkEventName, fn: (event: CustomEvent) => void) => void;
-  }
-  interface UpChunkModule {
-    createUpload: (options: UpChunkOptions) => UpChunk;
-  }
-}
-
 declare namespace sprigConfig {
   type IdentifyResult = Promise<
     | {
@@ -1210,7 +2806,14 @@ declare namespace sprigConfig {
       };
     };
 }
-
+type ArgumentTypes<F> = F extends (...args: infer A) => unknown ? A : never;
+type ArgumentType<T> = T extends (arg1: infer U, ...args: unknown[]) => unknown
+  ? U
+  : unknown;
+type PublicOf<T> = { [K in keyof T]: T[K] };
+type createUpload = typeof _mux_upchunk["createUpload"];
+type rrwebRecord = typeof rrweb["record"];
+type rrwebCustomEvent = typeof rrweb["record"]["addCustomEvent"];
 declare global {
   interface Window {
     __cfg: Config;
@@ -1222,10 +2825,21 @@ declare global {
     optimizely?: optimizely.Optimizely;
     optimizelyDatafile?: object;
     previewMode?: unknown;
-    UpChunk: upchunk.UpChunkModule;
+    UpChunk: {
+      createUpload: (
+        ...args: ArgumentTypes<createUpload>
+      ) => PublicOf<ReturnType<createUpload>>;
+    };
     _Sprig?: sprigConfig.WindowSprig;
     Sprig: sprigConfig.WindowSprig;
     UserLeap: sprigConfig.WindowSprig;
+    rrwebRecord?: {
+      addCustomEvent: (
+        ...args: ArgumentTypes<rrwebCustomEvent>
+      ) => PublicOf<ReturnType<rrwebCustomEvent>>;
+    } & ((
+      arg: Omit<ArgumentType<rrwebRecord>, "hooks">
+    ) => PublicOf<ReturnType<rrwebRecord>>);
     sprigAPI?: object;
   }
 
@@ -1259,9 +2873,6 @@ declare class SprigAPI {
         SURVEY_WILL_PRESENT: SprigEvent;
         QUESTION_ANSWERED: SprigEvent;
         CLOSE_SURVEY_ON_OVERLAY_CLICK: SprigEvent;
-        /**
-         * Attach an email address to visitor
-         */
         VISITOR_ID_UPDATED: SprigEvent;
         DATA: {
             DISMISS_REASONS: {