@coralogix/browser 3.4.0 → 3.5.0

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

@@ -0,0 +1,50 @@
+import type { serializedNodeWithId } from '../rrweb-types';
+export type tagMap = {
+    [key: string]: string;
+};
+export type DialogAttributes = {
+    open: string;
+    rr_open_mode: 'modal' | 'non-modal';
+};
+export interface ICanvas extends HTMLCanvasElement {
+    __context: string;
+}
+export type idNodeMap = Map<number, Node>;
+export type nodeMetaMap = WeakMap<Node, serializedNodeWithId>;
+export 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 type SlimDOMOptions = Partial<{
+    script: boolean;
+    comment: boolean;
+    headFavicon: boolean;
+    headWhitespace: boolean;
+    headMetaDescKeywords: boolean;
+    headMetaSocial: boolean;
+    headMetaRobots: boolean;
+    headMetaHttpEquiv: boolean;
+    headMetaAuthorship: boolean;
+    headMetaVerification: boolean;
+    headTitleMutations: boolean;
+}>;
+export type MaskTextFn = (text: string, element: HTMLElement | null) => string;
+export type MaskInputFn = (text: string, element: HTMLElement) => string;
+export type KeepIframeSrcFn = (src: string) => boolean;
+export type BuildCache = {
+    stylesWithHoverClass: Map<string, string>;
+};

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

@@ -0,0 +1,51 @@
+import type { MaskInputFn, MaskInputOptions } from './types';
+import type { IMirror, serializedNodeWithId, serializedNode } from '../rrweb-types';
+export declare function isElement(n: Node): n is Element;
+export declare function isShadowRoot(n: Node): n is ShadowRoot;
+export declare function isNativeShadowDom(shadowRoot: ShadowRoot): boolean;
+declare interface CSSImportRule extends CSSRule {
+    readonly href: string;
+    readonly layerName: string | null;
+    readonly media: MediaList;
+    readonly styleSheet: CSSStyleSheet;
+    readonly supportsText?: string | null;
+}
+export declare function escapeImportStatement(rule: CSSImportRule): string;
+export declare function stringifyStylesheet(s: CSSStyleSheet): string | null;
+export declare function stringifyRule(rule: CSSRule, sheetHref: string | null): string;
+export declare function fixSafariColons(cssStringified: string): string;
+export declare function isCSSImportRule(rule: CSSRule): rule is CSSImportRule;
+export declare function isCSSStyleRule(rule: CSSRule): rule is CSSStyleRule;
+export declare class Mirror 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;
+}
+export declare function createMirror(): Mirror;
+export declare function maskInputValue({ element, maskInputOptions, tagName, type, value, maskInputFn, }: {
+    element: HTMLElement;
+    maskInputOptions: MaskInputOptions;
+    tagName: string;
+    type: string | null;
+    value: string | null;
+    maskInputFn?: MaskInputFn;
+}): string;
+export declare function toLowerCase<T extends string>(str: T): Lowercase<T>;
+export declare function is2DCanvasBlank(canvas: HTMLCanvasElement): boolean;
+export declare function isNodeMetaEqual(a: serializedNode, b: serializedNode): boolean;
+export declare function getInputType(element: HTMLElement): Lowercase<string> | null;
+export declare function extractFileExtension(path: string, baseURL?: string): string | null;
+export declare function absolutifyURLs(cssText: string | null, href: string): string;
+export declare function normalizeCssString(cssText: string, _testNoPxNorm?: boolean): string;
+export declare function splitCssText(cssText: string, style: HTMLStyleElement, _testNoPxNorm?: boolean): string[];
+export declare function markCssSplits(cssText: string, style: HTMLStyleElement): string;
+export {};

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

