clarity-js 0.8.12 → 0.8.13-beta

package/src/data/metric.ts

@@ -1,4 +1,4 @@
-import { Event, Metric, type MetricData } from "@clarity-types/data";
+import { Event, Metric, MetricData } from "@clarity-types/data";
 import encode from "./encode";
 
 export let data: MetricData = null;
@@ -16,24 +16,16 @@ 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;
     }
@@ -41,10 +33,8 @@ 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 && Number.isNaN(value) === false) {
-        if (!(metric in data)) {
-            data[metric] = 0;
-        }
+    if (value !== null && 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, type PingData, Setting } from "@clarity-types/data";
+import { Event, 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,22 +15,18 @@ 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 {
-    const now = time();
+    let 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 type { ClaritySignal, SignalCallback } from "@clarity-types/data";
+import { 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;
-        }
-        const signals = parseSignals(signalsPayload);
-        for (const signal of signals) {
-            signalCallback(signal);
-        }
-    } catch {
-        //do nothing
+  try {
+    if (!signalCallback) {
+      return;
     }
+    const signals = parseSignals(signalsPayload);
+    signals.forEach((signal) => {
+      signalCallback(signal);
+    });
+  } catch {
+    //do nothing
+  }
 }

package/src/data/summary.ts

@@ -1,4 +1,4 @@
-import { Event, Setting, type SummaryData } from "@clarity-types/data";
+import { Event, SummaryData, Setting } from "@clarity-types/data";
 import encode from "./encode";
 
 export let data: SummaryData = null;
@@ -15,15 +15,13 @@ export function track(event: Event, time: number): void {
     if (!(event in data)) {
         data[event] = [[time, 0]];
     } else {
-        const e = data[event];
-        const last = e[e.length - 1];
+        let e = data[event];
+        let 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 type { Token } from "@clarity-types/data";
+import {Constant, 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,20 +6,18 @@ import type { 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[] {
-    const output: Token[] = [];
-    const lookup: { [key: string]: number } = {};
+export default function(tokens: Token[]): Token[] {
+    let output: Token[] = [];
+    let 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] === "string") {
-            const token = tokens[i] as string;
-            const index = lookup[token] || -1;
+        if (typeof tokens[i] === Constant.String) {
+            let token = tokens[i] as string;
+            let 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, type UpgradeData } from "@clarity-types/data";
+import { Constant, Event, UpgradeData } from "@clarity-types/data";
 import * as core from "@src/core";
 import config from "@src/core/config";
 import encode from "@src/data/encode";
@@ -9,9 +9,7 @@ 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;
 }
 
@@ -30,9 +28,7 @@ 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,48 +1,34 @@
-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 { UploadCallback } from "@clarity-types/core";
+import { BooleanFlag, Check, Code, Constant, EncodedPayload, Event, Metric, Setting, Severity, Token, Transit, 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 = 0;
-let playbackBytes = 0;
+let discoverBytes: number = 0;
+let playbackBytes: number = 0;
 let playback: string[];
 let analysis: string[];
 let timeout: number = null;
 let transit: Transit;
 let active: boolean;
-let queuedTime = 0;
+let queuedTime: number = 0;
 let leanLimit = false;
 export let track: UploadData;
 
@@ -58,11 +44,11 @@ export function start(): void {
     track = null;
 }
 
-export function queue(tokens: Token[], transmit = true): void {
+export function queue(tokens: Token[], transmit: boolean = true): void {
     if (active) {
-        const now = time();
-        const type = tokens.length > 1 ? tokens[1] : null;
-        const event = JSON.stringify(tokens);
+        let now = time();
+        let type = tokens.length > 1 ? tokens[1] : null;
+        let event = JSON.stringify(tokens);
 
         if (!config.lean) {
             leanLimit = false;
@@ -72,20 +58,15 @@ export function queue(tokens: Token[], transmit = 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;
@@ -100,8 +81,8 @@ export function queue(tokens: Token[], transmit = 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.
-        const gap = delay();
-        if (now - queuedTime > gap * 2) {
+        let gap = delay();
+        if (now - queuedTime > (gap * 2)) {
             clearTimeout(timeout);
             timeout = null;
         }
@@ -110,9 +91,7 @@ export function queue(tokens: Token[], transmit = 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);
@@ -134,17 +113,14 @@ export function stop(): void {
     active = false;
 }
 
-async function upload(final = false): Promise<void> {
+async function upload(final: boolean = 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
-    const sendPlaybackBytes =
-        config.lean === false && playbackBytes > 0 && (playbackBytes < Setting.MaxFirstPayloadBytes || envelope.data.sequence > 0);
-    if (sendPlaybackBytes) {
-        metric.max(Metric.Playback, BooleanFlag.True);
-    }
+    let 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.
@@ -157,18 +133,18 @@ async function upload(final = 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.
-    const last = final === true;
-    const e = JSON.stringify(envelope.envelope(last));
-    const a = `[${analysis.join()}]`;
+    let last = final === true;
+    let e = JSON.stringify(envelope.envelope(last));
+    let a = `[${analysis.join()}]`;
 
-    const p = sendPlaybackBytes ? `[${playback.join()}]` : Constant.Empty;
-    const encoded: EncodedPayload = { e, a, p };
+    let p = sendPlaybackBytes ? `[${playback.join()}]` : Constant.Empty;
+    let 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
-    const payload = stringify(encoded);
-    const zipped = last ? null : await compress(payload);
+    let payload = stringify(encoded);
+    let zipped = last ? null : await compress(payload)
     metric.sum(Metric.TotalBytes, zipped ? zipped.length : payload.length);
     send(payload, zipped, envelope.data.sequence, last);
 
@@ -186,9 +162,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 = false): void {
+function send(payload: string, zipped: Uint8Array, sequence: number, beacon: boolean = false): void {
     // Upload data if a valid URL is defined in the config
-    if (typeof config.upload === "string") {
+    if (typeof config.upload === Constant.String) {
         const url = config.upload as string;
         let dispatched = false;
 
@@ -200,12 +176,8 @@ function send(payload: string, zipped: Uint8Array, sequence: number, beacon = fa
             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
@@ -216,22 +188,12 @@ function send(payload: string, zipped: Uint8Array, sequence: number, beacon = fa
         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 };
-            }
-            const xhr = new XMLHttpRequest();
+            if (sequence in transit) { transit[sequence].attempts++; } else { transit[sequence] = { data: payload, attempts: 1 }; }
+            let 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
@@ -250,7 +212,7 @@ function send(payload: string, zipped: Uint8Array, sequence: number, beacon = fa
 }
 
 function check(xhr: XMLHttpRequest, sequence: number): void {
-    const transitData = transit[sequence];
+    var 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) {
@@ -264,9 +226,7 @@ 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
@@ -275,13 +235,9 @@ 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
@@ -290,9 +246,7 @@ 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];
         }
@@ -310,14 +264,15 @@ 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
-    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;
+    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;
 }
 
 function response(payload: string): void {
-    const lines = payload && payload.length > 0 ? payload.split("\n") : [];
-    for (const line of lines) {
-        const parts = line && line.length > 0 ? line.split(/ (.*)/) : [Constant.Empty];
+    let lines = payload && payload.length > 0 ? payload.split("\n") : [];
+    for (var line of lines)
+    {
+        let 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
@@ -329,19 +284,13 @@ 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, type IdentityData, Setting, type VariableData } from "@clarity-types/data";
+import { Constant, Event, IdentityData, Setting, VariableData } from "@clarity-types/data";
 import * as core from "@src/core";
 import { scrub } from "@src/core/scrub";
 import encode from "./encode";
@@ -10,28 +10,23 @@ export function start(): void {
 }
 
 export function set(variable: string, value: string | string[]): void {
-    const values = typeof value === "string" ? [value as string] : (value as string[]);
+    let values = typeof value === Constant.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> {
-    const 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> {
+    let 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;
     }
@@ -44,12 +39,14 @@ export async function identify(
 }
 
 function log(variable: string, value: string[]): void {
-    if (core.active() && variable && value && typeof variable === "string" && variable.length < 255) {
-        const validValues = variable in data ? data[variable] : [];
+    if (core.active() &&
+        variable &&
+        value &&
+        typeof variable === Constant.String &&
+        variable.length < 255) {
+        let validValues = variable in data ? data[variable] : [];
         for (let i = 0; i < value.length; i++) {
-            if (typeof value[i] === "string" && value[i].length < 255) {
-                validValues.push(value[i]);
-            }
+            if (typeof value[i] === Constant.String && value[i].length < 255) { validValues.push(value[i]); }
         }
         data[variable] = validValues;
     }
@@ -68,9 +65,8 @@ 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> {
@@ -78,14 +74,11 @@ 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) => `00${x.toString(16)}`.slice(-2)).join("");
-        }
-        return Constant.Empty;
-    } catch {
-        return Constant.Empty;
-    }
+            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; }
 }
 
 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, type Token } from "@clarity-types/data";
+import { Event, 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> {
-    const tokens: Token[] = [time(), type];
+    let 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 type { FraudData } from "@clarity-types/diagnostic";
+import { 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,10 +13,11 @@ 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 {
@@ -33,4 +34,4 @@ export function check(id: number, target: number, input: string): void {
 
 export function stop(): void {
     history = [];
-}
+}