@clue-ai/browser-sdk 0.0.1

package/dist/capture/action.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureModuleContext, CaptureStopHandle } from "../core/types";
+export declare const startActionCapture: (context: CaptureModuleContext) => CaptureStopHandle;

package/dist/capture/action.js

@@ -0,0 +1,62 @@
+import { buildLocalTextDescriptor } from "../privacy/local-minimization";
+import { extractFieldName, extractFieldType, getElementAriaLabel, getElementClassList, getElementLabel, getElementPlaceholder, getElementRole, getElementSectionHeading, isEditableElement, resolveClickDisplayTarget, resolveStableKeyDescriptor, } from "./dom";
+export const startActionCapture = (context) => {
+    if (typeof document === "undefined") {
+        return { stop: () => undefined };
+    }
+    const clickHandler = (event) => {
+        if (context.getConsent() === "denied") {
+            return;
+        }
+        const target = event.target;
+        if (!(target instanceof Element)) {
+            return;
+        }
+        if (context.shouldIgnoreElement?.(target)) {
+            return;
+        }
+        try {
+            const displayTarget = resolveClickDisplayTarget(target);
+            if (context.shouldIgnoreElement?.(displayTarget)) {
+                return;
+            }
+            const stableKey = resolveStableKeyDescriptor(displayTarget);
+            context.onEvent({
+                type: "element_clicked",
+                occurredAtMs: Date.now(),
+                payload: {
+                    viewId: context.getViewId(),
+                    elementTag: displayTarget.tagName.toLowerCase(),
+                    elementRole: getElementRole(displayTarget),
+                    stableKey: stableKey.stableKey,
+                    stableKeyQuality: stableKey.stableKeyQuality,
+                    formKey: stableKey.formKey,
+                    elementId: displayTarget.id || null,
+                    elementClass: getElementClassList(displayTarget),
+                    elementLabelMeta: buildLocalTextDescriptor(getElementLabel(displayTarget)),
+                    ariaLabelMeta: buildLocalTextDescriptor(getElementAriaLabel(displayTarget)),
+                    placeholderMeta: buildLocalTextDescriptor(getElementPlaceholder(displayTarget)),
+                    clickTargetText: getElementLabel(displayTarget),
+                    clickTargetAriaLabel: getElementAriaLabel(displayTarget),
+                    clickTargetTitle: displayTarget.getAttribute("title") || null,
+                    fieldName: extractFieldName(displayTarget),
+                    fieldType: extractFieldType(displayTarget),
+                    fieldDisplayLabel: getElementLabel(displayTarget),
+                    fieldAriaLabel: getElementAriaLabel(displayTarget),
+                    fieldPlaceholder: getElementPlaceholder(displayTarget),
+                    isEditable: isEditableElement(displayTarget),
+                    sectionHeading: getElementSectionHeading(displayTarget),
+                },
+            });
+        }
+        catch (error) {
+            context.onInternalError("capture/action:click", error);
+        }
+    };
+    document.addEventListener("click", clickHandler, true);
+    return {
+        stop: () => {
+            document.removeEventListener("click", clickHandler, true);
+        },
+    };
+};

package/dist/capture/dom.d.ts

@@ -0,0 +1,23 @@
+export declare const buildDomPath: (element: Element) => string;
+export declare const getTextPreview: (element: Element) => string | null;
+export declare const getElementClassList: (element: Element) => string[] | null;
+export declare const getElementRole: (element: Element) => string | null;
+export declare const getElementPlaceholder: (element: Element) => string | null;
+export declare const getElementAriaLabel: (element: Element) => string | null;
+export declare const getElementSectionHeading: (element: Element) => string | null;
+export declare const getElementLabel: (element: Element) => string | null;
+export declare const resolveClickDisplayTarget: (element: Element) => Element;
+export type StableKeyQuality = "official" | "compat" | "structural";
+export type StableKeyDescriptor = {
+    stableKey: string;
+    stableKeyQuality: StableKeyQuality;
+    formKey: string | null;
+};
+export declare const getFormKey: (element: Element) => string | null;
+export declare const resolveStableKeyDescriptor: (element: Element) => StableKeyDescriptor;
+export declare const getStableKey: (element: Element) => string;
+export declare const extractFieldName: (element: Element) => string | null;
+export declare const extractFieldType: (element: Element) => string | null;
+export declare const findParentFormId: (element: Element) => string | null;
+export declare const isEditableElement: (element: Element) => boolean;
+export declare const getElementValue: (element: Element) => unknown;

