@coralogix/browser 3.4.0 → 3.5.0

package/src/constants.d.ts

@@ -7,8 +7,7 @@ export declare const MAX_INTERACTION_ELEMENT_SIZE = 1024;
 export declare const MAX_CHARACTERS = 1024;
 export declare const SCHEDULE_DELAY_MILLIS: number;
 export declare const REQUIRED_CONFIG_KEYS: Array<keyof CoralogixBrowserSdkConfig>;
-export declare const SDK_CONFIG_KEY = "sdkConfig";
-export declare const USER_AGENT_KEY = "userAgent";
+export { SDK_CONFIG_KEY, USER_AGENT_KEY } from './tools/global-keys';
 export declare const ID_MASK_KEY = "{id}";
 export declare const UUID_REGEX: RegExp;
 export declare const NANOID_REGEX: RegExp;

package/src/cx-rrweb/rrweb/index.d.ts

@@ -0,0 +1,4 @@
+import record from './record';
+export type { recordOptions } from './types';
+export { record };
+export declare const addCustomEvent: <T>(tag: string, payload: T) => void, freezePage: () => void, takeFullSnapshot: (isCheckout?: boolean) => void;

package/src/cx-rrweb/rrweb/record/cross-origin-iframe-mirror.d.ts

@@ -0,0 +1,14 @@
+import type { ICrossOriginIframeMirror } from '../../rrweb-types';
+export default class CrossOriginIframeMirror implements ICrossOriginIframeMirror {
+    private generateIdFn;
+    private iframeIdToRemoteIdMap;
+    private iframeRemoteIdToIdMap;
+    constructor(generateIdFn: () => number);
+    getId(iframe: HTMLIFrameElement, remoteId: number, idToRemoteMap?: Map<number, number>, remoteToIdMap?: Map<number, number>): number;
+    getIds(iframe: HTMLIFrameElement, remoteId: number[]): number[];
+    getRemoteId(iframe: HTMLIFrameElement, id: number, map?: Map<number, number>): number;
+    getRemoteIds(iframe: HTMLIFrameElement, ids: number[]): number[];
+    reset(iframe?: HTMLIFrameElement): void;
+    private getIdToRemoteIdMap;
+    private getRemoteIdToIdMap;
+}

package/src/cx-rrweb/rrweb/record/error-handler.d.ts

@@ -0,0 +1,6 @@
+import type { ErrorHandler } from '../types';
+type Callback = (...args: any[]) => any;
+export declare function registerErrorHandler(handler: ErrorHandler | undefined): void;
+export declare function unregisterErrorHandler(): void;
+export declare const callbackWrapper: <T extends Callback>(cb: T) => T;
+export {};

package/src/cx-rrweb/rrweb/record/iframe-manager.d.ts

@@ -0,0 +1,34 @@
+import type { Mirror } from '../../rrweb-snapshot';
+import CrossOriginIframeMirror from './cross-origin-iframe-mirror';
+import type { eventWithoutTime, serializedNodeWithId, mutationCallBack } from '../../rrweb-types';
+import type { StylesheetManager } from './stylesheet-manager';
+export declare class IframeManager {
+    private iframes;
+    private crossOriginIframeMap;
+    crossOriginIframeMirror: CrossOriginIframeMirror;
+    crossOriginIframeStyleMirror: CrossOriginIframeMirror;
+    crossOriginIframeRootIdMap: WeakMap<HTMLIFrameElement, number>;
+    private mirror;
+    private mutationCb;
+    private wrappedEmit;
+    private loadListener?;
+    private stylesheetManager;
+    private recordCrossOriginIframes;
+    constructor(options: {
+        mirror: Mirror;
+        mutationCb: mutationCallBack;
+        stylesheetManager: StylesheetManager;
+        recordCrossOriginIframes: boolean;
+        wrappedEmit: (e: eventWithoutTime, isCheckout?: boolean) => void;
+    });
+    addIframe(iframeEl: HTMLIFrameElement): void;
+    addLoadListener(cb: (iframeEl: HTMLIFrameElement) => unknown): void;
+    attachIframe(iframeEl: HTMLIFrameElement, childSn: serializedNodeWithId): void;
+    private handleMessage;
+    private transformCrossOriginEvent;
+    private replace;
+    private replaceIds;
+    private replaceStyleIds;
+    private replaceIdOnNode;
+    private patchRootIdOnNode;
+}

