clarity-js 0.8.11 → 0.8.13-beta

package/src/interaction/encode.ts

@@ -1,8 +1,9 @@
-import { Constant, Event, type Token } from "@clarity-types/data";
+import { Constant, Event, Token } from "@clarity-types/data";
 import * as scrub from "@src/core/scrub";
 import { time } from "@src/core/time";
 import * as baseline from "@src/data/baseline";
 import { queue } from "@src/data/upload";
+import { metadata } from "@src/layout/target";
 import * as change from "@src/interaction/change";
 import * as click from "@src/interaction/click";
 import * as clipboard from "@src/interaction/clipboard";
@@ -15,10 +16,9 @@ import * as submit from "@src/interaction/submit";
 import * as timeline from "@src/interaction/timeline";
 import * as unload from "@src/interaction/unload";
 import * as visibility from "@src/interaction/visibility";
-import { metadata } from "@src/layout/target";
 
 export default async function (type: Event, ts: number = null): Promise<void> {
-    const t = ts || time();
+    let t = ts || time();
     let tokens: Token[] = [t, type];
     switch (type) {
         case Event.MouseDown:
@@ -30,15 +30,15 @@ export default async function (type: Event, ts: number = null): Promise<void> {
         case Event.TouchEnd:
         case Event.TouchMove:
         case Event.TouchCancel:
-            for (const entry of pointer.state) {
-                const pTarget = metadata(entry.data.target as Node, entry.event);
+            for (let entry of pointer.state) {
+                let pTarget = metadata(entry.data.target as Node, entry.event);
                 if (pTarget.id > 0) {
                     tokens = [entry.time, entry.event];
                     tokens.push(pTarget.id);
                     tokens.push(entry.data.x);
                     tokens.push(entry.data.y);
-                    if (entry.data.id !== undefined) {
-                        tokens.push(entry.data.id);
+                    if (entry.data.id !== undefined) { 
+                        tokens.push(entry.data.id); 
 
                         if (entry.data.isPrimary !== undefined) {
                             tokens.push(entry.data.isPrimary.toString());
@@ -53,10 +53,10 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             pointer.reset();
             break;
         case Event.Click:
-            for (const entry of click.state) {
-                const cTarget = metadata(entry.data.target as Node, entry.event, entry.data.text);
+            for (let entry of click.state) {
+                let cTarget = metadata(entry.data.target as Node, entry.event, entry.data.text);
                 tokens = [entry.time, entry.event];
-                const cHash = cTarget.hash ? cTarget.hash.join(Constant.Dot) : Constant.Empty;
+                let cHash = cTarget.hash ? cTarget.hash.join(Constant.Dot) : Constant.Empty;
                 tokens.push(cTarget.id);
                 tokens.push(entry.data.x);
                 tokens.push(entry.data.y);
@@ -76,9 +76,9 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             click.reset();
             break;
         case Event.Clipboard:
-            for (const entry of clipboard.state) {
+            for (let entry of clipboard.state) {
                 tokens = [entry.time, entry.event];
-                const target = metadata(entry.data.target as Node, entry.event);
+                let target = metadata(entry.data.target as Node, entry.event);
                 if (target.id > 0) {
                     tokens.push(target.id);
                     tokens.push(entry.data.action);
@@ -87,26 +87,24 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             }
             clipboard.reset();
             break;
-        case Event.Resize: {
-            const r = resize.data;
+        case Event.Resize:
+            let r = resize.data;
             tokens.push(r.width);
             tokens.push(r.height);
             baseline.track(type, r.width, r.height);
             resize.reset();
             queue(tokens);
             break;
-        }
-        case Event.Unload: {
-            const u = unload.data;
+        case Event.Unload:
+            let u = unload.data;
             tokens.push(u.name);
             tokens.push(u.persisted);
             unload.reset();
             queue(tokens);
             break;
-        }
         case Event.Input:
-            for (const entry of input.state) {
-                const iTarget = metadata(entry.data.target as Node, entry.event, entry.data.value);
+            for (let entry of input.state) {
+                let iTarget = metadata(entry.data.target as Node, entry.event, entry.data.value);
                 tokens = [entry.time, entry.event];
                 tokens.push(iTarget.id);
                 tokens.push(scrub.text(entry.data.value, "input", iTarget.privacy, false, entry.data.type));
@@ -114,11 +112,11 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             }
             input.reset();
             break;
-        case Event.Selection: {
-            const s = selection.data;
+        case Event.Selection:
+            let s = selection.data;
             if (s) {
-                const startTarget = metadata(s.start as Node, type);
-                const endTarget = metadata(s.end as Node, type);
+                let startTarget = metadata(s.start as Node, type);
+                let endTarget = metadata(s.end as Node, type);
                 tokens.push(startTarget.id);
                 tokens.push(s.startOffset);
                 tokens.push(endTarget.id);
@@ -127,10 +125,9 @@ export default async function (type: Event, ts: number = null): Promise<void> {
                 queue(tokens);
             }
             break;
-        }
         case Event.Scroll:
-            for (const entry of scroll.state) {
-                const sTarget = metadata(entry.data.target as Node, entry.event);
+            for (let entry of scroll.state) {
+                let sTarget = metadata(entry.data.target as Node, entry.event);
                 const top = metadata(entry.data.top as Node, entry.event);
                 const bottom = metadata(entry.data.bottom as Node, entry.event);
                 const sTopHash = top?.hash ? top.hash.join(Constant.Dot) : Constant.Empty;
@@ -149,9 +146,9 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             scroll.reset();
             break;
         case Event.Change:
-            for (const entry of change.state) {
+            for (let entry of change.state) {
                 tokens = [entry.time, entry.event];
-                const target = metadata(entry.data.target as Node, entry.event);
+                let target = metadata(entry.data.target as Node, entry.event);
                 if (target.id > 0) {
                     tokens = [entry.time, entry.event];
                     tokens.push(target.id);
@@ -164,9 +161,9 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             change.reset();
             break;
         case Event.Submit:
-            for (const entry of submit.state) {
+            for (let entry of submit.state) {
                 tokens = [entry.time, entry.event];
-                const target = metadata(entry.data.target as Node, entry.event);
+                let target = metadata(entry.data.target as Node, entry.event);
                 if (target.id > 0) {
                     tokens.push(target.id);
                     queue(tokens);
@@ -175,7 +172,7 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             submit.reset();
             break;
         case Event.Timeline:
-            for (const entry of timeline.updates) {
+            for (let entry of timeline.updates) {
                 tokens = [entry.time, entry.event];
                 tokens.push(entry.data.type);
                 tokens.push(entry.data.hash);
@@ -187,13 +184,12 @@ export default async function (type: Event, ts: number = null): Promise<void> {
             }
             timeline.reset();
             break;
-        case Event.Visibility: {
-            const v = visibility.data;
+        case Event.Visibility:
+            let v = visibility.data;
             tokens.push(v.visible);
             queue(tokens);
             baseline.visibility(t, v.visible);
             visibility.reset();
             break;
-        }
     }
 }

package/src/interaction/input.ts

@@ -1,13 +1,13 @@
 import { Event } from "@clarity-types/data";
-import { type InputData, type InputState, Setting } from "@clarity-types/interaction";
+import { InputData, InputState, Setting } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import { bind } from "@src/core/event";
 import { schedule } from "@src/core/task";
 import { time } from "@src/core/time";
 import { clearTimeout, setTimeout } from "@src/core/timeout";
 import { get } from "@src/layout/dom";
-import { target } from "@src/layout/target";
 import encode from "./encode";
+import { target } from "@src/layout/target";
 
 let timeout: number = null;
 export let state: InputState[] = [];
@@ -22,11 +22,11 @@ export function observe(root: Node): void {
 
 function recompute(evt: UIEvent): void {
     recompute.dn = FunctionNames.InputRecompute;
-    const input = target(evt) as HTMLInputElement;
-    const value = get(input);
-    if (input?.type && value) {
+    let input = target(evt) as HTMLInputElement;
+    let value = get(input);
+    if (input && input.type && value) {
         let v = input.value;
-        const t = input.type;
+        let t = input.type;
         switch (input.type) {
             case "radio":
             case "checkbox":
@@ -34,12 +34,10 @@ function recompute(evt: UIEvent): void {
                 break;
         }
 
-        const data: InputData = { target: input, value: v, type: t };
+        let data: InputData = { target: input, value: v, type: t };
 
         // If last entry in the queue is for the same target node as the current one, remove it so we can later swap it with current data.
-        if (state.length > 0 && state[state.length - 1].data.target === data.target) {
-            state.pop();
-        }
+        if (state.length > 0 && (state[state.length - 1].data.target === data.target)) { state.pop(); }
 
         state.push({ time: time(evt), event: Event.Input, data });
 
@@ -59,4 +57,4 @@ export function reset(): void {
 export function stop(): void {
     clearTimeout(timeout);
     reset();
-}
+}

package/src/interaction/pointer.ts

@@ -1,5 +1,5 @@
 import { Event } from "@clarity-types/data";
-import { type PointerState, Setting } from "@clarity-types/interaction";
+import { PointerState, Setting } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import { bind } from "@src/core/event";
 import { schedule } from "@src/core/task";
@@ -34,47 +34,45 @@ export function observe(root: Node): void {
 
 function mouse(event: Event, root: Node, evt: MouseEvent): void {
     mouse.dn = FunctionNames.PointerMouse;
-    const frame = iframe(root);
-    const d = frame ? frame.contentDocument.documentElement : document.documentElement;
-    let x = "pageX" in evt ? Math.round(evt.pageX) : "clientX" in evt ? Math.round((evt as MouseEvent).clientX + d.scrollLeft) : null;
-    let y = "pageY" in evt ? Math.round(evt.pageY) : "clientY" in evt ? Math.round((evt as MouseEvent).clientY + d.scrollTop) : null;
+    let frame = iframe(root);
+    let d = frame ? frame.contentDocument.documentElement : document.documentElement;
+    let x = "pageX" in evt ? Math.round(evt.pageX) : ("clientX" in evt ? Math.round(evt["clientX"] + d.scrollLeft) : null);
+    let y = "pageY" in evt ? Math.round(evt.pageY) : ("clientY" in evt ? Math.round(evt["clientY"] + d.scrollTop) : null);
     // In case of iframe, we adjust (x,y) to be relative to top parent's origin
     if (frame) {
-        const distance = offset(frame);
+        let distance = offset(frame);
         x = x ? x + Math.round(distance.x) : x;
         y = y ? y + Math.round(distance.y) : y;
     }
 
     // Check for null values before processing this event
-    if (x !== null && y !== null) {
-        handler({ time: time(evt), event, data: { target: target(evt), x, y } });
-    }
+    if (x !== null && y !== null) { handler({ time: time(evt), event, data: { target: target(evt), x, y } }); }
 }
 
 function touch(event: Event, root: Node, evt: TouchEvent): void {
     touch.dn = FunctionNames.PointerTouch;
-    const frame = iframe(root);
-    const d = frame ? frame.contentDocument.documentElement : document.documentElement;
-    const touches = evt.changedTouches;
+    let frame = iframe(root);
+    let d = frame ? frame.contentDocument.documentElement : document.documentElement;
+    let touches = evt.changedTouches;
 
-    const t = time(evt);
+    let t = time(evt);
     if (touches) {
         for (let i = 0; i < touches.length; i++) {
-            const entry = touches[i];
-            let x = "clientX" in entry ? Math.round(entry.clientX + d.scrollLeft) : null;
-            let y = "clientY" in entry ? Math.round(entry.clientY + d.scrollTop) : null;
+            let entry = touches[i];
+            let x = "clientX" in entry ? Math.round(entry["clientX"] + d.scrollLeft) : null;
+            let y = "clientY" in entry ? Math.round(entry["clientY"] + d.scrollTop) : null;
             x = x && frame ? x + Math.round(frame.offsetLeft) : x;
             y = y && frame ? y + Math.round(frame.offsetTop) : y;
 
             // We cannot rely on identifier to determine primary touch as its value doesn't always start with 0.
             // Safari/Webkit uses the address of the UITouch object as the identifier value for each touch point.
-            const id = "identifier" in entry ? entry.identifier : undefined;
+            const id = "identifier" in entry ? entry["identifier"] : undefined;
 
-            switch (event) {
+            switch(event) {
                 case Event.TouchStart:
                     if (activeTouchPointIds.size === 0) {
                         // Track presence of primary touch separately to handle scenarios when same id is repeated
-                        hasPrimaryTouch = true;
+                        hasPrimaryTouch = true;  
                         primaryTouchId = id;
                     }
                     activeTouchPointIds.add(id);
@@ -87,15 +85,11 @@ function touch(event: Event, root: Node, evt: TouchEvent): void {
             const isPrimary = hasPrimaryTouch && primaryTouchId === id;
 
             // Check for null values before processing this event
-            if (x !== null && y !== null) {
-                handler({ time: t, event, data: { target: target(evt), x, y, id, isPrimary } });
-            }
+            if (x !== null && y !== null) { handler({ time: t, event, data: { target: target(evt), x, y, id, isPrimary } }); }
 
             // Reset primary touch point id once touch event ends
             if (event === Event.TouchCancel || event === Event.TouchEnd) {
-                if (primaryTouchId === id) {
-                    hasPrimaryTouch = false;
-                }
+                if (primaryTouchId === id) { hasPrimaryTouch = false; }
             }
         }
     }
@@ -105,18 +99,15 @@ function handler(current: PointerState): void {
     switch (current.event) {
         case Event.MouseMove:
         case Event.MouseWheel:
-        case Event.TouchMove: {
-            const length = state.length;
-            const last = length > 1 ? state[length - 2] : null;
-            if (last && similar(last, current)) {
-                state.pop();
-            }
+        case Event.TouchMove:
+            let length = state.length;
+            let last = length > 1 ? state[length - 2] : null;
+            if (last && similar(last, current)) { state.pop(); }
             state.push(current);
 
             clearTimeout(timeout);
             timeout = setTimeout(process, Setting.LookAhead, current.event);
             break;
-        }
         default:
             state.push(current);
             process(current.event);
@@ -145,7 +136,5 @@ function similar(last: PointerState, current: PointerState): boolean {
 export function stop(): void {
     clearTimeout(timeout);
     // Send out any pending pointer events in the pipeline
-    if (state.length > 0) {
-        process(state[state.length - 1].event);
-    }
+    if (state.length > 0) { process(state[state.length - 1].event); }
 }

package/src/interaction/resize.ts

@@ -1,10 +1,10 @@
 import { Event } from "@clarity-types/data";
-import { type ResizeData, Setting } from "@clarity-types/interaction";
+import { ResizeData, Setting } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
-import { bind } from "@src/core/event";
-import { schedule } from "@src/core/task";
 import { clearTimeout, setTimeout } from "@src/core/timeout";
+import { bind } from "@src/core/event";
 import encode from "./encode";
+import { schedule } from "@src/core/task";
 
 export let data: ResizeData;
 let timeout: number = null;
@@ -18,7 +18,7 @@ export function start(): void {
 
 function recompute(): void {
     recompute.dn = FunctionNames.ResizeRecompute;
-    const de = document.documentElement;
+    let de = document.documentElement;
     // window.innerWidth includes width of the scrollbar and is not a true representation of the viewport width.
     // Therefore, when possible, use documentElement's clientWidth property.
     data = {
@@ -45,4 +45,4 @@ export function reset(): void {
 
 export function stop(): void {
     reset();
-}
+}

package/src/interaction/scroll.ts

@@ -1,5 +1,5 @@
 import { Constant, Dimension, Event } from "@clarity-types/data";
-import { type ScrollState, Setting } from "@clarity-types/interaction";
+import { ScrollState, Setting } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import { bind } from "@src/core/event";
 import { schedule } from "@src/core/task";
@@ -8,7 +8,7 @@ import { clearTimeout, setTimeout } from "@src/core/timeout";
 import throttle from "@src/core/throttle";
 import * as dimension from "@src/data/dimension";
 import { iframe } from "@src/layout/dom";
-import { metadata, target } from "@src/layout/target";
+import { target, metadata } from "@src/layout/target";
 import encode from "./encode";
 
 export let state: ScrollState[] = [];
@@ -35,7 +35,7 @@ function recompute(event: UIEvent = null): void {
 
     // If the target is a Document node, then identify corresponding documentElement and window for this document
     if (element && element.nodeType === Node.DOCUMENT_NODE) {
-        const frame = iframe(element);
+        let frame = iframe(element);
         w = frame ? frame.contentWindow : w;
         element = de = (element as Document).documentElement;
     }
@@ -43,8 +43,8 @@ function recompute(event: UIEvent = null): void {
     // Edge doesn't support scrollTop position on document.documentElement.
     // For cross browser compatibility, looking up pageYOffset on window if the scroll is on document.
     // And, if for some reason that is not available, fall back to looking up scrollTop on document.documentElement.
-    const x = element === de && "pageXOffset" in w ? Math.round(w.pageXOffset) : Math.round((element as HTMLElement).scrollLeft);
-    const y = element === de && "pageYOffset" in w ? Math.round(w.pageYOffset) : Math.round((element as HTMLElement).scrollTop);
+    let x = element === de && "pageXOffset" in w ? Math.round(w.pageXOffset) : Math.round((element as HTMLElement).scrollLeft);
+    let y = element === de && "pageYOffset" in w ? Math.round(w.pageYOffset) : Math.round((element as HTMLElement).scrollTop);
     const width = window.innerWidth;
     const height = window.innerHeight;
     const xPosition = width / 3;
@@ -54,20 +54,18 @@ function recompute(event: UIEvent = null): void {
     const top = getPositionNode(xPosition, startYPosition);
     const bottom = getPositionNode(xPosition, endYPosition);
 
-    const current: ScrollState = { time: time(event), event: Event.Scroll, data: { target: element, x, y, top, bottom } };
+    let current: ScrollState = { time: time(event), event: Event.Scroll, data: {target: element, x, y, top, bottom} };
 
     // We don't send any scroll events if this is the first event and the current position is top (0,0)
-    if ((event === null && x === 0 && y === 0) || x === null || y === null) {
+    if ((event === null && x === 0 && y === 0) || (x === null || y === null)) {
         initialTop = top;
         initialBottom = bottom;
         return;
     }
 
-    const length = state.length;
-    const last = length > 1 ? state[length - 2] : null;
-    if (last && similar(last, current)) {
-        state.pop();
-    }
+    let length = state.length;
+    let last = length > 1 ? state[length - 2] : null;
+    if (last && similar(last, current)) { state.pop(); }
     state.push(current);
 
     clearTimeout(timeout);
@@ -79,10 +77,9 @@ const throttledRecompute = throttle(recompute, Setting.Throttle);
 function getPositionNode(x: number, y: number): Node {
     let node: Node;
     if ("caretPositionFromPoint" in document) {
-        // biome-ignore lint/suspicious/noExplicitAny: caretPositionFromPoint is not defined on all browsers, makes typescript unhappy
         node = (document as any).caretPositionFromPoint(x, y)?.offsetNode;
     } else if ("caretRangeFromPoint" in document) {
-        node = (document as Document).caretRangeFromPoint(x, y)?.startContainer;
+        node = (document as any).caretRangeFromPoint(x, y)?.startContainer;
     }
     if (!node) {
         node = document.elementFromPoint(x, y) as Node;

package/src/interaction/selection.ts

@@ -1,5 +1,5 @@
 import { Event } from "@clarity-types/data";
-import { type SelectionData, Setting } from "@clarity-types/interaction";
+import { SelectionData, Setting } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import { bind } from "@src/core/event";
 import { schedule } from "@src/core/task";
@@ -21,25 +21,21 @@ export function observe(root: Node): void {
 
 function recompute(root: Node): void {
     recompute.dn = FunctionNames.SelectionRecompute;
-    const doc = root.nodeType === Node.DOCUMENT_NODE ? (root as Document) : document;
-    const current = doc.getSelection();
+    let doc = root.nodeType === Node.DOCUMENT_NODE ? root as Document : document;
+    let current = doc.getSelection();
 
     // Bail out if we don't have a valid selection
-    if (current === null) {
-        return;
-    }
+    if (current === null) { return; }
 
     // Bail out if we got a valid selection but not valid nodes
     // In Edge, selectionchange gets fired even on interactions like right clicks and
     // can result in null anchorNode and focusNode if there was no previous selection on page
     // Also, ignore any selections that start and end at the exact same point
-    if (
-        (current.anchorNode === null && current.focusNode === null) ||
-        (current.anchorNode === current.focusNode && current.anchorOffset === current.focusOffset)
-    ) {
+    if ((current.anchorNode === null && current.focusNode === null) ||
+        (current.anchorNode === current.focusNode && current.anchorOffset === current.focusOffset)) {
         return;
     }
-    const startNode = data.start ? data.start : null;
+    let startNode = data.start ? data.start : null;
     if (previous !== null && data.start !== null && startNode !== current.anchorNode) {
         clearTimeout(timeout);
         process(Event.Selection);
@@ -49,7 +45,7 @@ function recompute(root: Node): void {
         start: current.anchorNode,
         startOffset: current.anchorOffset,
         end: current.focusNode,
-        endOffset: current.focusOffset,
+        endOffset: current.focusOffset
     };
     previous = current;
 

package/src/interaction/submit.ts

@@ -1,11 +1,11 @@
 import { Event } from "@clarity-types/data";
-import type { SubmitState } from "@clarity-types/interaction";
+import { SubmitState } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import { bind } from "@src/core/event";
 import { schedule } from "@src/core/task";
 import { time } from "@src/core/time";
-import { target } from "@src/layout/target";
 import encode from "./encode";
+import { target } from "@src/layout/target";
 
 export let state: SubmitState[] = [];
 

package/src/interaction/timeline.ts

@@ -1,5 +1,5 @@
 import { BooleanFlag, Event } from "@clarity-types/data";
-import { BrowsingContext, Setting, type TimelineState } from "@clarity-types/interaction";
+import { BrowsingContext, Setting, TimelineState } from "@clarity-types/interaction";
 import * as baseline from "@src/data/baseline";
 import * as envelope from "@src/data/envelope";
 import encode from "@src/interaction/encode";
@@ -16,15 +16,13 @@ export function reset(): void {
     updates = [];
 }
 
-export function track(
-    time: number,
+export function track(time: number,
     event: Event,
     hash: string,
     x: number,
     y: number,
     reaction: number = BooleanFlag.True,
-    context: number = BrowsingContext.Self,
-): void {
+    context: number = BrowsingContext.Self): void {
     state.push({
         time,
         event: Event.Timeline,
@@ -34,8 +32,8 @@ export function track(
             x,
             y,
             reaction,
-            context,
-        },
+            context
+        }
     });
 
     // Since timeline only keeps the data for configured time, we still want to continue tracking these values
@@ -47,14 +45,12 @@ export function track(
 export function compute(): void {
     const temp = [];
     updates = [];
-    const max = envelope.data.start + envelope.data.duration;
-    const min = Math.max(max - Setting.TimelineSpan, 0);
+    let max = envelope.data.start + envelope.data.duration;
+    let min = Math.max(max - Setting.TimelineSpan, 0);
 
-    for (const s of state) {
+    for (let s of state) {
         if (s.time >= min) {
-            if (s.time <= max) {
-                updates.push(s);
-            }
+            if (s.time <= max) { updates.push(s); }
             temp.push(s);
         }
     }

package/src/interaction/unload.ts

@@ -1,5 +1,5 @@
 import { BooleanFlag, Event } from "@clarity-types/data";
-import type { UnloadData } from "@clarity-types/interaction";
+import { UnloadData } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import * as clarity from "@src/clarity";
 import { bind } from "@src/core/event";

package/src/interaction/visibility.ts

@@ -1,5 +1,5 @@
 import { Event } from "@clarity-types/data";
-import type { VisibilityData } from "@clarity-types/interaction";
+import { VisibilityData } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import { bind } from "@src/core/event";
 import { time } from "@src/core/time";
@@ -24,4 +24,4 @@ export function reset(): void {
 
 export function stop(): void {
     reset();
-}
+}