@@ -0,0 +1,558 @@
+export declare enum EventType {
+    DomContentLoaded = 0,
+    Load = 1,
+    FullSnapshot = 2,
+    IncrementalSnapshot = 3,
+    Meta = 4,
+    Custom = 5,
+    Plugin = 6
+}
+export type domContentLoadedEvent = {
+    type: EventType.DomContentLoaded;
+    data: unknown;
+};
+export type loadedEvent = {
+    type: EventType.Load;
+    data: unknown;
+};
+export type fullSnapshotEvent = {
+    type: EventType.FullSnapshot;
+    data: {
+        node: serializedNodeWithId;
+        initialOffset: {
+            top: number;
+            left: number;
+        };
+    };
+};
+export type incrementalSnapshotEvent = {
+    type: EventType.IncrementalSnapshot;
+    data: incrementalData;
+};
+export type metaEvent = {
+    type: EventType.Meta;
+    data: {
+        href: string;
+        width: number;
+        height: number;
+    };
+};
+export type customEvent<T = unknown> = {
+    type: EventType.Custom;
+    data: {
+        tag: string;
+        payload: T;
+    };
+};
+export type pluginEvent<T = unknown> = {
+    type: EventType.Plugin;
+    data: {
+        plugin: string;
+        payload: T;
+    };
+};
+export 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,
+    CustomElement = 16
+}
+export type mutationData = {
+    source: IncrementalSource.Mutation;
+} & mutationCallbackParam;
+export type mousemoveData = {
+    source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
+    positions: mousePosition[];
+};
+export type mouseInteractionData = {
+    source: IncrementalSource.MouseInteraction;
+} & mouseInteractionParam;
+export type scrollData = {
+    source: IncrementalSource.Scroll;
+} & scrollPosition;
+export type viewportResizeData = {
+    source: IncrementalSource.ViewportResize;
+} & viewportResizeDimension;
+export type inputData = {
+    source: IncrementalSource.Input;
+    id: number;
+} & inputValue;
+export type mediaInteractionData = {
+    source: IncrementalSource.MediaInteraction;
+} & mediaInteractionParam;
+export type styleSheetRuleData = {
+    source: IncrementalSource.StyleSheetRule;
+} & styleSheetRuleParam;
+export type styleDeclarationData = {
+    source: IncrementalSource.StyleDeclaration;
+} & styleDeclarationParam;
+export type canvasMutationData = {
+    source: IncrementalSource.CanvasMutation;
+} & canvasMutationParam;
+export type fontData = {
+    source: IncrementalSource.Font;
+} & fontParam;
+export type selectionData = {
+    source: IncrementalSource.Selection;
+} & selectionParam;
+export type adoptedStyleSheetData = {
+    source: IncrementalSource.AdoptedStyleSheet;
+} & adoptedStyleSheetParam;
+export type customElementData = {
+    source: IncrementalSource.CustomElement;
+} & customElementParam;
+export type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData | customElementData;
+export type eventWithoutTime = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;
+export type event = eventWithoutTime;
+export type eventWithTime = eventWithoutTime & {
+    timestamp: number;
+    delay?: number;
+};
+export type canvasEventWithTime = eventWithTime & {
+    type: EventType.IncrementalSnapshot;
+    data: canvasMutationData;
+};
+export type blockClass = string | RegExp;
+export type maskTextClass = string | RegExp;
+export type SamplingStrategy = Partial<{
+    mousemove: boolean | number;
+    mousemoveCallback: number;
+    mouseInteraction: boolean | Record<string, boolean | undefined>;
+    scroll: number;
+    media: number;
+    input: 'all' | 'last';
+    canvas: 'all' | number;
+}>;
+export 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;
+}
+export 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: IMirror<Node>;
+        crossOriginIframeMirror: ICrossOriginIframeMirror;
+        crossOriginIframeStyleMirror: ICrossOriginIframeMirror;
+    }) => void;
+    options: TOptions;
+};
+export 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;
+    customElement?: customElementCallback;
+};
+export type mutationRecord = Readonly<{
+    type: string;
+    target: Node;
+    oldValue: string | null;
+    addedNodes: NodeList;
+    removedNodes: NodeList;
+    attributeName: string | null;
+}>;
+export type textCursor = {
+    node: Node;
+    value: string | null;
+};
+export type textMutation = {
+    id: number;
+    value: string | null;
+};
+export type styleOMValue = {
+    [key: string]: styleValueWithPriority | string | false;
+};
+export type styleValueWithPriority = [string, string];
+export type attributeCursor = {
+    node: Node;
+    attributes: {
+        [key: string]: string | styleOMValue | null;
+    };
+    styleDiff: styleOMValue;
+    _unchangedStyles: styleOMValue;
+};
+export type attributeMutation = {
+    id: number;
+    attributes: {
+        [key: string]: string | styleOMValue | null;
+    };
+};
+export type removedNodeMutation = {
+    parentId: number;
+    id: number;
+    isShadow?: boolean;
+};
+export type addedNodeMutation = {
+    parentId: number;
+    previousId?: number | null;
+    nextId: number | null;
+    node: serializedNodeWithId;
+};
+export type mutationCallbackParam = {
+    texts: textMutation[];
+    attributes: attributeMutation[];
+    removes: removedNodeMutation[];
+    adds: addedNodeMutation[];
+    isAttachIframe?: true;
+};
+export type mutationCallBack = (m: mutationCallbackParam) => void;
+export type mousemoveCallBack = (p: mousePosition[], source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag) => void;
+export type mousePosition = {
+    x: number;
+    y: number;
+    id: number;
+    timeOffset: number;
+};
+export type mouseMovePos = {
+    x: number;
+    y: number;
+    id: number;
+    debugData: incrementalData;
+};
+export 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
+}
+export declare enum PointerTypes {
+    Mouse = 0,
+    Pen = 1,
+    Touch = 2
+}
+export declare enum CanvasContext {
+    '2D' = 0,
+    WebGL = 1,
+    WebGL2 = 2
+}
+export type SerializedCanvasArg = {
+    rr_type: 'ArrayBuffer';
+    base64: string;
+} | {
+    rr_type: 'Blob';
+    data: Array<CanvasArg>;
+    type?: string;
+} | {
+    rr_type: string;
+    src: string;
+} | {
+    rr_type: string;
+    args: Array<CanvasArg>;
+} | {
+    rr_type: string;
+    index: number;
+};
+export type CanvasArg = SerializedCanvasArg | string | number | boolean | null | CanvasArg[];
+type mouseInteractionParam = {
+    type: MouseInteractions;
+    id: number;
+    x?: number;
+    y?: number;
+    pointerType?: PointerTypes;
+};
+export type mouseInteractionCallBack = (d: mouseInteractionParam) => void;
+export type scrollPosition = {
+    id: number;
+    x: number;
+    y: number;
+};
+export type scrollCallback = (p: scrollPosition) => void;
+export type styleSheetAddRule = {
+    rule: string;
+    index?: number | number[];
+};
+export type styleSheetDeleteRule = {
+    index: number | number[];
+};
+export type styleSheetRuleParam = {
+    id?: number;
+    styleId?: number;
+    removes?: styleSheetDeleteRule[];
+    adds?: styleSheetAddRule[];
+    replace?: string;
+    replaceSync?: string;
+};
+export type styleSheetRuleCallback = (s: styleSheetRuleParam) => void;
+export type adoptedStyleSheetParam = {
+    id: number;
+    styles?: {
+        styleId: number;
+        rules: styleSheetAddRule[];
+    }[];
+    styleIds: number[];
+};
+export type adoptedStyleSheetCallback = (a: adoptedStyleSheetParam) => void;
+export type styleDeclarationParam = {
+    id?: number;
+    styleId?: number;
+    index: number[];
+    set?: {
+        property: string;
+        value: string | null;
+        priority: string | undefined;
+    };
+    remove?: {
+        property: string;
+    };
+};
+export type styleDeclarationCallback = (s: styleDeclarationParam) => void;
+export type canvasMutationCommand = {
+    property: string;
+    args: Array<unknown>;
+    setter?: true;
+};
+export type canvasMutationParam = {
+    id: number;
+    type: CanvasContext;
+    commands: canvasMutationCommand[];
+} | ({
+    id: number;
+    type: CanvasContext;
+} & canvasMutationCommand);
+export type canvasMutationWithType = {
+    type: CanvasContext;
+} & canvasMutationCommand;
+export type canvasMutationCallback = (p: canvasMutationParam) => void;
+export type canvasManagerMutationCallback = (target: HTMLCanvasElement, p: canvasMutationWithType) => void;
+export type ImageBitmapDataURLWorkerParams = {
+    id: number;
+    bitmap: ImageBitmap;
+    width: number;
+    height: number;
+    dataURLOptions: DataURLOptions;
+};
+export type ImageBitmapDataURLWorkerResponse = {
+    id: number;
+} | {
+    id: number;
+    type: string;
+    base64: string;
+    width: number;
+    height: number;
+};
+export type fontParam = {
+    family: string;
+    fontSource: string;
+    buffer: boolean;
+    descriptors?: FontFaceDescriptors;
+};
+export type fontCallback = (p: fontParam) => void;
+export type viewportResizeDimension = {
+    width: number;
+    height: number;
+};
+export type viewportResizeCallback = (d: viewportResizeDimension) => void;
+export type inputValue = {
+    text: string;
+    isChecked: boolean;
+    userTriggered?: boolean;
+};
+export type inputCallback = (v: inputValue & {
+    id: number;
+}) => void;
+export declare enum MediaInteractions {
+    Play = 0,
+    Pause = 1,
+    Seeked = 2,
+    VolumeChange = 3,
+    RateChange = 4
+}
+export type mediaInteractionParam = {
+    type: MediaInteractions;
+    id: number;
+    currentTime?: number;
+    volume?: number;
+    muted?: boolean;
+    loop?: boolean;
+    playbackRate?: number;
+};
+export type mediaInteractionCallback = (p: mediaInteractionParam) => void;
+export type DocumentDimension = {
+    x: number;
+    y: number;
+    relativeScale: number;
+    absoluteScale: number;
+};
+export type SelectionRange = {
+    start: number;
+    startOffset: number;
+    end: number;
+    endOffset: number;
+};
+export type selectionParam = {
+    ranges: Array<SelectionRange>;
+};
+export type selectionCallback = (p: selectionParam) => void;
+export type customElementParam = {
+    define?: {
+        name: string;
+    };
+};
+export type customElementCallback = (c: customElementParam) => void;
+interface INode extends Node {
+    __sn: serializedNodeWithId;
+}
+export 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;
+};
+export type throttleOptions = {
+    leading?: boolean;
+    trailing?: boolean;
+};
+export type listenerHandler = () => void;
+export type hookResetter = () => void;
+export type playerMetaData = {
+    startTime: number;
+    endTime: number;
+    totalTime: number;
+};
+export type actionWithDelay = {
+    doAction: () => void;
+    delay: number;
+};
+export type Handler = (event?: unknown) => void;
+export type Emitter = {
+    on(type: string, handler: Handler): void;
+    emit(type: string, event?: unknown): void;
+    off(type: string, handler: Handler): void;
+};
+export type Arguments<T> = T extends (...payload: infer U) => unknown ? U : unknown;
+export type KeepIframeSrcFn = (src: string) => boolean;
+declare global {
+    interface Window {
+        FontFace: typeof FontFace;
+    }
+}
+export type IWindow = Window & typeof globalThis;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type GetTypedKeys<Obj extends object, ValueType> = TakeTypeHelper<Obj, ValueType>[keyof TakeTypeHelper<Obj, ValueType>];
+export type TakeTypeHelper<Obj extends object, ValueType> = {
+    [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
+};
+export type TakeTypedKeyValues<Obj extends object, Type> = Pick<Obj, TakeTypeHelper<Obj, Type>[keyof TakeTypeHelper<Obj, Type>]>;
+export declare enum NodeType {
+    Document = 0,
+    DocumentType = 1,
+    Element = 2,
+    Text = 3,
+    CDATA = 4,
+    Comment = 5
+}
+export type documentNode = {
+    type: NodeType.Document;
+    childNodes: serializedNodeWithId[];
+    compatMode?: string;
+};
+export type documentTypeNode = {
+    type: NodeType.DocumentType;
+    name: string;
+    publicId: string;
+    systemId: string;
+};
+type cssTextKeyAttr = {
+    _cssText?: string;
+};
+export type attributes = cssTextKeyAttr & {
+    [key: string]: string | number | true | null;
+};
+export type legacyAttributes = {
+    selected: false;
+};
+export type mediaAttributes = {
+    rr_mediaState: 'played' | 'paused';
+    rr_mediaCurrentTime: number;
+    rr_mediaPlaybackRate?: number;
+    rr_mediaMuted?: boolean;
+    rr_mediaLoop?: boolean;
+    rr_mediaVolume?: number;
+};
+export type elementNode = {
+    type: NodeType.Element;
+    tagName: string;
+    attributes: attributes;
+    childNodes: serializedNodeWithId[];
+    isSVG?: true;
+    needBlock?: boolean;
+    isCustom?: true;
+};
+export type textNode = {
+    type: NodeType.Text;
+    textContent: string;
+    isStyle?: true;
+};
+export type cdataNode = {
+    type: NodeType.CDATA;
+    textContent: '';
+};
+export type commentNode = {
+    type: NodeType.Comment;
+    textContent: string;
+};
+export type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
+    rootId?: number;
+    isShadowHost?: boolean;
+    isShadow?: boolean;
+};
+export type serializedNodeWithId = serializedNode & {
+    id: number;
+};
+export type serializedElementNodeWithId = Extract<serializedNodeWithId, Record<'type', NodeType.Element>>;
+export 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;
+}
+export type DataURLOptions = Partial<{
+    type: string;
+    quality: number;
+}>;
+export type PackFn = (event: eventWithTime) => string;
+export type UnpackFn = (raw: string) => eventWithTime;
+export {};

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