package/src/cx-rrweb/rrweb/record/index.d.ts

@@ -0,0 +1,10 @@
+import type { recordOptions } from '../types';
+import { type eventWithTime, type listenerHandler } from '../../rrweb-types';
+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) => void;
+    var mirror: import("../../rrweb-snapshot").Mirror;
+}
+export default record;

package/src/cx-rrweb/rrweb/record/mutation.d.ts

@@ -0,0 +1,50 @@
+import type { MutationBufferParam } from '../types';
+import type { mutationRecord } from '../../rrweb-types';
+export default class MutationBuffer {
+    private frozen;
+    private locked;
+    private texts;
+    private attributes;
+    private attributeMap;
+    private removes;
+    private mapRemoves;
+    private movedMap;
+    private addedSet;
+    private movedSet;
+    private droppedSet;
+    private removesSubTreeCache;
+    private mutationCb;
+    private blockClass;
+    private blockSelector;
+    private maskTextClass;
+    private maskTextSelector;
+    private inlineStylesheet;
+    private maskInputOptions;
+    private maskTextFn;
+    private maskInputFn;
+    private keepIframeSrcFn;
+    private recordCanvas;
+    private inlineImages;
+    private slimDOMOptions;
+    private dataURLOptions;
+    private doc;
+    private mirror;
+    private iframeManager;
+    private stylesheetManager;
+    private shadowDomManager;
+    private canvasManager;
+    private processedNodeManager;
+    private unattachedDoc;
+    init(options: MutationBufferParam): void;
+    freeze(): void;
+    unfreeze(): void;
+    isFrozen(): boolean;
+    lock(): void;
+    unlock(): void;
+    reset(): void;
+    processMutations: (mutations: mutationRecord[]) => void;
+    emit: () => void;
+    private genTextAreaValueMutation;
+    private processMutation;
+    private genAdds;
+}

package/src/cx-rrweb/rrweb/record/observer.d.ts

@@ -0,0 +1,9 @@
+import type { MutationBufferParam, observerParam } from '../types';
+import type { hooksParam, listenerHandler } from '../../rrweb-types';
+import MutationBuffer from './mutation';
+export declare const mutationBuffers: MutationBuffer[];
+export declare function initMutationObserver(options: MutationBufferParam, rootEl: Node): MutationObserver;
+export declare function initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, sampling, }: Pick<observerParam, 'scrollCb' | 'doc' | 'mirror' | 'blockClass' | 'blockSelector' | 'sampling'>): listenerHandler;
+export declare const INPUT_TAGS: string[];
+export declare function initAdoptedStyleSheetObserver({ mirror, stylesheetManager, }: Pick<observerParam, 'mirror' | 'stylesheetManager'>, host: Document | ShadowRoot): listenerHandler;
+export declare function initObservers(o: observerParam, hooks?: hooksParam): listenerHandler;

package/src/cx-rrweb/rrweb/record/observers/canvas/2d.d.ts

@@ -0,0 +1,2 @@
+import { type blockClass, type canvasManagerMutationCallback, type IWindow, type listenerHandler } from '../../../../rrweb-types';
+export default function initCanvas2DMutationObserver(cb: canvasManagerMutationCallback, win: IWindow, blockClass: blockClass, blockSelector: string | null): listenerHandler;

package/src/cx-rrweb/rrweb/record/observers/canvas/canvas-manager.d.ts

@@ -0,0 +1,37 @@
+import type { Mirror } from '../../../../rrweb-snapshot';
+import type { blockClass, canvasMutationCallback, DataURLOptions, IWindow } from '../../../../rrweb-types';
+export 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;
+        mutationCb: canvasMutationCallback;
+        win: IWindow;
+        blockClass: blockClass;
+        blockSelector: string | null;
+        mirror: Mirror;
+        sampling?: 'all' | number;
+        dataURLOptions: DataURLOptions;
+    });
+    private processMutation;
+    private initCanvasFPSObserver;
+    private initCanvasMutationObserver;
+    private startPendingCanvasMutationFlusher;
+    private startRAFTimestamping;
+    flushPendingCanvasMutations(): void;
+    flushPendingCanvasMutationFor(canvas: HTMLCanvasElement, id: number): void;
+}