package/dist/capture/dom.js

@@ -0,0 +1,329 @@
+export const buildDomPath = (element) => {
+    const segments = [];
+    let current = element;
+    while (current && segments.length < 8) {
+        const tag = current.tagName.toLowerCase();
+        const id = current.id ? `#${current.id}` : "";
+        const className = typeof current.className === "string" && current.className.trim()
+            ? `.${current.className.trim().split(/\s+/).slice(0, 2).join(".")}`
+            : "";
+        segments.unshift(`${tag}${id}${className}`);
+        current = current.parentElement;
+    }
+    return segments.join(" > ");
+};
+export const getTextPreview = (element) => {
+    const text = element.textContent?.trim() ?? "";
+    if (!text) {
+        return null;
+    }
+    return text.slice(0, 120);
+};
+export const getElementClassList = (element) => {
+    if (typeof element.className !== "string") {
+        return null;
+    }
+    const classList = element.className.trim().split(/\s+/).filter(Boolean);
+    return classList.length > 0 ? classList : null;
+};
+export const getElementRole = (element) => {
+    return element.getAttribute("role") || null;
+};
+export const getElementPlaceholder = (element) => {
+    if (element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement) {
+        return element.placeholder || null;
+    }
+    return null;
+};
+export const getElementAriaLabel = (element) => {
+    return element.getAttribute("aria-label") || null;
+};
+const SECTION_CONTAINER_SELECTOR = [
+    "section",
+    "article",
+    "aside",
+    "nav",
+    "main",
+    "form",
+    "fieldset",
+    "dialog",
+    "[role='dialog']",
+    "[role='region']",
+].join(",");
+const SECTION_HEADING_SELECTOR = [
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "legend",
+].join(",");
+const readSectionHeadingLabel = (container) => {
+    const labelledBy = container.getAttribute("aria-labelledby");
+    if (labelledBy) {
+        const labelNode = container.ownerDocument?.getElementById(labelledBy);
+        if (labelNode instanceof Element) {
+            const text = getTextPreview(labelNode);
+            if (text) {
+                return text;
+            }
+        }
+    }
+    const headingNode = container.querySelector(SECTION_HEADING_SELECTOR);
+    if (headingNode instanceof Element) {
+        const text = getTextPreview(headingNode);
+        if (text) {
+            return text;
+        }
+    }
+    return (container.getAttribute("aria-label") ||
+        container.getAttribute("title") ||
+        null);
+};
+export const getElementSectionHeading = (element) => {
+    let container = element.closest(SECTION_CONTAINER_SELECTOR);
+    while (container) {
+        const label = readSectionHeadingLabel(container);
+        if (label) {
+            return label;
+        }
+        container = container.parentElement?.closest(SECTION_CONTAINER_SELECTOR) ?? null;
+    }
+    return null;
+};
+export const getElementLabel = (element) => {
+    if (element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement ||
+        element instanceof HTMLSelectElement) {
+        const label = element.labels?.[0]?.textContent?.trim();
+        return label || null;
+    }
+    const ownText = Array.from(element.childNodes)
+        .filter((node) => node.nodeType === Node.TEXT_NODE)
+        .map((node) => node.textContent?.trim() ?? "")
+        .filter((value) => value.length > 0)
+        .join(" ")
+        .trim();
+    if (ownText) {
+        return ownText.slice(0, 120);
+    }
+    const isInteractiveDisplayTarget = element instanceof HTMLButtonElement ||
+        element instanceof HTMLAnchorElement ||
+        element.getAttribute("role") === "button" ||
+        element.getAttribute("role") === "link";
+    const descendantCandidates = Array.from(element.querySelectorAll("label, p, span, strong, em, small, button, a, [role='button'], [role='link']"))
+        .map((candidate) => candidate.textContent?.trim() ?? "")
+        .map((value) => value.replace(/\s+/g, " ").trim())
+        .filter((value) => value.length > 0 && value.length <= 80);
+    if (isInteractiveDisplayTarget && descendantCandidates.length > 0) {
+        return descendantCandidates[0] ?? null;
+    }
+    if (descendantCandidates.length > 0) {
+        descendantCandidates.sort((left, right) => {
+            const leftWordCount = left.split(/\s+/).length;
+            const rightWordCount = right.split(/\s+/).length;
+            if (leftWordCount !== rightWordCount) {
+                return leftWordCount - rightWordCount;
+            }
+            return left.length - right.length;
+        });
+        return descendantCandidates[0] ?? null;
+    }
+    return getTextPreview(element);
+};
+const CLICKABLE_DISPLAY_SELECTOR = [
+    "a[href]",
+    "button",
+    "input",
+    "textarea",
+    "select",
+    "[role='button']",
+    "[role='link']",
+].join(",");
+export const resolveClickDisplayTarget = (element) => {
+    const matched = element.closest(CLICKABLE_DISPLAY_SELECTOR);
+    return matched ?? element;
+};
+const SAFE_FALLBACK_STABLE_IDENTIFIER = /^[a-z0-9._:-]{1,80}$/i;
+const toSafeFallbackStableSegment = (value) => {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.trim();
+    if (!normalized || !SAFE_FALLBACK_STABLE_IDENTIFIER.test(normalized)) {
+        return null;
+    }
+    return normalized.toLowerCase();
+};
+const buildCoarsePosition = (element) => {
+    const segments = [];
+    let current = element;
+    let depth = 0;
+    while (current && depth < 4) {
+        const parent = current.parentElement;
+        if (!parent) {
+            break;
+        }
+        const siblings = Array.from(parent.children);
+        const currentTagName = current.tagName;
+        const sameTagSiblings = siblings.filter((child) => child.tagName === currentTagName);
+        const positionIndex = siblings.indexOf(current) + 1;
+        const sameTagIndex = sameTagSiblings.indexOf(current) + 1;
+        segments.unshift(`p${positionIndex}-t${sameTagIndex}`);
+        current = parent;
+        depth += 1;
+    }
+    if (segments.length === 0) {
+        return "root";
+    }
+    return segments.join("/");
+};
+const buildStructuralStableKey = (element) => {
+    const tag = element.tagName.toLowerCase();
+    const role = toSafeFallbackStableSegment(getElementRole(element)) || "none";
+    const inputType = (element instanceof HTMLInputElement && element.type) ||
+        (element instanceof HTMLTextAreaElement && "textarea") ||
+        (element instanceof HTMLSelectElement && "select") ||
+        (element instanceof HTMLElement &&
+            element.isContentEditable &&
+            "contenteditable") ||
+        "na";
+    return `struct:${tag}:${role}:${inputType}:${buildCoarsePosition(element)}`;
+};
+export const getFormKey = (element) => {
+    return toSafeFallbackStableSegment(findParentFormId(element));
+};
+export const resolveStableKeyDescriptor = (element) => {
+    const dataTestId = toSafeFallbackStableSegment(element.getAttribute("data-testid"));
+    if (dataTestId) {
+        return {
+            stableKey: `dtid:${dataTestId}`,
+            stableKeyQuality: "compat",
+            formKey: getFormKey(element),
+        };
+    }
+    const dataQa = toSafeFallbackStableSegment(element.getAttribute("data-qa"));
+    if (dataQa) {
+        return {
+            stableKey: `dqa:${dataQa}`,
+            stableKeyQuality: "compat",
+            formKey: getFormKey(element),
+        };
+    }
+    const safeName = toSafeFallbackStableSegment(element.getAttribute("name"));
+    if (safeName) {
+        return {
+            stableKey: `name:${safeName}`,
+            stableKeyQuality: "structural",
+            formKey: getFormKey(element),
+        };
+    }
+    const safeAriaLabel = toSafeFallbackStableSegment(getElementAriaLabel(element));
+    if (safeAriaLabel) {
+        return {
+            stableKey: `aria:${safeAriaLabel}`,
+            stableKeyQuality: "structural",
+            formKey: getFormKey(element),
+        };
+    }
+    const safeId = toSafeFallbackStableSegment(element.id);
+    if (safeId) {
+        return {
+            stableKey: `id:${safeId}`,
+            stableKeyQuality: "structural",
+            formKey: getFormKey(element),
+        };
+    }
+    return {
+        stableKey: buildStructuralStableKey(element),
+        stableKeyQuality: "structural",
+        formKey: getFormKey(element),
+    };
+};
+export const getStableKey = (element) => {
+    return resolveStableKeyDescriptor(element).stableKey;
+};
+export const extractFieldName = (element) => {
+    if (element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement ||
+        element instanceof HTMLSelectElement) {
+        return (element.getAttribute("name") ||
+            element.getAttribute("id") ||
+            element.getAttribute("aria-label") ||
+            null);
+    }
+    if (element instanceof HTMLElement && element.isContentEditable) {
+        return (element.getAttribute("data-field-name") ||
+            element.getAttribute("aria-label") ||
+            element.getAttribute("id") ||
+            null);
+    }
+    return null;
+};
+export const extractFieldType = (element) => {
+    if (element instanceof HTMLInputElement) {
+        return element.type || "input";
+    }
+    if (element instanceof HTMLTextAreaElement) {
+        return "textarea";
+    }
+    if (element instanceof HTMLSelectElement) {
+        return "select";
+    }
+    if (element instanceof HTMLElement && element.isContentEditable) {
+        return "contenteditable";
+    }
+    return null;
+};
+export const findParentFormId = (element) => {
+    if (element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement ||
+        element instanceof HTMLSelectElement) {
+        const form = element.form;
+        return form ? form.id || form.getAttribute("name") || null : null;
+    }
+    if (element instanceof HTMLElement) {
+        const form = element.closest("form");
+        return form instanceof HTMLFormElement
+            ? form.id || form.getAttribute("name") || null
+            : null;
+    }
+    return null;
+};
+export const isEditableElement = (element) => {
+    return Boolean(element instanceof HTMLInputElement ||
+        element instanceof HTMLTextAreaElement ||
+        element instanceof HTMLSelectElement ||
+        (element instanceof HTMLElement && element.isContentEditable));
+};
+export const getElementValue = (element) => {
+    if (element instanceof HTMLInputElement) {
+        if (element.type === "checkbox") {
+            return element.checked;
+        }
+        if (element.type === "radio") {
+            return element.checked ? element.value : null;
+        }
+        if (element.type === "file") {
+            return {
+                fileCount: element.files?.length ?? 0,
+            };
+        }
+        return element.value;
+    }
+    if (element instanceof HTMLTextAreaElement) {
+        return element.value;
+    }
+    if (element instanceof HTMLSelectElement) {
+        if (element.multiple) {
+            return Array.from(element.selectedOptions).map((option) => option.value);
+        }
+        return element.value;
+    }
+    if (element instanceof HTMLElement && element.isContentEditable) {
+        return element.textContent?.trim() ?? null;
+    }
+    return null;
+};