@@ -0,0 +1,43 @@
+type BasePrototypeCache = {
+    Node: typeof Node.prototype;
+    ShadowRoot: typeof ShadowRoot.prototype;
+    MutationObserver: typeof MutationObserver.prototype;
+    Element: typeof Element.prototype;
+};
+export declare const isAngularZonePresent: () => boolean;
+export declare function getUntaintedPrototype<T extends keyof BasePrototypeCache>(key: T): BasePrototypeCache[T];
+export declare function getUntaintedAccessor<K extends keyof BasePrototypeCache, T extends keyof BasePrototypeCache[K]>(key: K, instance: BasePrototypeCache[K], accessor: T): BasePrototypeCache[K][T];
+export declare function getUntaintedMethod<K extends keyof BasePrototypeCache, T extends keyof BasePrototypeCache[K]>(key: K, instance: BasePrototypeCache[K], method: T): BasePrototypeCache[K][T];
+export declare function ownerDocument(n: Node): Document | null;
+export declare function childNodes(n: Node): NodeListOf<Node>;
+export declare function parentNode(n: Node): ParentNode | null;
+export declare function parentElement(n: Node): HTMLElement | null;
+export declare function textContent(n: Node): string | null;
+export declare function contains(n: Node, other: Node): boolean;
+export declare function getRootNode(n: Node): Node;
+export declare function host(n: ShadowRoot): Element | null;
+export declare function styleSheets(n: ShadowRoot): StyleSheetList;
+export declare function shadowRoot(n: Node): ShadowRoot | null;
+export declare function querySelector(n: Element, selectors: string): Element | null;
+export declare function querySelectorAll(n: Element, selectors: string): NodeListOf<Element>;
+export declare function mutationObserverCtor(): (typeof MutationObserver)['prototype']['constructor'];
+export declare function patch(source: {
+    [key: string]: any;
+}, name: string, replacement: (...args: any[]) => any): () => void;
+declare const _default: {
+    ownerDocument: typeof ownerDocument;
+    childNodes: typeof childNodes;
+    parentNode: typeof parentNode;
+    parentElement: typeof parentElement;
+    textContent: typeof textContent;
+    contains: typeof contains;
+    getRootNode: typeof getRootNode;
+    host: typeof host;
+    styleSheets: typeof styleSheets;
+    shadowRoot: typeof shadowRoot;
+    querySelector: typeof querySelector;
+    querySelectorAll: typeof querySelectorAll;
+    mutationObserver: typeof mutationObserverCtor;
+    patch: typeof patch;
+};
+export default _default;

package/src/instrumentations/CoralogixErrorInstrumentation.d.ts

@@ -1,5 +1,6 @@
 import { InstrumentationBase, InstrumentationConfig } from '@opentelemetry/instrumentation';
 import { CoralogixRumLabels } from '../types';
+export declare function extractMfePath(fileName: string): string | undefined;
 export declare const ERROR_INSTRUMENTATION_NAME = "errors";
 export declare const ErrorAttributes: {
     TYPE: string;