package/src/cx-rrweb/rrweb/record/observers/canvas/canvas.d.ts

@@ -0,0 +1,2 @@
+import type { blockClass, IWindow, listenerHandler } from '../../../../rrweb-types';
+export default function initCanvasContextObserver(win: IWindow, blockClass: blockClass, blockSelector: string | null, setPreserveDrawingBufferToTrue: boolean): listenerHandler;

package/src/cx-rrweb/rrweb/record/observers/canvas/serialize-args.d.ts

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

package/src/cx-rrweb/rrweb/record/observers/canvas/webgl.d.ts

@@ -0,0 +1,2 @@
+import { type blockClass, type canvasManagerMutationCallback, type IWindow, type listenerHandler } from '../../../../rrweb-types';
+export default function initCanvasWebGLMutationObserver(cb: canvasManagerMutationCallback, win: IWindow, blockClass: blockClass, blockSelector: string | null): listenerHandler;

package/src/cx-rrweb/rrweb/record/processed-node-manager.d.ts

@@ -0,0 +1,8 @@
+import type MutationBuffer from './mutation';
+export default class ProcessedNodeManager {
+    private nodeMap;
+    private active;
+    inOtherBuffer(node: Node, thisBuffer: MutationBuffer): boolean | undefined;
+    add(node: Node, buffer: MutationBuffer): void;
+    destroy(): void;
+}

package/src/cx-rrweb/rrweb/record/shadow-dom-manager.d.ts

@@ -0,0 +1,26 @@
+import type { MutationBufferParam } from '../types';
+import type { mutationCallBack, SamplingStrategy, scrollCallback } from '../../rrweb-types';
+import type { Mirror } from '../../rrweb-snapshot';
+type BypassOptions = Omit<MutationBufferParam, 'doc' | 'mutationCb' | 'mirror' | 'shadowDomManager'> & {
+    sampling: SamplingStrategy;
+};
+export declare class ShadowDomManager {
+    private shadowDoms;
+    private mutationCb;
+    private scrollCb;
+    private bypassOptions;
+    private mirror;
+    private restoreHandlers;
+    constructor(options: {
+        mutationCb: mutationCallBack;
+        scrollCb: scrollCallback;
+        bypassOptions: BypassOptions;
+        mirror: Mirror;
+    });
+    init(): void;
+    addShadowRoot(shadowRoot: ShadowRoot, doc: Document): void;
+    observeAttachShadow(iframeElement: HTMLIFrameElement): void;
+    private patchAttachShadow;
+    reset(): void;
+}
+export {};

package/src/cx-rrweb/rrweb/record/stylesheet-manager.d.ts

@@ -0,0 +1,17 @@
+import type { serializedNodeWithId, adoptedStyleSheetCallback, mutationCallBack } from '../../rrweb-types';
+import { StyleSheetMirror } from '../utils';
+export declare class StylesheetManager {
+    private trackedLinkElements;
+    private mutationCb;
+    private adoptedStyleSheetCb;
+    styleMirror: StyleSheetMirror;
+    constructor(options: {
+        mutationCb: mutationCallBack;
+        adoptedStyleSheetCb: adoptedStyleSheetCallback;
+    });
+    attachLinkElement(linkEl: HTMLLinkElement, childSn: serializedNodeWithId): void;
+    trackLinkElement(linkEl: HTMLLinkElement): void;
+    adoptStyleSheets(sheets: CSSStyleSheet[] | readonly CSSStyleSheet[], hostId: number): void;
+    reset(): void;
+    private trackStylesheetInLinkElement;
+}

package/src/cx-rrweb/rrweb/record/workers/image-bitmap-data-url-worker.d.ts