package/dist/capture/drag.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureModuleContext, CaptureStopHandle } from "../core/types";
+export declare const startDragCapture: (context: CaptureModuleContext) => CaptureStopHandle;

package/dist/capture/drag.js

@@ -0,0 +1,75 @@
+import { buildLocalValueDescriptor } from "../privacy/local-minimization";
+import { extractFieldName, extractFieldType, getElementAriaLabel, getElementLabel, getElementPlaceholder, getElementRole, getElementSectionHeading, resolveStableKeyDescriptor, } from "./dom";
+const readDragPayload = (event) => {
+    const dataTransfer = event.dataTransfer;
+    if (!dataTransfer) {
+        return {
+            itemCount: 0,
+            fileCount: 0,
+            dragTypes: [],
+        };
+    }
+    const itemCount = dataTransfer.items?.length ?? 0;
+    const fileCount = dataTransfer.files?.length ?? 0;
+    const dragTypes = Array.from(dataTransfer.types ?? []).filter(Boolean);
+    return {
+        itemCount,
+        fileCount,
+        dragTypes,
+    };
+};
+export const startDragCapture = (context) => {
+    if (typeof document === "undefined") {
+        return { stop: () => undefined };
+    }
+    const dropHandler = (event) => {
+        if (context.getConsent() === "denied") {
+            return;
+        }
+        const target = event.target;
+        if (!(target instanceof Element)) {
+            return;
+        }
+        if (context.shouldIgnoreElement?.(target)) {
+            return;
+        }
+        try {
+            const stableKey = resolveStableKeyDescriptor(target);
+            const dragPayload = readDragPayload(event);
+            context.onEvent({
+                type: "drag_drop_completed",
+                occurredAtMs: Date.now(),
+                payload: {
+                    viewId: context.getViewId(),
+                    elementTag: target.tagName.toLowerCase(),
+                    elementRole: getElementRole(target),
+                    stableKey: stableKey.stableKey,
+                    stableKeyQuality: stableKey.stableKeyQuality,
+                    formKey: stableKey.formKey,
+                    fieldNameMeta: buildLocalValueDescriptor(extractFieldName(target)),
+                    elementLabelMeta: buildLocalValueDescriptor(getElementLabel(target)),
+                    ariaLabelMeta: buildLocalValueDescriptor(getElementAriaLabel(target)),
+                    placeholderMeta: buildLocalValueDescriptor(getElementPlaceholder(target)),
+                    fieldName: extractFieldName(target),
+                    fieldType: extractFieldType(target),
+                    fieldDisplayLabel: getElementLabel(target),
+                    fieldAriaLabel: getElementAriaLabel(target),
+                    fieldPlaceholder: getElementPlaceholder(target),
+                    sectionHeading: getElementSectionHeading(target),
+                    dragItemCount: dragPayload.itemCount,
+                    fileCount: dragPayload.fileCount,
+                    dragTypes: dragPayload.dragTypes,
+                },
+            });
+        }
+        catch (error) {
+            context.onInternalError("capture/drag:drop", error);
+        }
+    };
+    document.addEventListener("drop", dropHandler, true);
+    return {
+        stop: () => {
+            document.removeEventListener("drop", dropHandler, true);
+        },
+    };
+};

