clarity-js 0.8.11 → 0.8.13-beta

package/src/core/event.ts

@@ -1,57 +1,53 @@
-import { type BrowserEvent, Constant } from "@clarity-types/core";
+import { BrowserEvent, Constant } from "@clarity-types/core";
 import api from "./api";
 import measure from "./measure";
 
 let bindings: Map<EventTarget, BrowserEvent[]> = new Map();
 
-export function bind(target: EventTarget, event: string, listener: EventListener, capture = false, passive = true): void {
-    // biome-ignore lint/style/noParameterAssign: intentionally reassigning the event listener for caller
-    listener = measure(listener) as EventListener;
-    // Wrapping following lines inside try / catch to cover edge cases where we might try to access an inaccessible element.
-    // E.g. Iframe may start off as same-origin but later turn into cross-origin, and the following lines will throw an exception.
-    try {
-        target[api(Constant.AddEventListener)](event, listener, { capture, passive });
-        if (!has(target)) {
-            bindings.set(target, []);
-        }
-
-        bindings.get(target).push({ event, listener, options: { capture, passive } });
-    } catch {
-        /* do nothing */
+export function bind(target: EventTarget, event: string, listener: EventListener, capture: boolean = false, passive: boolean = true): void {
+  listener = measure(listener) as EventListener;
+  // Wrapping following lines inside try / catch to cover edge cases where we might try to access an inaccessible element.
+  // E.g. Iframe may start off as same-origin but later turn into cross-origin, and the following lines will throw an exception.
+  try {
+    target[api(Constant.AddEventListener)](event, listener, { capture, passive });
+    if (!has(target)) {
+      bindings.set(target, []);
     }
+
+    bindings.get(target).push({ event, listener, options: { capture, passive } });
+  } catch {
+    /* do nothing */
+  }
 }
 
 export function reset(): void {
-    // Walk through existing list of bindings and remove them all
-    bindings.forEach((bindingsPerTarget: BrowserEvent[], target: EventTarget) => {
-        resetByTarget(bindingsPerTarget, target);
-    });
+  // Walk through existing list of bindings and remove them all
+  bindings.forEach((bindingsPerTarget: BrowserEvent[], target: EventTarget) => {
+    resetByTarget(bindingsPerTarget, target);
+  });
 
-    bindings = new Map();
+  bindings = new Map();
 }
 
 export function unbind(target: EventTarget) {
-    if (!has(target)) {
-        return;
-    }
-    resetByTarget(bindings.get(target), target);
+  if (!has(target)) {
+    return;
+  }
+  resetByTarget(bindings.get(target), target);
 }
 
 export function has(target: EventTarget): boolean {
-    return bindings.has(target);
+  return bindings.has(target);
 }
 
 function resetByTarget(bindingsPerTarget: BrowserEvent[], target: EventTarget): void {
-    for (const binding of bindingsPerTarget) {
-        // Wrapping inside try / catch to avoid situations where the element may be destroyed before we get a chance to unbind
-        try {
-            target[api(Constant.RemoveEventListener)](binding.event, binding.listener, {
-                capture: binding.options.capture,
-                passive: binding.options.passive,
-            });
-        } catch {
-            /* do nothing */
-        }
+  bindingsPerTarget.forEach((binding) => {
+    // Wrapping inside try / catch to avoid situations where the element may be destroyed before we get a chance to unbind
+    try {
+      target[api(Constant.RemoveEventListener)](binding.event, binding.listener, { capture: binding.options.capture, passive: binding.options.passive });
+    } catch {
+      /* do nothing */
     }
-    bindings.delete(target);
+  });
+  bindings.delete(target);
 }

package/src/core/hash.ts

@@ -1,18 +1,19 @@
-export default function (input: string, precision: number = null): string {
+// tslint:disable: no-bitwise
+export default function(input: string, precision: number = null): string {
     // Code inspired from C# GetHashCode: https://github.com/Microsoft/referencesource/blob/master/mscorlib/system/string.cs
     let hash = 0;
     let hashOne = 5381;
     let hashTwo = hashOne;
     for (let i = 0; i < input.length; i += 2) {
-        const charOne = input.charCodeAt(i);
+        let charOne = input.charCodeAt(i);
         hashOne = ((hashOne << 5) + hashOne) ^ charOne;
         if (i + 1 < input.length) {
-            const charTwo = input.charCodeAt(i + 1);
+            let charTwo = input.charCodeAt(i + 1);
             hashTwo = ((hashTwo << 5) + hashTwo) ^ charTwo;
         }
     }
     // Replace the magic number from C# implementation (1566083941) with a smaller prime number (11579)
     // This ensures we don't hit integer overflow and prevent collisions
-    hash = Math.abs(hashOne + hashTwo * 11579);
-    return (precision ? hash % 2 ** precision : hash).toString(36);
+    hash = Math.abs(hashOne + (hashTwo * 11579));
+    return (precision ? hash % Math.pow(2, precision) : hash).toString(36);
 }

package/src/core/history.ts

@@ -1,10 +1,10 @@
 import { BooleanFlag, Code, Constant, Metric, Setting, Severity } from "@clarity-types/data";
 import { FunctionNames } from "@clarity-types/performance";
 import * as clarity from "@src/clarity";
-import * as core from "@src/core";
+import * as core from "@src/core"
 import { bind } from "@src/core/event";
-import * as metric from "@src/data/metric";
 import * as internal from "@src/diagnostic/internal";
+import * as metric from "@src/data/metric";
 
 let pushState = null;
 let replaceState = null;
@@ -17,10 +17,10 @@ export function start(): void {
     bind(window, "popstate", compute);
 
     // Add a proxy to history.pushState function
-    if (pushState === null) {
-        pushState = history.pushState;
-        history.pushState = function (...args): void {
-            pushState.apply(this, args);
+    if (pushState === null) { 
+        pushState = history.pushState; 
+        history.pushState = function(): void {
+            pushState.apply(this, arguments);
             if (core.active() && check()) {
                 compute();
             }
@@ -28,10 +28,11 @@ export function start(): void {
     }
 
     // Add a proxy to history.replaceState function
-    if (replaceState === null) {
-        replaceState = history.replaceState;
-        history.replaceState = function (...args): void {
-            replaceState.apply(this, args);
+    if (replaceState === null) 
+    { 
+        replaceState = history.replaceState; 
+        history.replaceState = function(): void {
+            replaceState.apply(this, arguments);
             if (core.active() && check()) {
                 compute();
             }

package/src/core/index.ts

@@ -1,13 +1,13 @@
-import type { Config } from "@clarity-types/core";
+import { Config } from "@clarity-types/core";
 import { Constant } from "@clarity-types/data";
 import { FunctionNames } from "@clarity-types/performance";
-import * as clarity from "@src/clarity";
 import configuration from "@src/core/config";
 import * as event from "@src/core/event";
 import * as history from "@src/core/history";
 import * as report from "@src/core/report";
 import * as task from "@src/core/task";
 import * as time from "@src/core/time";
+import * as clarity from "@src/clarity";
 import * as custom from "@src/data/custom";
 
 let status = false;
@@ -36,17 +36,15 @@ export function active(): boolean {
 
 export function check(): boolean {
     try {
-        const globalPrivacyControlSet = navigator && "globalPrivacyControl" in navigator && navigator.globalPrivacyControl === true;
-        return (
-            status === false &&
+        let globalPrivacyControlSet = navigator && "globalPrivacyControl" in navigator && navigator['globalPrivacyControl'] == true;
+        return status === false &&
             typeof Promise !== "undefined" &&
-            window.MutationObserver &&
-            document.createTreeWalker &&
+            window["MutationObserver"] &&
+            document["createTreeWalker"] &&
             "now" in Date &&
             "now" in performance &&
             typeof WeakMap !== "undefined" &&
             !globalPrivacyControlSet
-        );
     } catch (ex) {
         return false;
     }
@@ -54,13 +52,9 @@ export function check(): boolean {
 
 export function config(override: Config): boolean {
     // Process custom configuration overrides, if available
-    if (override === null || status) {
-        return false;
-    }
-    for (const key in override) {
-        if (key in configuration) {
-            configuration[key] = override[key];
-        }
+    if (override === null || status) { return false; }
+    for (let key in override) {
+        if (key in configuration) { configuration[key] = override[key]; }
     }
     return true;
 }
@@ -77,12 +71,8 @@ export function suspend(): void {
     if (status) {
         custom.event(Constant.Clarity, Constant.Suspend);
         clarity.stop();
-        for (const x of ["mousemove", "touchstart"]) {
-            event.bind(document, x, restart);
-        }
-        for (const x of ["resize", "scroll", "pageshow"]) {
-            event.bind(window, x, restart);
-        }
+        ["mousemove", "touchstart"].forEach(x => event.bind(document, x, restart));
+        ["resize", "scroll", "pageshow"].forEach(x => event.bind(window, x, restart));
     }
 }
 

package/src/core/measure.ts

@@ -3,16 +3,12 @@ import { report } from "@src/core/report";
 import * as metric from "@src/data/metric";
 import * as internal from "@src/diagnostic/internal";
 
-// biome-ignore lint/complexity/noBannedTypes: specifically looking to instrument function calls
+// tslint:disable-next-line: ban-types
 export default function (method: Function): Function {
-    return function (...args): void {
-        const start = performance.now();
-        try {
-            method.apply(this, args);
-        } catch (ex) {
-            throw report(ex);
-        }
-        const duration = performance.now() - start;
+    return function (): void {
+        let start = performance.now();
+        try { method.apply(this, arguments); } catch (ex) { throw report(ex); }
+        let duration = performance.now() - start;
         metric.sum(Metric.TotalCost, duration);
         if (duration > Setting.LongTask) {
             metric.count(Metric.LongTaskCount);

package/src/core/report.ts

@@ -1,4 +1,4 @@
-import type { Report } from "@clarity-types/core";
+import { Report } from "@clarity-types/core";
 import config from "@src/core/config";
 import { data } from "@src/data/envelope";
 
@@ -12,7 +12,7 @@ export function report(e: Error): Error {
     // Do not report the same message twice for the same page
     if (history && history.indexOf(e.message) === -1) {
         const url = config.report;
-        if (url && url.length > 0) {
+        if (url && url.length > 0 && data) {
             const payload: Report = { v: data.version, p: data.projectId, u: data.userId, s: data.sessionId, n: data.pageNum };
             if (e.message) {
                 payload.m = e.message;
@@ -22,7 +22,7 @@ export function report(e: Error): Error {
             }
             // Using POST request instead of a GET request (img-src) to not violate existing CSP rules
             // Since, Clarity already uses XHR to upload data, we stick with similar POST mechanism for reporting too
-            const xhr = new XMLHttpRequest();
+            let xhr = new XMLHttpRequest();
             xhr.open("POST", url, true);
             xhr.send(JSON.stringify(payload));
             history.push(e.message);

package/src/core/scrub.ts

@@ -10,9 +10,9 @@ let digitRegex = null;
 let letterRegex = null;
 let currencyRegex = null;
 
-export function text(value: string, hint: string, privacy: Privacy, mangle = false, type?: string): string {
+export function text(value: string, hint: string, privacy: Privacy, mangle: boolean = false, type?: string): string {
     if (value) {
-        if (hint === "input" && (type === "checkbox" || type === "radio")) {
+        if (hint == "input" && (type === "checkbox" || type === "radio")) {
             return value;
         }
 
@@ -88,21 +88,17 @@ export function text(value: string, hint: string, privacy: Privacy, mangle = fal
     return value;
 }
 
-export function url(input: string, electron = false, truncate = false): string {
+export function url(input: string, electron: boolean = false, truncate: boolean = false): string {
     let result = input;
     // Replace the URL for Electron apps so we don't send back file:/// URL
     if (electron) {
         result = `${Data.Constant.HTTPS}${Data.Constant.Electron}`;
     } else {
-        const drop = config.drop;
+        let drop = config.drop;
         if (drop && drop.length > 0 && input && input.indexOf("?") > 0) {
-            const [path, query] = input.split("?");
-            const swap = Data.Constant.Dropped;
-            result =
-                `${path}?${query
-                    .split("&")
-                    .map((p) => (drop.some((x) => p.indexOf(`${x}=`) === 0) ? `${p.split("=")[0]}=${swap}` : p))
-                    .join("&")}`;
+            let [path, query] = input.split("?");
+            let swap = Data.Constant.Dropped;
+            result = path + "?" + query.split("&").map(p => drop.some(x => p.indexOf(`${x}=`) === 0) ? `${p.split("=")[0]}=${swap}` : p).join("&");
         }
     }
 
@@ -113,12 +109,12 @@ export function url(input: string, electron = false, truncate = false): string {
 }
 
 function mangleText(value: string): string {
-    const trimmed = value.trim();
+    let trimmed = value.trim();
     if (trimmed.length > 0) {
-        const first = trimmed[0];
-        const index = value.indexOf(first);
-        const prefix = value.substr(0, index);
-        const suffix = value.substr(index + trimmed.length);
+        let first = trimmed[0];
+        let index = value.indexOf(first);
+        let prefix = value.substr(0, index);
+        let suffix = value.substr(index + trimmed.length);
         return `${prefix}${trimmed.length.toString(36)}${suffix}`;
     }
     return value;
@@ -134,7 +130,7 @@ export function scrub(value: string, letter: string, digit: string): string {
 }
 
 function mangleToken(value: string): string {
-    const length = (Math.floor(value.length / Data.Setting.WordLength) + 1) * Data.Setting.WordLength;
+    let length = ((Math.floor(value.length / Data.Setting.WordLength) + 1) * Data.Setting.WordLength);
     let output: string = Layout.Constant.Empty;
     for (let i = 0; i < length; i++) {
         output += i > 0 && i % Data.Setting.WordLength === 0 ? Data.Constant.Space : Data.Constant.Mask;
@@ -147,12 +143,10 @@ function regex(): void {
     // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes
     if (unicodeRegex && digitRegex === null) {
         try {
-            digitRegex = /\p{N}/gu;
-            letterRegex = /\p{L}/gu;
-            currencyRegex = /\p{Sc}/gu;
-        } catch {
-            unicodeRegex = false;
-        }
+            digitRegex = new RegExp("\\p{N}", "gu");
+            letterRegex = new RegExp("\\p{L}", "gu");
+            currencyRegex = new RegExp("\\p{Sc}", "gu");
+        } catch { unicodeRegex = false; }
     }
 }
 
@@ -167,19 +161,16 @@ function redact(value: string): string {
     regex(); // Initialize regular expressions
 
     for (let i = 0; i < value.length; i++) {
-        const c = value.charCodeAt(i);
+        let c = value.charCodeAt(i);
         hasDigit = hasDigit || (c >= Data.Character.Zero && c <= Data.Character.Nine); // Check for digits in the current word
         hasEmail = hasEmail || c === Data.Character.At; // Check for @ sign anywhere within the current word
-        hasWhitespace =
-            c === Data.Character.Tab || c === Data.Character.NewLine || c === Data.Character.Return || c === Data.Character.Blank;
+        hasWhitespace = c === Data.Character.Tab || c === Data.Character.NewLine || c === Data.Character.Return || c === Data.Character.Blank;
 
         // Process each word as an individual token to redact any sensitive information
         if (i === 0 || i === value.length - 1 || hasWhitespace) {
             // Performance optimization: Lazy load string -> array conversion only when required
             if (hasDigit || hasEmail) {
-                if (array === null) {
-                    array = value.split(Data.Constant.Empty);
-                }
+                if (array === null) { array = value.split(Data.Constant.Empty); }
                 // Work on a token at a time so we don't have to apply regex to a larger string
                 let token = value.substring(spaceIndex + 1, hasWhitespace ? i : i + 1);
                 // Check if unicode regex is supported, otherwise fallback to calling mask function on this token

package/src/core/task.ts

@@ -1,12 +1,5 @@
-import {
-    type AsyncTask,
-    Priority,
-    type RequestIdleCallbackDeadline,
-    type RequestIdleCallbackOptions,
-    Task,
-    type Timer,
-} from "@clarity-types/core";
-import type { TaskFunction, TaskResolve, Tasks } from "@clarity-types/core";
+import { AsyncTask, Priority, RequestIdleCallbackDeadline, RequestIdleCallbackOptions, Task, Timer } from "@clarity-types/core";
+import { TaskFunction, TaskResolve, Tasks } from "@clarity-types/core";
 import { Code, Metric, Setting, Severity } from "@clarity-types/data";
 import * as metadata from "@src/data/metadata";
 import * as metric from "@src/data/metric";
@@ -32,9 +25,7 @@ export function resume(): void {
     if (pauseTask) {
         resumeResolve();
         pauseTask = null;
-        if (activeTask === null) {
-            run();
-        }
+        if (activeTask === null) { run(); }
     }
 }
 
@@ -47,14 +38,14 @@ export function reset(): void {
 
 export async function schedule(task: TaskFunction, priority: Priority = Priority.Normal): Promise<void> {
     // If this task is already scheduled, skip it
-    for (const q of queuedTasks) {
+    for (let q of queuedTasks) {
         if (q.task === task) {
             return;
         }
     }
 
-    const promise = new Promise<void>((resolve: TaskResolve): void => {
-        const insert = priority === Priority.High ? "unshift" : "push";
+    let promise = new Promise<void>((resolve: TaskResolve): void => {
+        let insert = priority === Priority.High ? "unshift" : "push";
         // Queue this task for asynchronous execution later
         // We also store a unique page identifier (id) along with the task to ensure
         // ensure that we do not accidentally execute this task in context of a different page
@@ -63,49 +54,38 @@ export async function schedule(task: TaskFunction, priority: Priority = Priority
 
     // If there is no active task running, and Clarity is not in pause state,
     // invoke the first task in the queue synchronously. This ensures that we don't yield the thread during unload event
-    if (activeTask === null && pauseTask === null) {
-        run();
-    }
+    if (activeTask === null && pauseTask === null) { run(); }
 
     return promise;
 }
 
 function run(): void {
-    const entry = queuedTasks.shift();
+    let entry = queuedTasks.shift();
     if (entry) {
         activeTask = entry;
-        entry
-            .task()
-            .then((): void => {
-                // Bail out if the context in which this task was operating is different from the current page
-                // An example scenario where task could span across pages is Single Page Applications (SPA)
-                // A task that started on page #1, but completes on page #2
-                if (entry.id !== metadata.id()) {
-                    return;
-                }
-                entry.resolve();
-                activeTask = null; // Reset active task back to null now that the promise is resolved
-                run();
-            })
-            .catch((error: Error): void => {
-                // If one of the scheduled tasks failed, log, recover and continue processing rest of the tasks
-                if (entry.id !== metadata.id()) {
-                    return;
-                }
-                if (error) {
-                    internal.log(Code.RunTask, Severity.Warning, error.name, error.message, error.stack);
-                }
-                activeTask = null;
-                run();
-            });
+        entry.task().then((): void => {
+            // Bail out if the context in which this task was operating is different from the current page
+            // An example scenario where task could span across pages is Single Page Applications (SPA)
+            // A task that started on page #1, but completes on page #2
+            if (entry.id !== metadata.id()) { return; }
+            entry.resolve();
+            activeTask = null; // Reset active task back to null now that the promise is resolved
+            run();
+        }).catch((error: Error): void => {
+            // If one of the scheduled tasks failed, log, recover and continue processing rest of the tasks
+            if (entry.id !== metadata.id()) { return; }
+            if (error) { internal.log(Code.RunTask, Severity.Warning, error.name, error.message, error.stack); }
+            activeTask = null;
+            run();
+        });
     }
 }
 
 export function state(timer: Timer): Task {
-    const id = key(timer);
+    let id = key(timer);
     if (id in tracker) {
-        const elapsed = performance.now() - tracker[id].start;
-        return elapsed > tracker[id].yield ? Task.Wait : Task.Run;
+        let elapsed = performance.now() - tracker[id].start;
+        return (elapsed > tracker[id].yield) ? Task.Wait : Task.Run;
     }
     // If this task is no longer being tracked, send stop message to the caller
     return Task.Stop;
@@ -116,10 +96,10 @@ export function start(timer: Timer): void {
 }
 
 function restart(timer: Timer): void {
-    const id = key(timer);
-    if (tracker?.[id]) {
-        const c = tracker[id].calls;
-        const y = tracker[id].yield;
+    let id = key(timer);
+    if (tracker && tracker[id]) {
+        let c = tracker[id].calls;
+        let y = tracker[id].yield;
         start(timer);
         tracker[id].calls = c + 1;
         tracker[id].yield = y;
@@ -127,17 +107,15 @@ function restart(timer: Timer): void {
 }
 
 export function stop(timer: Timer): void {
-    const end = performance.now();
-    const id = key(timer);
-    const duration = end - tracker[id].start;
+    let end = performance.now();
+    let id = key(timer);
+    let duration = end - tracker[id].start;
     metric.sum(timer.cost, duration);
     metric.count(Metric.InvokeCount);
 
     // For the first execution, which is synchronous, time is automatically counted towards TotalDuration.
     // However, for subsequent asynchronous runs, we need to manually update TotalDuration metric.
-    if (tracker[id].calls > 0) {
-        metric.sum(Metric.TotalCost, duration);
-    }
+    if (tracker[id].calls > 0) { metric.sum(Metric.TotalCost, duration); }
 }
 
 export async function suspend(timer: Timer): Promise<Task> {
@@ -145,10 +123,10 @@ export async function suspend(timer: Timer): Promise<Task> {
     // It's possible that Clarity is wrapping up instrumentation on a page and we are still in the middle of an async task.
     // In that case, we do not wish to continue yielding thread.
     // Instead, we will turn async task into a sync task and maximize our chances of getting some data back.
-    const id = key(timer);
+    let id = key(timer);
     if (id in tracker) {
         stop(timer);
-        // some customer polyfills for requestIdleCallback return null
+        // some customer polyfills for requestIdleCallback return null 
         tracker[id].yield = (await wait())?.timeRemaining() || Setting.LongTask;
         restart(timer);
     }
@@ -162,9 +140,7 @@ function key(timer: Timer): string {
 }
 
 async function wait(): Promise<RequestIdleCallbackDeadline> {
-    if (pauseTask) {
-        await pauseTask;
-    }
+    if (pauseTask) { await pauseTask; }
     return new Promise<RequestIdleCallbackDeadline>((resolve: (deadline: RequestIdleCallbackDeadline) => void): void => {
         requestIdleCallback(resolve, { timeout: idleTimeout });
     });
@@ -186,24 +162,20 @@ function requestIdleCallbackPolyfill(callback: (deadline: RequestIdleCallbackDea
     const incoming = channel.port1;
     const outgoing = channel.port2;
     incoming.onmessage = (event: MessageEvent): void => {
-        const currentTime = performance.now();
-        const elapsed = currentTime - startTime;
-        const duration = currentTime - event.data;
+        let currentTime = performance.now();
+        let elapsed = currentTime - startTime;
+        let duration = currentTime - event.data;
         if (duration > Setting.LongTask && elapsed < options.timeout) {
-            requestAnimationFrame((): void => {
-                outgoing.postMessage(currentTime);
-            });
+            requestAnimationFrame((): void => { outgoing.postMessage(currentTime); });
         } else {
-            const didTimeout = elapsed > options.timeout;
+            let didTimeout = elapsed > options.timeout;
             callback({
                 didTimeout,
-                timeRemaining: (): number => (didTimeout ? Setting.LongTask : Math.max(0, Setting.LongTask - duration)),
+                timeRemaining: (): number => didTimeout ? Setting.LongTask : Math.max(0, Setting.LongTask - duration)
             });
         }
     };
-    requestAnimationFrame((): void => {
-        outgoing.postMessage(performance.now());
-    });
+    requestAnimationFrame((): void => { outgoing.postMessage(performance.now()); });
 }
 
-const requestIdleCallback = window.requestIdleCallback || requestIdleCallbackPolyfill;
+let requestIdleCallback = window["requestIdleCallback"] || requestIdleCallbackPolyfill;

package/src/core/time.ts

@@ -4,13 +4,13 @@ export function start(): void {
     startTime = performance.now() + performance.timeOrigin;
 }
 
-// event.timestamp is number of milliseconds elapsed since the document was loaded
+// event.timestamp is number of milliseconds elapsed since the document was loaded 
 // since iframes can be loaded later the event timestamp is not the same as performance.now()
 // converting everything to absolute time by adding timeorigin of the event view
 // to synchronize times before calculating the difference with start time
 export function time(event: UIEvent | PageTransitionEvent = null): number {
-    const ts = event && event.timeStamp > 0 ? event.timeStamp : performance.now();
-    const origin = event && (event as UIEvent).view ? (event as UIEvent).view.performance.timeOrigin : performance.timeOrigin;
+    let ts = event && event.timeStamp > 0 ? event.timeStamp : performance.now();
+    let origin = event && (event as UIEvent).view ? (event as UIEvent).view.performance.timeOrigin : performance.timeOrigin;
     return Math.max(Math.round(ts + origin - startTime), 0);
 }
 

package/src/core/timeout.ts

@@ -1,4 +1,4 @@
-import type { Event } from "@clarity-types/data";
+import { Event } from "@clarity-types/data";
 import measure from "./measure";
 
 export function setTimeout(handler: (event?: Event | boolean) => void, timeout?: number, event?: Event): number {
@@ -6,5 +6,5 @@ export function setTimeout(handler: (event?: Event | boolean) => void, timeout?:
 }
 
 export function clearTimeout(handle: number): void {
-    window.clearTimeout(handle);
+    return window.clearTimeout(handle);
 }

package/src/core/version.ts

@@ -1,2 +1,2 @@
-const version = "0.8.11";
+let version = "0.8.13-beta";
 export default version;