@@ -0,0 +1,6 @@
+import type { ImageBitmapDataURLWorkerParams, ImageBitmapDataURLWorkerResponse } from '../../../rrweb-types';
+export interface ImageBitmapDataURLRequestWorker {
+    postMessage: (message: ImageBitmapDataURLWorkerParams, transfer?: [ImageBitmap]) => void;
+    onmessage: ((message: MessageEvent<ImageBitmapDataURLWorkerResponse>) => void) | null;
+}
+export declare function createImageBitmapWorker(): ImageBitmapDataURLRequestWorker;

package/src/cx-rrweb/rrweb/types.d.ts

@@ -0,0 +1,102 @@
+import type { Mirror, MaskInputOptions, SlimDOMOptions, MaskInputFn, MaskTextFn } from '../rrweb-snapshot';
+import type { IframeManager } from './record/iframe-manager';
+import type { ShadowDomManager } from './record/shadow-dom-manager';
+import type { CanvasManager } from './record/observers/canvas/canvas-manager';
+import type { StylesheetManager } from './record/stylesheet-manager';
+import type { DataURLOptions, blockClass, canvasMutationCallback, customElementCallback, eventWithTime, fontCallback, hooksParam, inputCallback, IWindow, KeepIframeSrcFn, listenerHandler, maskTextClass, mediaInteractionCallback, mouseInteractionCallBack, mousemoveCallBack, mutationCallBack, RecordPlugin, SamplingStrategy, scrollCallback, selectionCallback, styleDeclarationCallback, styleSheetRuleCallback, viewportResizeCallback, PackFn } from '../rrweb-types';
+import type ProcessedNodeManager from './record/processed-node-manager';
+export 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;
+    recordDOM?: boolean;
+    recordCanvas?: boolean;
+    recordCrossOriginIframes?: boolean;
+    recordAfter?: 'DOMContentLoaded' | 'load';
+    userTriggeredOnInput?: boolean;
+    collectFonts?: boolean;
+    inlineImages?: boolean;
+    plugins?: RecordPlugin[];
+    mousemoveWait?: number;
+    keepIframeSrcFn?: KeepIframeSrcFn;
+    errorHandler?: ErrorHandler;
+};
+export type observerParam = {
+    mutationCb: mutationCallBack;
+    mousemoveCb: mousemoveCallBack;
+    mouseInteractionCb: mouseInteractionCallBack;
+    scrollCb: scrollCallback;
+    viewportResizeCb: viewportResizeCallback;
+    inputCb: inputCallback;
+    mediaInteractionCb: mediaInteractionCallback;
+    selectionCb: selectionCallback;
+    blockClass: blockClass;
+    blockSelector: string | null;
+    ignoreClass: string;
+    ignoreSelector: string | null;
+    maskTextClass: maskTextClass;
+    maskTextSelector: string | null;
+    maskInputOptions: MaskInputOptions;
+    maskInputFn?: MaskInputFn;
+    maskTextFn?: MaskTextFn;
+    keepIframeSrcFn: KeepIframeSrcFn;
+    inlineStylesheet: boolean;
+    styleSheetRuleCb: styleSheetRuleCallback;
+    styleDeclarationCb: styleDeclarationCallback;
+    canvasMutationCb: canvasMutationCallback;
+    customElementCb: customElementCallback;
+    fontCb: fontCallback;
+    sampling: SamplingStrategy;
+    recordDOM: boolean;
+    recordCanvas: boolean;
+    inlineImages: boolean;
+    userTriggeredOnInput: boolean;
+    collectFonts: boolean;
+    slimDOMOptions: SlimDOMOptions;
+    dataURLOptions: DataURLOptions;
+    doc: Document;
+    mirror: Mirror;
+    iframeManager: IframeManager;
+    stylesheetManager: StylesheetManager;
+    shadowDomManager: ShadowDomManager;
+    canvasManager: CanvasManager;
+    processedNodeManager: ProcessedNodeManager;
+    ignoreCSSAttributes: Set<string>;
+    plugins: Array<{
+        observer: (cb: (...arg: Array<unknown>) => void, win: IWindow, options: unknown) => listenerHandler;
+        callback: (...arg: Array<unknown>) => void;
+        options: unknown;
+    }>;
+};
+export type MutationBufferParam = Pick<observerParam, 'mutationCb' | 'blockClass' | 'blockSelector' | 'maskTextClass' | 'maskTextSelector' | 'inlineStylesheet' | 'maskInputOptions' | 'maskTextFn' | 'maskInputFn' | 'keepIframeSrcFn' | 'recordCanvas' | 'inlineImages' | 'slimDOMOptions' | 'dataURLOptions' | 'doc' | 'mirror' | 'iframeManager' | 'stylesheetManager' | 'shadowDomManager' | 'canvasManager' | 'processedNodeManager'>;
+declare global {
+    interface Window {
+        FontFace: typeof FontFace;
+        Array: typeof Array;
+    }
+}
+export type CrossOriginIframeMessageEventContent<T = eventWithTime> = {
+    type: 'rrweb';
+    event: T;
+    origin: string;
+    isCheckout?: boolean;
+};
+export type CrossOriginIframeMessageEvent = MessageEvent<CrossOriginIframeMessageEventContent>;
+export type ErrorHandler = (error: unknown) => void | boolean;