package/dist/capture/error.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureModuleContext, CaptureStopHandle } from "../core/types";
+export declare const startErrorCapture: (context: CaptureModuleContext) => CaptureStopHandle;

package/dist/capture/error.js

@@ -0,0 +1,193 @@
+const ERROR_BURST_DEBOUNCE_MS = 250;
+const hashString = (value) => {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `err_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+const sourceFileHintFromValue = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        const resolved = new URL(value, globalThis.location?.origin);
+        const segments = resolved.pathname.split("/").filter(Boolean);
+        return segments[segments.length - 1] ?? null;
+    }
+    catch {
+        const normalized = value.split(/[?#]/, 1)[0] ?? value;
+        const segments = normalized.split("/").filter(Boolean);
+        return segments[segments.length - 1] ?? (normalized || null);
+    }
+};
+const buildFingerprint = (input) => {
+    const firstStackLine = input.stack
+        ?.split("\n")
+        .map((line) => line.trim())
+        .find(Boolean) ?? "";
+    return hashString([
+        input.type,
+        input.errorType ?? "",
+        input.message ?? "",
+        sourceFileHintFromValue(input.sourceFile) ?? "",
+        input.lineNumber ?? "",
+        input.columnNumber ?? "",
+        firstStackLine,
+    ].join("|"));
+};
+export const startErrorCapture = (context) => {
+    if (typeof window === "undefined") {
+        return { stop: () => undefined };
+    }
+    const pendingByFingerprint = new Map();
+    const flushFingerprint = (fingerprint) => {
+        const bucket = pendingByFingerprint.get(fingerprint);
+        if (!bucket) {
+            return;
+        }
+        if (bucket.timer) {
+            clearTimeout(bucket.timer);
+        }
+        context.onEvent({
+            type: bucket.event.type,
+            occurredAtMs: bucket.lastOccurredAtMs,
+            payload: {
+                ...bucket.event.payload,
+                repeatCount: bucket.repeatCount,
+            },
+        });
+        pendingByFingerprint.delete(fingerprint);
+    };
+    const scheduleFlush = (fingerprint) => {
+        const bucket = pendingByFingerprint.get(fingerprint);
+        if (!bucket) {
+            return;
+        }
+        if (bucket.timer) {
+            clearTimeout(bucket.timer);
+        }
+        bucket.timer = setTimeout(() => {
+            flushFingerprint(fingerprint);
+        }, ERROR_BURST_DEBOUNCE_MS);
+    };
+    const queueErrorEnvelope = (type, occurredAtMs, payload) => {
+        const fingerprint = String(payload.errorFingerprint ?? "");
+        if (!fingerprint) {
+            context.onEvent({
+                type,
+                occurredAtMs,
+                payload: {
+                    ...payload,
+                    repeatCount: 1,
+                },
+            });
+            return;
+        }
+        const existing = pendingByFingerprint.get(fingerprint);
+        if (existing) {
+            existing.repeatCount += 1;
+            existing.lastOccurredAtMs = occurredAtMs;
+            existing.event.payload = {
+                ...existing.event.payload,
+                ...payload,
+            };
+            scheduleFlush(fingerprint);
+            return;
+        }
+        pendingByFingerprint.set(fingerprint, {
+            event: {
+                type,
+                occurredAtMs,
+                payload,
+            },
+            repeatCount: 1,
+            lastOccurredAtMs: occurredAtMs,
+            timer: null,
+        });
+        scheduleFlush(fingerprint);
+    };
+    const errorHandler = (event) => {
+        if (context.getConsent() === "denied") {
+            return;
+        }
+        try {
+            const occurredAtMs = Date.now();
+            const sourceFile = event.filename || null;
+            const fingerprint = buildFingerprint({
+                type: "frontend_error",
+                errorType: event.error?.name || event.type || "Error",
+                message: event.message || null,
+                sourceFile,
+                lineNumber: event.lineno || undefined,
+                columnNumber: event.colno || undefined,
+                stack: event.error && typeof event.error.stack === "string"
+                    ? event.error.stack
+                    : null,
+            });
+            queueErrorEnvelope("frontend_error", occurredAtMs, {
+                viewId: context.getViewId(),
+                errorType: event.error?.name || event.type || "Error",
+                errorFingerprint: fingerprint,
+                sourceFileHint: sourceFileHintFromValue(sourceFile),
+                message: event.message || null,
+                stack: event.error && typeof event.error.stack === "string"
+                    ? event.error.stack
+                    : null,
+                sourceFile,
+                lineNumber: event.lineno || undefined,
+                columnNumber: event.colno || undefined,
+            });
+        }
+        catch (error) {
+            context.onInternalError("capture/error:error", error);
+        }
+    };
+    const rejectionHandler = (event) => {
+        if (context.getConsent() === "denied") {
+            return;
+        }
+        try {
+            const reason = event.reason;
+            const message = reason instanceof Error
+                ? reason.message
+                : typeof reason === "string"
+                    ? reason
+                    : null;
+            const stack = reason instanceof Error ? (reason.stack ?? null) : null;
+            const errorType = reason instanceof Error ? reason.name : "PromiseRejection";
+            const occurredAtMs = Date.now();
+            const fingerprint = buildFingerprint({
+                type: "unhandled_rejection",
+                errorType,
+                message,
+                sourceFile: null,
+                stack,
+            });
+            queueErrorEnvelope("unhandled_rejection", occurredAtMs, {
+                viewId: context.getViewId(),
+                errorType,
+                errorFingerprint: fingerprint,
+                sourceFileHint: null,
+                message,
+                stack,
+                sourceFile: null,
+            });
+        }
+        catch (error) {
+            context.onInternalError("capture/error:unhandledrejection", error);
+        }
+    };
+    window.addEventListener("error", errorHandler);
+    window.addEventListener("unhandledrejection", rejectionHandler);
+    return {
+        stop: () => {
+            for (const fingerprint of pendingByFingerprint.keys()) {
+                flushFingerprint(fingerprint);
+            }
+            window.removeEventListener("error", errorHandler);
+            window.removeEventListener("unhandledrejection", rejectionHandler);
+        },
+    };
+};