clarity-js 0.8.10-beta → 0.8.10

package/src/data/metric.ts

@@ -1,4 +1,4 @@
-import { Event, Metric, MetricData } from "@clarity-types/data";
+import { Event, Metric, type MetricData } from "@clarity-types/data";
 import encode from "./encode";
 
 export let data: MetricData = null;
@@ -16,16 +16,24 @@ export function stop(): void {
 }
 
 export function count(metric: Metric): void {
-    if (!(metric in data)) { data[metric] = 0; }
-    if (!(metric in updates)) { updates[metric] = 0; }
+    if (!(metric in data)) {
+        data[metric] = 0;
+    }
+    if (!(metric in updates)) {
+        updates[metric] = 0;
+    }
     data[metric]++;
     updates[metric]++;
 }
 
 export function sum(metric: Metric, value: number): void {
-    if (value !== null) { 
-        if (!(metric in data)) { data[metric] = 0; }
-        if (!(metric in updates)) { updates[metric] = 0; }
+    if (value !== null) {
+        if (!(metric in data)) {
+            data[metric] = 0;
+        }
+        if (!(metric in updates)) {
+            updates[metric] = 0;
+        }
         data[metric] += value;
         updates[metric] += value;
     }
@@ -33,8 +41,10 @@ export function sum(metric: Metric, value: number): void {
 
 export function max(metric: Metric, value: number): void {
     // Ensure that we do not process null or NaN values
-    if (value !== null && isNaN(value) === false) { 
-        if (!(metric in data)) { data[metric] = 0; }
+    if (value !== null && Number.isNaN(value) === false) {
+        if (!(metric in data)) {
+            data[metric] = 0;
+        }
         if (value > data[metric] || data[metric] === 0) {
             updates[metric] = value;
             data[metric] = value;

package/src/data/ping.ts

@@ -1,4 +1,4 @@
-import { Event, PingData, Setting } from "@clarity-types/data";
+import { Event, type PingData, Setting } from "@clarity-types/data";
 import { suspend } from "@src/core";
 import { time } from "@src/core/time";
 import { clearTimeout, setTimeout } from "@src/core/timeout";
@@ -15,18 +15,22 @@ export function start(): void {
 }
 
 export function reset(): void {
-    if (timeout) { clearTimeout(timeout); }
+    if (timeout) {
+        clearTimeout(timeout);
+    }
     timeout = setTimeout(ping, interval);
     last = time();
 }
 
 function ping(): void {
-    let now = time();
+    const now = time();
     data = { gap: now - last };
     encode(Event.Ping);
     if (data.gap < Setting.PingTimeout) {
         timeout = setTimeout(ping, interval);
-    } else { suspend(); }
+    } else {
+        suspend();
+    }
 }
 
 export function stop(): void {

package/src/data/signal.ts

@@ -1,30 +1,30 @@
-import { ClaritySignal, SignalCallback } from '@clarity-types/data';
+import type { ClaritySignal, SignalCallback } from "@clarity-types/data";
 
 export let signalCallback: SignalCallback = null;
 
 export function signal(cb: SignalCallback): void {
-  signalCallback = cb;
+    signalCallback = cb;
 }
 
 function parseSignals(signalsPayload: string): ClaritySignal[] {
-  try{
-    const parsedSignals: ClaritySignal[] = JSON.parse(signalsPayload);
-    return parsedSignals;
-  }catch{
-    return []
-  }
+    try {
+        const parsedSignals: ClaritySignal[] = JSON.parse(signalsPayload);
+        return parsedSignals;
+    } catch {
+        return [];
+    }
 }
 
 export function signalsEvent(signalsPayload: string) {
-  try {
-    if (!signalCallback) {
-      return;
+    try {
+        if (!signalCallback) {
+            return;
+        }
+        const signals = parseSignals(signalsPayload);
+        for (const signal of signals) {
+            signalCallback(signal);
+        }
+    } catch {
+        //do nothing
     }
-    const signals = parseSignals(signalsPayload);
-    signals.forEach((signal) => {
-      signalCallback(signal);
-    });
-  } catch {
-    //do nothing
-  }
 }

package/src/data/summary.ts

@@ -1,4 +1,4 @@
-import { Event, SummaryData, Setting } from "@clarity-types/data";
+import { Event, Setting, type SummaryData } from "@clarity-types/data";
 import encode from "./encode";
 
 export let data: SummaryData = null;
@@ -15,13 +15,15 @@ export function track(event: Event, time: number): void {
     if (!(event in data)) {
         data[event] = [[time, 0]];
     } else {
-        let e = data[event];
-        let last = e[e.length - 1];
+        const e = data[event];
+        const last = e[e.length - 1];
         // Add a new entry only if the new event occurs after configured interval
         // Otherwise, extend the duration of the previous entry
         if (time - last[0] > Setting.SummaryInterval) {
             data[event].push([time, 0]);
-        } else { last[1] = time - last[0]; }
+        } else {
+            last[1] = time - last[0];
+        }
     }
 }
 

package/src/data/token.ts

@@ -1,4 +1,4 @@
-import {Constant, Token} from "@clarity-types/data";
+import type { Token } from "@clarity-types/data";
 
 // Following code takes an array of tokens and transforms it to optimize for repeating tokens and make it efficient to send over the wire
 // The way it works is that it iterate over all tokens and checks if the current token was already seen in the tokens array so far
@@ -6,18 +6,20 @@ import {Constant, Token} from "@clarity-types/data";
 // E.g. If tokens array is: ["hello", "world", "coding", "language", "world", "language", "example"]
 // Then the resulting tokens array after following code execution would be: ["hello", "world", "coding", "language", [1, 3], "example"]
 // Where [1,3] points to tokens[1] => "world" and tokens[3] => "language"
-export default function(tokens: Token[]): Token[] {
-    let output: Token[] = [];
-    let lookup: {[key: string]: number} = {};
+export default function (tokens: Token[]): Token[] {
+    const output: Token[] = [];
+    const lookup: { [key: string]: number } = {};
     let pointer = 0;
     let reference = null;
     for (let i = 0; i < tokens.length; i++) {
         // Only optimize for string values
-        if (typeof tokens[i] === Constant.String) {
-            let token = tokens[i] as string;
-            let index = lookup[token] || -1;
+        if (typeof tokens[i] === "string") {
+            const token = tokens[i] as string;
+            const index = lookup[token] || -1;
             if (index >= 0) {
-                if (reference) { reference.push(index); } else {
+                if (reference) {
+                    reference.push(index);
+                } else {
                     reference = [index];
                     output.push(reference);
                     pointer++;

package/src/data/upgrade.ts

@@ -1,4 +1,4 @@
-import { Constant, Event, UpgradeData } from "@clarity-types/data";
+import { Constant, Event, type UpgradeData } from "@clarity-types/data";
 import * as core from "@src/core";
 import config from "@src/core/config";
 import encode from "@src/data/encode";
@@ -9,7 +9,9 @@ import * as style from "@src/layout/style";
 export let data: UpgradeData = null;
 
 export function start(): void {
-    if (!config.lean && config.upgrade) { config.upgrade(Constant.Config); }
+    if (!config.lean && config.upgrade) {
+        config.upgrade(Constant.Config);
+    }
     data = null;
 }
 
@@ -28,7 +30,9 @@ export function upgrade(key: string): void {
         metadata.save();
 
         // Callback upgrade handler, if configured
-        if (config.upgrade) { config.upgrade(key); }
+        if (config.upgrade) {
+            config.upgrade(key);
+        }
 
         encode(Event.Upgrade);
 

package/src/data/upload.ts

@@ -1,34 +1,48 @@
-import { UploadCallback } from "@clarity-types/core";
-import { BooleanFlag, Check, Code, Constant, EncodedPayload, Event, Metric, Setting, Severity, Token, Transit, UploadData, XMLReadyState } from "@clarity-types/data";
+import type { UploadCallback } from "@clarity-types/core";
+import {
+    BooleanFlag,
+    Check,
+    Code,
+    Constant,
+    type EncodedPayload,
+    Event,
+    Metric,
+    Setting,
+    Severity,
+    type Token,
+    type Transit,
+    type UploadData,
+    XMLReadyState,
+} from "@clarity-types/data";
 import * as clarity from "@src/clarity";
 import config from "@src/core/config";
 import measure from "@src/core/measure";
+import { report } from "@src/core/report";
 import { time } from "@src/core/time";
 import { clearTimeout, setTimeout } from "@src/core/timeout";
 import compress from "@src/data/compress";
 import encode from "@src/data/encode";
 import * as envelope from "@src/data/envelope";
+import * as extract from "@src/data/extract";
 import * as data from "@src/data/index";
 import * as limit from "@src/data/limit";
 import * as metadata from "@src/data/metadata";
 import * as metric from "@src/data/metric";
 import * as ping from "@src/data/ping";
+import { signalsEvent } from "@src/data/signal";
 import * as internal from "@src/diagnostic/internal";
 import * as timeline from "@src/interaction/timeline";
 import * as region from "@src/layout/region";
-import * as extract from "@src/data/extract";
 import * as style from "@src/layout/style";
-import { report } from "@src/core/report";
-import { signalsEvent } from "@src/data/signal";
 
-let discoverBytes: number = 0;
-let playbackBytes: number = 0;
+let discoverBytes = 0;
+let playbackBytes = 0;
 let playback: string[];
 let analysis: string[];
 let timeout: number = null;
 let transit: Transit;
 let active: boolean;
-let queuedTime: number = 0;
+let queuedTime = 0;
 let leanLimit = false;
 export let track: UploadData;
 
@@ -44,11 +58,11 @@ export function start(): void {
     track = null;
 }
 
-export function queue(tokens: Token[], transmit: boolean = true): void {
+export function queue(tokens: Token[], transmit = true): void {
     if (active) {
-        let now = time();
-        let type = tokens.length > 1 ? tokens[1] : null;
-        let event = JSON.stringify(tokens);
+        const now = time();
+        const type = tokens.length > 1 ? tokens[1] : null;
+        const event = JSON.stringify(tokens);
 
         if (!config.lean) {
             leanLimit = false;
@@ -58,15 +72,20 @@ export function queue(tokens: Token[], transmit: boolean = true): void {
         }
 
         switch (type) {
+            // biome-ignore lint/suspicious/noFallthroughSwitchClause: we want discover bytes to also count as playback bytes
             case Event.Discover:
-                if (leanLimit) { break; }
+                if (leanLimit) {
+                    break;
+                }
                 discoverBytes += event.length;
             case Event.Box:
             case Event.Mutation:
             case Event.Snapshot:
             case Event.StyleSheetAdoption:
             case Event.StyleSheetUpdate:
-                if (leanLimit) { break; }
+                if (leanLimit) {
+                    break;
+                }
                 playbackBytes += event.length;
                 playback.push(event);
                 break;
@@ -81,8 +100,8 @@ export function queue(tokens: Token[], transmit: boolean = true): void {
         // Following two checks are precautionary and act as a fail safe mechanism to get out of unexpected situations.
         // Check 1: If for any reason the upload hasn't happened after waiting for 2x the config.delay time,
         // reset the timer. This allows Clarity to attempt an upload again.
-        let gap = delay();
-        if (now - queuedTime > (gap * 2)) {
+        const gap = delay();
+        if (now - queuedTime > gap * 2) {
             clearTimeout(timeout);
             timeout = null;
         }
@@ -91,7 +110,9 @@ export function queue(tokens: Token[], transmit: boolean = true): void {
         // However, in certain scenarios - like metric calculation - which are triggered as part of an existing upload
         // We enrich the data going out with the existing upload. In these cases, call to upload comes with 'transmit' set to false.
         if (transmit && timeout === null) {
-            if (type !== Event.Ping) { ping.reset(); }
+            if (type !== Event.Ping) {
+                ping.reset();
+            }
             timeout = setTimeout(upload, gap);
             queuedTime = now;
             limit.check(playbackBytes);
@@ -113,14 +134,17 @@ export function stop(): void {
     active = false;
 }
 
-async function upload(final: boolean = false): Promise<void> {
+async function upload(final = false): Promise<void> {
     timeout = null;
 
     // Check if we can send playback bytes over the wire or not
     // For better instrumentation coverage, we send playback bytes from second sequence onwards
     // And, we only send playback metric when we are able to send the playback bytes back to server
-    let sendPlaybackBytes = config.lean === false && playbackBytes > 0 && (playbackBytes < Setting.MaxFirstPayloadBytes || envelope.data.sequence > 0);
-    if (sendPlaybackBytes) { metric.max(Metric.Playback, BooleanFlag.True); }
+    const sendPlaybackBytes =
+        config.lean === false && playbackBytes > 0 && (playbackBytes < Setting.MaxFirstPayloadBytes || envelope.data.sequence > 0);
+    if (sendPlaybackBytes) {
+        metric.max(Metric.Playback, BooleanFlag.True);
+    }
 
     // CAUTION: Ensure "transmit" is set to false in the queue function for following events
     // Otherwise you run a risk of infinite loop.
@@ -133,18 +157,18 @@ async function upload(final: boolean = false): Promise<void> {
     // In real world tests, we noticed that certain third party scripts (e.g. https://www.npmjs.com/package/raven-js)
     // could inject function arguments for internal tracking (likely stack traces for script errors).
     // For these edge cases, we want to ensure that an injected object (e.g. {"key": "value"}) isn't mistaken to be true.
-    let last = final === true;
-    let e = JSON.stringify(envelope.envelope(last));
-    let a = `[${analysis.join()}]`;
+    const last = final === true;
+    const e = JSON.stringify(envelope.envelope(last));
+    const a = `[${analysis.join()}]`;
 
-    let p = sendPlaybackBytes ? `[${playback.join()}]` : Constant.Empty;
-    let encoded: EncodedPayload = {e, a, p};
+    const p = sendPlaybackBytes ? `[${playback.join()}]` : Constant.Empty;
+    const encoded: EncodedPayload = { e, a, p };
 
     // Get the payload ready for sending over the wire
     // We also attempt to compress the payload if it is not the last payload and the browser supports it
     // In all other cases, we continue to send back string value
-    let payload = stringify(encoded);
-    let zipped = last ? null : await compress(payload)
+    const payload = stringify(encoded);
+    const zipped = last ? null : await compress(payload);
     metric.sum(Metric.TotalBytes, zipped ? zipped.length : payload.length);
     send(payload, zipped, envelope.data.sequence, last);
 
@@ -162,9 +186,9 @@ function stringify(encoded: EncodedPayload): string {
     return encoded.p.length > 0 ? `{"e":${encoded.e},"a":${encoded.a},"p":${encoded.p}}` : `{"e":${encoded.e},"a":${encoded.a}}`;
 }
 
-function send(payload: string, zipped: Uint8Array, sequence: number, beacon: boolean = false): void {
+function send(payload: string, zipped: Uint8Array, sequence: number, beacon = false): void {
     // Upload data if a valid URL is defined in the config
-    if (typeof config.upload === Constant.String) {
+    if (typeof config.upload === "string") {
         const url = config.upload as string;
         let dispatched = false;
 
@@ -176,8 +200,12 @@ function send(payload: string, zipped: Uint8Array, sequence: number, beacon: boo
             try {
                 // Navigator needs to be bound to sendBeacon before it is used to avoid errors in some browsers
                 dispatched = navigator.sendBeacon.bind(navigator)(url, payload);
-                if (dispatched) { done(sequence); }
-            } catch { /* do nothing - and we will automatically fallback to XHR below */ }
+                if (dispatched) {
+                    done(sequence);
+                }
+            } catch {
+                /* do nothing - and we will automatically fallback to XHR below */
+            }
         }
 
         // Before initiating XHR upload, we check if the data has already been uploaded using sendBeacon
@@ -188,12 +216,22 @@ function send(payload: string, zipped: Uint8Array, sequence: number, beacon: boo
         if (dispatched === false) {
             // While tracking payload for retry, we only track string value of the payload to err on the safe side
             // Not all browsers support compression API and the support for it in supported browsers is still experimental
-            if (sequence in transit) { transit[sequence].attempts++; } else { transit[sequence] = { data: payload, attempts: 1 }; }
-            let xhr = new XMLHttpRequest();
+            if (sequence in transit) {
+                transit[sequence].attempts++;
+            } else {
+                transit[sequence] = { data: payload, attempts: 1 };
+            }
+            const xhr = new XMLHttpRequest();
             xhr.open("POST", url, true);
             xhr.timeout = Setting.UploadTimeout;
-            xhr.ontimeout = () => { report(new Error(`${Constant.Timeout} : ${url}`)) };
-            if (sequence !== null) { xhr.onreadystatechange = (): void => { measure(check)(xhr, sequence); }; }
+            xhr.ontimeout = () => {
+                report(new Error(`${Constant.Timeout} : ${url}`));
+            };
+            if (sequence !== null) {
+                xhr.onreadystatechange = (): void => {
+                    measure(check)(xhr, sequence);
+                };
+            }
             xhr.withCredentials = true;
             if (zipped) {
                 // If we do have valid compressed array, send it with appropriate HTTP headers so server can decode it appropriately
@@ -212,7 +250,7 @@ function send(payload: string, zipped: Uint8Array, sequence: number, beacon: boo
 }
 
 function check(xhr: XMLHttpRequest, sequence: number): void {
-    var transitData = transit[sequence];
+    const transitData = transit[sequence];
     if (xhr && xhr.readyState === XMLReadyState.Done && transitData) {
         // Attempt send payload again (as configured in settings) if we do not receive a success (2XX) response code back from the server
         if ((xhr.status < 200 || xhr.status > 208) && transitData.attempts <= Setting.RetryLimit) {
@@ -226,7 +264,9 @@ function check(xhr: XMLHttpRequest, sequence: number): void {
                 //    1: Browsers block upload because of content security policy violation
                 //    2: Safari will terminate pending XHR requests with status code 0 if the user navigates away from the page
                 // In any case, we switch the upload URL to fallback configuration (if available) before re-trying one more time
-                if (xhr.status === 0) { config.upload = config.fallback ? config.fallback : config.upload; }
+                if (xhr.status === 0) {
+                    config.upload = config.fallback ? config.fallback : config.upload;
+                }
                 // In all other cases, re-attempt sending the same data
                 // For retry we always fallback to string payload, even though we may have attempted
                 // sending zipped payload earlier
@@ -235,9 +275,13 @@ function check(xhr: XMLHttpRequest, sequence: number): void {
         } else {
             track = { sequence, attempts: transitData.attempts, status: xhr.status };
             // Send back an event only if we were not successful in our first attempt
-            if (transitData.attempts > 1) { encode(Event.Upload); }
+            if (transitData.attempts > 1) {
+                encode(Event.Upload);
+            }
             // Handle response if it was a 200 response with a valid body
-            if (xhr.status === 200 && xhr.responseText) { response(xhr.responseText); }
+            if (xhr.status === 200 && xhr.responseText) {
+                response(xhr.responseText);
+            }
             // If we exhausted our retries then trigger Clarity's shutdown for this page since the data will be incomplete
             if (xhr.status === 0) {
                 // And, right before we terminate the session, we will attempt one last time to see if we can use
@@ -246,7 +290,9 @@ function check(xhr: XMLHttpRequest, sequence: number): void {
                 limit.trigger(Check.Retry);
             }
             // Signal that this request completed successfully
-            if (xhr.status >= 200 && xhr.status <= 208) { done(sequence); }
+            if (xhr.status >= 200 && xhr.status <= 208) {
+                done(sequence);
+            }
             // Stop tracking this payload now that it's all done
             delete transit[sequence];
         }
@@ -264,15 +310,14 @@ function done(sequence: number): void {
 function delay(): number {
     // Progressively increase delay as we continue to send more payloads from the client to the server
     // If we are not uploading data to a server, and instead invoking UploadCallback, in that case keep returning configured value
-    let gap = config.lean === false && discoverBytes > 0 ? Setting.MinUploadDelay : envelope.data.sequence * config.delay;
-    return typeof config.upload === Constant.String ? Math.max(Math.min(gap, Setting.MaxUploadDelay), Setting.MinUploadDelay) : config.delay;
+    const gap = config.lean === false && discoverBytes > 0 ? Setting.MinUploadDelay : envelope.data.sequence * config.delay;
+    return typeof config.upload === "string" ? Math.max(Math.min(gap, Setting.MaxUploadDelay), Setting.MinUploadDelay) : config.delay;
 }
 
 function response(payload: string): void {
-    let lines = payload && payload.length > 0 ? payload.split("\n") : [];
-    for (var line of lines)
-    {
-        let parts = line && line.length > 0 ? line.split(/ (.*)/) : [Constant.Empty];
+    const lines = payload && payload.length > 0 ? payload.split("\n") : [];
+    for (const line of lines) {
+        const parts = line && line.length > 0 ? line.split(/ (.*)/) : [Constant.Empty];
         switch (parts[0]) {
             case Constant.End:
                 // Clear out session storage and end the session so we can start fresh the next time
@@ -284,13 +329,19 @@ function response(payload: string): void {
                 break;
             case Constant.Action:
                 // Invoke action callback, if configured and has a valid value
-                if (config.action && parts.length > 1) { config.action(parts[1]); }
+                if (config.action && parts.length > 1) {
+                    config.action(parts[1]);
+                }
                 break;
             case Constant.Extract:
-                if (parts.length > 1) { extract.trigger(parts[1]); }
+                if (parts.length > 1) {
+                    extract.trigger(parts[1]);
+                }
                 break;
             case Constant.Signal:
-                if (parts.length > 1) { signalsEvent(parts[1]); }
+                if (parts.length > 1) {
+                    signalsEvent(parts[1]);
+                }
                 break;
         }
     }

package/src/data/variable.ts

@@ -1,4 +1,4 @@
-import { Constant, Event, IdentityData, Setting, VariableData } from "@clarity-types/data";
+import { Constant, Event, type IdentityData, Setting, type VariableData } from "@clarity-types/data";
 import * as core from "@src/core";
 import { scrub } from "@src/core/scrub";
 import encode from "./encode";
@@ -10,23 +10,28 @@ export function start(): void {
 }
 
 export function set(variable: string, value: string | string[]): void {
-    let values = typeof value === Constant.String ? [value as string] : value as string[];
+    const values = typeof value === "string" ? [value as string] : (value as string[]);
     log(variable, values);
 }
 
-export async function identify(userId: string, sessionId: string = null, pageId: string = null, userHint: string = null): Promise<IdentityData> {
-    let output: IdentityData = { userId: await sha256(userId), userHint: userHint || redact(userId) };
+export async function identify(
+    userId: string,
+    sessionId: string = null,
+    pageId: string = null,
+    userHint: string = null,
+): Promise<IdentityData> {
+    const output: IdentityData = { userId: await sha256(userId), userHint: userHint || redact(userId) };
 
     // By default, hash custom userId using SHA256 algorithm on the client to preserve privacy
     log(Constant.UserId, [output.userId]);
-    
+
     // Optional non-identifying name for the user
     // If name is not explicitly provided, we automatically generate a redacted version of the userId
     log(Constant.UserHint, [output.userHint]);
-    log(Constant.UserType, [detect(userId)]);    
+    log(Constant.UserType, [detect(userId)]);
 
     // Log sessionId and pageId if provided
-    if (sessionId) { 
+    if (sessionId) {
         log(Constant.SessionId, [sessionId]);
         output.sessionId = sessionId;
     }
@@ -39,14 +44,12 @@ export async function identify(userId: string, sessionId: string = null, pageId:
 }
 
 function log(variable: string, value: string[]): void {
-    if (core.active() &&
-        variable &&
-        value &&
-        typeof variable === Constant.String &&
-        variable.length < 255) {
-        let validValues = variable in data ? data[variable] : [];
+    if (core.active() && variable && value && typeof variable === "string" && variable.length < 255) {
+        const validValues = variable in data ? data[variable] : [];
         for (let i = 0; i < value.length; i++) {
-            if (typeof value[i] === Constant.String && value[i].length < 255) { validValues.push(value[i]); }
+            if (typeof value[i] === "string" && value[i].length < 255) {
+                validValues.push(value[i]);
+            }
         }
         data[variable] = validValues;
     }
@@ -65,8 +68,9 @@ export function stop(): void {
 }
 
 function redact(input: string): string {
-    return input && input.length >= Setting.WordLength ? 
-        `${input.substring(0,2)}${scrub(input.substring(2), Constant.Asterix, Constant.Asterix)}` : scrub(input, Constant.Asterix, Constant.Asterix);
+    return input && input.length >= Setting.WordLength
+        ? `${input.substring(0, 2)}${scrub(input.substring(2), Constant.Asterix, Constant.Asterix)}`
+        : scrub(input, Constant.Asterix, Constant.Asterix);
 }
 
 async function sha256(input: string): Promise<string> {
@@ -74,11 +78,14 @@ async function sha256(input: string): Promise<string> {
         if (crypto && input) {
             // Reference: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest#converting_a_digest_to_a_hex_string
             const buffer = await crypto.subtle.digest(Constant.SHA256, new TextEncoder().encode(input));
-            return Array.prototype.map.call(new Uint8Array(buffer), (x: any) =>(('00'+x.toString(16)).slice(-2))).join('');
-        } else { return Constant.Empty; }
-    } catch { return Constant.Empty; }
+            return Array.prototype.map.call(new Uint8Array(buffer), (x) => `00${x.toString(16)}`.slice(-2)).join("");
+        }
+        return Constant.Empty;
+    } catch {
+        return Constant.Empty;
+    }
 }
 
 function detect(input: string): string {
     return input && input.indexOf(Constant.At) > 0 ? Constant.Email : Constant.String;
-}
+}

package/src/diagnostic/encode.ts

@@ -1,4 +1,4 @@
-import { Event, Token } from "@clarity-types/data";
+import { Event, type Token } from "@clarity-types/data";
 import * as scrub from "@src/core/scrub";
 import { time } from "@src/core/time";
 import { queue } from "@src/data/upload";
@@ -7,7 +7,7 @@ import * as internal from "@src/diagnostic/internal";
 import * as script from "@src/diagnostic/script";
 
 export default async function (type: Event): Promise<void> {
-    let tokens: Token[] = [time(), type];
+    const tokens: Token[] = [time(), type];
 
     switch (type) {
         case Event.ScriptError:

package/src/diagnostic/fraud.ts

@@ -1,5 +1,5 @@
 import { BooleanFlag, Event, IframeStatus, Metric, Setting } from "@clarity-types/data";
-import { FraudData } from "@clarity-types/diagnostic";
+import type { FraudData } from "@clarity-types/diagnostic";
 import config from "@src/core/config";
 import hash from "@src/core/hash";
 import * as metric from "@src/data/metric";
@@ -13,11 +13,10 @@ export function start(): void {
     metric.max(Metric.Automation, navigator.webdriver ? BooleanFlag.True : BooleanFlag.False);
     try {
         // some sites (unintentionally) overwrite the window.self property, so we also check for the main window object
-        metric.max(Metric.Iframed, window.top == window.self || window.top == window ? IframeStatus.TopFrame : IframeStatus.Iframe);
+        metric.max(Metric.Iframed, window.top === window.self || window.top === window ? IframeStatus.TopFrame : IframeStatus.Iframe);
     } catch (ex) {
         metric.max(Metric.Iframed, IframeStatus.Unknown);
     }
-    
 }
 
 export function check(id: number, target: number, input: string): void {
@@ -34,4 +33,4 @@ export function check(id: number, target: number, input: string): void {
 
 export function stop(): void {
     history = [];
-}
+}