package/src/cx-rrweb/rrweb/utils/base64.d.ts

@@ -0,0 +1 @@
+export declare function encodeBase64(arraybuffer: ArrayBuffer): string;

package/src/cx-rrweb/rrweb/utils.d.ts

@@ -0,0 +1,66 @@
+import type { addedNodeMutation, blockClass, DeprecatedMirror, DocumentDimension, hookResetter, IMirror, IWindow, listenerHandler, textMutation, throttleOptions } from '../rrweb-types';
+import type { Mirror, SlimDOMOptions } from '../rrweb-snapshot';
+interface RRNode {
+    nodeName: string;
+    nodeType: number;
+    ELEMENT_NODE: number;
+    shadowRoot?: ShadowRoot | null;
+}
+type RRIFrameElement = HTMLIFrameElement;
+export declare function on(type: string, fn: EventListenerOrEventListenerObject, target?: Document | IWindow): listenerHandler;
+export declare let _mirror: DeprecatedMirror;
+export declare function throttle<T>(func: (arg: T) => void, wait: number, options?: throttleOptions): (this: any, ...args: T[]) => void;
+export declare function hookSetter<T>(target: T, key: string | number | symbol, d: PropertyDescriptor, isRevoked?: boolean, win?: Window & typeof globalThis): hookResetter;
+declare let nowTimestamp: () => number;
+export { nowTimestamp };
+export declare function getWindowScroll(win: Window): {
+    left: number;
+    top: number;
+};
+export declare function getWindowHeight(): number;
+export declare function getWindowWidth(): number;
+export declare function closestElementOfNode(node: Node | null): HTMLElement | null;
+export declare function isBlocked(node: Node | null, blockClass: blockClass, blockSelector: string | null, checkAncestors: boolean): boolean;
+export declare function isSerialized(n: Node, mirror: Mirror): boolean;
+export declare function isIgnored(n: Node, mirror: Mirror, slimDOMOptions: SlimDOMOptions): boolean;
+export declare function isAncestorRemoved(target: Node, mirror: Mirror): boolean;
+export declare function legacy_isTouchEvent(event: MouseEvent | TouchEvent | PointerEvent): event is TouchEvent;
+export declare function polyfill(win?: Window & typeof globalThis): void;
+type ResolveTree = {
+    value: addedNodeMutation;
+    children: ResolveTree[];
+    parent: ResolveTree | null;
+};
+export declare function queueToResolveTrees(queue: addedNodeMutation[]): ResolveTree[];
+export declare function iterateResolveTree(tree: ResolveTree, cb: (mutation: addedNodeMutation) => unknown): void;
+export type AppendedIframe = {
+    mutationInQueue: addedNodeMutation;
+    builtNode: HTMLIFrameElement | RRIFrameElement;
+};
+export declare function isSerializedIframe<TNode extends Node | RRNode>(n: TNode, mirror: IMirror<TNode>): boolean;
+export declare function isSerializedStylesheet<TNode extends Node | RRNode>(n: TNode, mirror: IMirror<TNode>): boolean;
+export declare function getBaseDimension(node: Node, rootIframe: Node): DocumentDimension;
+export declare function hasShadowRoot<T extends Node | RRNode>(n: T): n is T & {
+    shadowRoot: ShadowRoot;
+};
+export declare function getNestedRule(rules: CSSRuleList, position: number[]): CSSGroupingRule;
+export declare function getPositionsAndIndex(nestedIndex: number[]): {
+    positions: number[];
+    index: number | undefined;
+};
+export declare function uniqueTextMutations(mutations: textMutation[]): textMutation[];
+export 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;
+}
+export declare function getShadowHost(n: Node): Element | null;
+export declare function getRootShadowHost(n: Node): Node;
+export declare function shadowHostInDom(n: Node): boolean;
+export declare function inDom(n: Node): boolean;

package/src/cx-rrweb/rrweb-plugin-console-record/error-stack-parser.d.ts

@@ -0,0 +1,37 @@
+export declare class StackFrame {
+    private fileName;
+    private functionName;
+    private lineNumber?;
+    private columnNumber?;
+    constructor(obj: {
+        fileName?: string;
+        functionName?: string;
+        lineNumber?: number;
+        columnNumber?: number;
+    });
+    toString(): string;
+}
+export declare const ErrorStackParser: {
+    parse: (error: Error) => StackFrame[];
+    extractLocation: (urlLike: string) => (string | undefined)[];
+    parseV8OrIE: (error: {
+        stack: string;
+    }) => StackFrame[];
+    parseFFOrSafari: (error: {
+        stack: string;
+    }) => StackFrame[];
+    parseOpera: (e: {
+        stacktrace?: string;
+        message: string;
+        stack?: string;
+    }) => StackFrame[];
+    parseOpera9: (e: {
+        message: string;
+    }) => StackFrame[];
+    parseOpera10: (e: {
+        stacktrace: string;
+    }) => StackFrame[];
+    parseOpera11: (error: {
+        stack: string;
+    }) => StackFrame[];
+};

package/src/cx-rrweb/rrweb-plugin-console-record/index.d.ts

@@ -0,0 +1,42 @@
+import type { RecordPlugin } from '../rrweb-types';
+export type StringifyOptions = {
+    stringLengthLimit?: number;
+    numOfKeysLimit: number;
+    depthOfLimit: number;
+};
+type LogRecordOptions = {
+    level?: LogLevel[];
+    lengthThreshold?: number;
+    stringifyOptions?: StringifyOptions;
+    logger?: Logger | 'console';
+};
+export type LogData = {
+    level: LogLevel;
+    trace: string[];
+    payload: string[];
+};
+export 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;
+};
+export type LogLevel = keyof Logger;
+export declare const PLUGIN_NAME = "rrweb/console@1";
+export declare const getRecordConsolePlugin: (options?: LogRecordOptions) => RecordPlugin;
+export {};

package/src/cx-rrweb/rrweb-plugin-console-record/stringify.d.ts

@@ -0,0 +1,2 @@
+import type { StringifyOptions } from './index';
+export declare function stringify(obj: unknown, stringifyOptions?: StringifyOptions): string;

package/src/cx-rrweb/rrweb-snapshot/index.d.ts

@@ -0,0 +1,4 @@
+import snapshot, { serializeNodeWithId, transformAttribute, ignoreAttribute, slimDOMDefaults, needMaskingText, classMatchesRegex, IGNORED_NODE, genId } from './snapshot';
+export type { ICanvas, MaskInputOptions, SlimDOMOptions, MaskInputFn, MaskTextFn, idNodeMap, nodeMetaMap, DialogAttributes, KeepIframeSrcFn, } from './types';
+export { Mirror, createMirror, isNativeShadowDom, isShadowRoot, stringifyRule, maskInputValue, getInputType, toLowerCase, } from './utils';
+export { snapshot, serializeNodeWithId, transformAttribute, ignoreAttribute, slimDOMDefaults, needMaskingText, classMatchesRegex, IGNORED_NODE, genId, };

package/src/cx-rrweb/rrweb-snapshot/snapshot.d.ts

@@ -0,0 +1,76 @@
+import type { KeepIframeSrcFn, MaskInputFn, MaskInputOptions, MaskTextFn, SlimDOMOptions } from './types';
+import type { DataURLOptions, serializedElementNodeWithId, serializedNodeWithId } from '../rrweb-types';
+import { Mirror } from './utils';
+export declare const IGNORED_NODE = -2;
+export declare function genId(): number;
+export declare function absoluteToDoc(doc: Document, attributeValue: string): string;
+export declare function transformAttribute(doc: Document, tagName: Lowercase<string>, name: Lowercase<string>, value: string | null): string | null;
+export declare function ignoreAttribute(tagName: string, name: string, _value: unknown): boolean;
+export declare function _isBlockedElement(element: HTMLElement, blockClass: string | RegExp, blockSelector: string | null): boolean;
+export declare function classMatchesRegex(node: Node | null, regex: RegExp, checkAncestors: boolean): boolean;
+export declare function needMaskingText(node: Node, maskTextClass: string | RegExp, maskTextSelector: string | null, checkAncestors: boolean): boolean;
+export declare function slimDOMDefaults(_slimDOMOptions: SlimDOMOptions | 'all' | true | false | undefined): Partial<{
+    script: boolean;
+    comment: boolean;
+    headFavicon: boolean;
+    headWhitespace: boolean;
+    headMetaDescKeywords: boolean;
+    headMetaSocial: boolean;
+    headMetaRobots: boolean;
+    headMetaHttpEquiv: boolean;
+    headMetaAuthorship: boolean;
+    headMetaVerification: boolean;
+    headTitleMutations: boolean;
+}>;
+export declare function serializeNodeWithId(n: Node, options: {
+    doc: Document;
+    mirror: Mirror;
+    blockClass: string | RegExp;
+    blockSelector: string | null;
+    maskTextClass: string | RegExp;
+    maskTextSelector: string | null;
+    skipChild: boolean;
+    inlineStylesheet: boolean;
+    newlyAddedElement?: boolean;
+    maskInputOptions?: MaskInputOptions;
+    needsMask?: boolean;
+    maskTextFn: MaskTextFn | undefined;
+    maskInputFn: MaskInputFn | undefined;
+    slimDOMOptions: SlimDOMOptions;
+    dataURLOptions?: DataURLOptions;
+    keepIframeSrcFn?: KeepIframeSrcFn;
+    inlineImages?: boolean;
+    recordCanvas?: boolean;
+    preserveWhiteSpace?: boolean;
+    onSerialize?: (n: Node) => unknown;
+    onIframeLoad?: (iframeNode: HTMLIFrameElement, node: serializedElementNodeWithId) => unknown;
+    iframeLoadTimeout?: number;
+    onStylesheetLoad?: (linkNode: HTMLLinkElement, node: serializedElementNodeWithId) => unknown;
+    stylesheetLoadTimeout?: number;
+    cssCaptured?: boolean;
+}): serializedNodeWithId | null;
+declare function snapshot(n: Document, options?: {
+    mirror?: Mirror;
+    blockClass?: string | RegExp;
+    blockSelector?: string | null;
+    maskTextClass?: string | RegExp;
+    maskTextSelector?: string | null;
+    inlineStylesheet?: boolean;
+    maskAllInputs?: boolean | MaskInputOptions;
+    maskTextFn?: MaskTextFn;
+    maskInputFn?: MaskInputFn;
+    slimDOM?: 'all' | boolean | SlimDOMOptions;
+    dataURLOptions?: DataURLOptions;
+    inlineImages?: boolean;
+    recordCanvas?: boolean;
+    preserveWhiteSpace?: boolean;
+    onSerialize?: (n: Node) => unknown;
+    onIframeLoad?: (iframeNode: HTMLIFrameElement, node: serializedElementNodeWithId) => unknown;
+    iframeLoadTimeout?: number;
+    onStylesheetLoad?: (linkNode: HTMLLinkElement, node: serializedElementNodeWithId) => unknown;
+    stylesheetLoadTimeout?: number;
+    keepIframeSrcFn?: KeepIframeSrcFn;
+}): serializedNodeWithId | null;
+export declare function visitSnapshot(node: serializedNodeWithId, onVisit: (node: serializedNodeWithId) => unknown): void;
+export declare function cleanupSnapshot(): void;
+export default snapshot;