@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/src/tools/observable.ts

@@ -1,4 +1,5 @@
 import { queueMicrotask } from './queueMicrotask'
+
 export interface Subscription {
   unsubscribe: () => void
 }
@@ -50,8 +51,12 @@ export function mergeObservables<T>(...observables: Array<Observable<T>>) {
 // eslint-disable-next-line no-restricted-syntax
 export class BufferedObservable<T> extends Observable<T> {
   private buffer: T[] = []
+  private droppedCount = 0
 
-  constructor(private maxBufferSize: number) {
+  constructor(
+    private maxBufferSize: number,
+    private onDrop?: (count: number) => void
+  ) {
     super()
   }
 
@@ -59,6 +64,7 @@ export class BufferedObservable<T> extends Observable<T> {
     this.buffer.push(data)
     if (this.buffer.length > this.maxBufferSize) {
       this.buffer.shift()
+      this.droppedCount++
     }
     super.notify(data)
   }
@@ -97,7 +103,10 @@ export class BufferedObservable<T> extends Observable<T> {
    */
   unbuffer() {
     queueMicrotask(() => {
+      if (this.droppedCount > 0 && this.onDrop) {
+        this.onDrop(this.droppedCount)
+      }
       this.maxBufferSize = this.buffer.length = 0
     })
   }
-}
+}

package/src/tools/queueMicrotask.ts

@@ -1,8 +1,13 @@
-import { monitor } from './monitor'
-import { globalObject } from './globalObject'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 
 export function queueMicrotask(callback: () => void) {
-  const nativeImplementation = globalObject.queueMicrotask?.bind(globalObject)
+  // Intentionally avoid .bind(globalObject): in some environments (e.g. Selenium GeckoDriver's
+  // executeScript), globalThis is not a proper global object, so calling the bound function throws
+  // 'queueMicrotask called on an object that does not implement interface Window'. Calling it as an
+  // unbound method is fine, as the proper global object will be used implicitly.
+  // See https://github.com/mozilla/geckodriver/issues/1798
+  const nativeImplementation = globalObject.queueMicrotask
 
   if (typeof nativeImplementation === 'function') {
     nativeImplementation(monitor(callback))

package/src/tools/readBytesFromStream.ts

@@ -2,17 +2,10 @@ import type { Uint8ArrayBuffer } from './utils/byteUtils'
 import { concatBuffers } from './utils/byteUtils'
 import { noop } from './utils/functionUtils'
 
-interface Options {
-  // TODO(next-major): always collect stream body when `trackEarlyRequests` is removed, as we don't
-  // need to use this function to just wait for the end of the stream without collecting it
-  collectStreamBody?: boolean
-}
-
 /**
  * Read bytes from a ReadableStream until the end of the stream.
- * Returns the bytes if collectStreamBody is true, otherwise returns undefined.
  */
-export async function readBytesFromStream(stream: ReadableStream<Uint8ArrayBuffer>, options: Options) {
+export async function readBytesFromStream(stream: ReadableStream<Uint8ArrayBuffer>) {
   const reader = stream.getReader()
   const chunks: Uint8ArrayBuffer[] = []
 
@@ -22,9 +15,7 @@ export async function readBytesFromStream(stream: ReadableStream<Uint8ArrayBuffe
       break
     }
 
-    if (options.collectStreamBody) {
-      chunks.push(result.value)
-    }
+    chunks.push(result.value)
   }
 
   reader.cancel().catch(
@@ -33,5 +24,5 @@ export async function readBytesFromStream(stream: ReadableStream<Uint8ArrayBuffe
     noop
   )
 
-  return options.collectStreamBody ? concatBuffers(chunks) : undefined
+  return concatBuffers(chunks)
 }

package/src/tools/requestIdleCallback.ts

@@ -1,6 +1,6 @@
+import { dateNow } from '@kubesense/kubesense-js-core/time'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 import { setTimeout, clearTimeout } from './timer'
-import { monitor } from './monitor'
-import { dateNow } from './utils/timeUtils'
 
 // This type is not yet supported in TS 3.8. Imported from the TS source until we upgrade the
 // minimum supported TS version.

package/src/tools/sendToExtension.ts

@@ -1,4 +1,4 @@
-import { globalObject } from './globalObject'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
 
 interface BrowserWindow {
   __kubesenseBrowserSdkExtensionCallback?: (message: unknown) => void

package/src/tools/serialisation/sanitize.ts

@@ -27,7 +27,7 @@ interface SanitizedEvent extends Context {
 
 // The maximum size of a single event is 256KiB. By default, we ensure that user-provided data
 // going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...
-const SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE
+export const SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE
 
 // Symbol for the root element of the JSONPath used for visited objects
 const JSON_PATH_ROOT_ELEMENT = '$'
@@ -58,58 +58,33 @@ export function sanitize(source: unknown, maxCharacterCount = SANITIZE_DEFAULT_M
   const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)
   const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)
 
-  // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object
-  const containerQueue: ContainerElementToProcess[] = []
-  const visitedObjectsWithPath = new WeakMap<object, string>()
-  const sanitizedData = sanitizeProcessor(
-    source as ExtendedContextValue,
-    JSON_PATH_ROOT_ELEMENT,
-    undefined,
-    containerQueue,
-    visitedObjectsWithPath
-  )
-  const serializedSanitizedData = JSON.stringify(sanitizedData)
-  let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0
-
-  if (accumulatedCharacterCount > maxCharacterCount) {
-    warnOverCharacterLimit(maxCharacterCount, 'discarded', source)
-    return undefined
-  }
+  try {
+    // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object
+    const containerQueue: ContainerElementToProcess[] = []
+    const visitedObjectsWithPath = new WeakMap<object, string>()
+    const sanitizedData = sanitizeProcessor(
+      source as ExtendedContextValue,
+      JSON_PATH_ROOT_ELEMENT,
+      undefined,
+      containerQueue,
+      visitedObjectsWithPath
+    )
+    const serializedSanitizedData = JSON.stringify(sanitizedData)
+    let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0
 
-  while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
-    const containerToProcess = containerQueue.shift()!
-    let separatorLength = 0 // 0 for the first element, 1 for subsequent elements
+    if (accumulatedCharacterCount > maxCharacterCount) {
+      warnOverCharacterLimit(maxCharacterCount, 'discarded', source)
+      return undefined
+    }
 
-    // Arrays and Objects have to be handled distinctly to ensure
-    // we do not pick up non-numerical properties from Arrays
-    if (Array.isArray(containerToProcess.source)) {
-      for (let key = 0; key < containerToProcess.source.length; key++) {
-        const targetData = sanitizeProcessor(
-          containerToProcess.source[key],
-          containerToProcess.path,
-          key,
-          containerQueue,
-          visitedObjectsWithPath
-        )
+    while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
+      const containerToProcess = containerQueue.shift()!
+      let separatorLength = 0 // 0 for the first element, 1 for subsequent elements
 
-        if (targetData !== undefined) {
-          accumulatedCharacterCount += JSON.stringify(targetData).length
-        } else {
-          // When an element of an Array (targetData) is undefined, it is serialized as null:
-          // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters
-          accumulatedCharacterCount += 4
-        }
-        accumulatedCharacterCount += separatorLength
-        separatorLength = 1
-        if (accumulatedCharacterCount > maxCharacterCount) {
-          warnOverCharacterLimit(maxCharacterCount, 'truncated', source)
-          break
-        }
-        ;(containerToProcess.target as ContextArray)[key] = targetData
-      }
-    } else {
-      for (const key in containerToProcess.source) {
-        if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {
+      // Arrays and Objects have to be handled distinctly to ensure
+      // we do not pick up non-numerical properties from Arrays
+      if (Array.isArray(containerToProcess.source)) {
+        for (let key = 0; key < containerToProcess.source.length; key++) {
           const targetData = sanitizeProcessor(
             containerToProcess.source[key],
             containerToProcess.path,
@@ -117,28 +92,55 @@ export function sanitize(source: unknown, maxCharacterCount = SANITIZE_DEFAULT_M
             containerQueue,
             visitedObjectsWithPath
           )
-          // When a property of an object has an undefined value, it will be dropped during serialization:
-          // JSON.stringify({a:undefined}) => '{}'
+
           if (targetData !== undefined) {
-            accumulatedCharacterCount +=
-              JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH
-            separatorLength = 1
+            accumulatedCharacterCount += JSON.stringify(targetData).length
+          } else {
+            // When an element of an Array (targetData) is undefined, it is serialized as null:
+            // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters
+            accumulatedCharacterCount += 4
           }
+          accumulatedCharacterCount += separatorLength
+          separatorLength = 1
           if (accumulatedCharacterCount > maxCharacterCount) {
             warnOverCharacterLimit(maxCharacterCount, 'truncated', source)
             break
           }
-          ;(containerToProcess.target as Context)[key] = targetData
+          ;(containerToProcess.target as ContextArray)[key] = targetData
+        }
+      } else {
+        for (const key in containerToProcess.source) {
+          if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {
+            const targetData = sanitizeProcessor(
+              containerToProcess.source[key],
+              containerToProcess.path,
+              key,
+              containerQueue,
+              visitedObjectsWithPath
+            )
+            // When a property of an object has an undefined value, it will be dropped during serialization:
+            // JSON.stringify({a:undefined}) => '{}'
+            if (targetData !== undefined) {
+              accumulatedCharacterCount +=
+                JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH
+              separatorLength = 1
+            }
+            if (accumulatedCharacterCount > maxCharacterCount) {
+              warnOverCharacterLimit(maxCharacterCount, 'truncated', source)
+              break
+            }
+            ;(containerToProcess.target as Context)[key] = targetData
+          }
         }
       }
     }
-  }
 
-  // Rebind detached toJSON functions
-  restoreObjectPrototypeToJson()
-  restoreArrayPrototypeToJson()
-
-  return sanitizedData
+    return sanitizedData
+  } finally {
+    // Rebind detached toJSON functions
+    restoreObjectPrototypeToJson()
+    restoreArrayPrototypeToJson()
+  }
 }
 
 /**
@@ -226,7 +228,7 @@ function sanitizeObjects(value: object): string | SanitizedEvent {
     // Handle all remaining object types in a generic way
     const result = Object.prototype.toString.call(value)
     const match = result.match(/\[object (.*)\]/)
-    if (match && match[1]) {
+    if (match?.[1]) {
       return `[${match[1]}]`
     }
   } catch {
@@ -250,8 +252,13 @@ function sanitizeEvent(event: Event): SanitizedEvent {
  *
  */
 function tryToApplyToJSON(value: ExtendedContextValue) {
+  // Primitive values are sanitized directly and should not use inherited toJSON methods.
+  if ((typeof value !== 'object' || value === null) && typeof value !== 'function') {
+    return value
+  }
+
   const object = value as ObjectWithToJsonMethod
-  if (object && typeof object.toJSON === 'function') {
+  if (typeof object.toJSON === 'function') {
     try {
       return object.toJSON() as ExtendedContextValue
     } catch {

package/src/tools/serialisation/stringify.ts

@@ -0,0 +1,18 @@
+import { jsonStringify } from './jsonStringify'
+import { sanitize } from './sanitize'
+
+export function safeToString(value: unknown): string | undefined {
+  try {
+    return String(value)
+  } catch {
+    // ignore
+  }
+}
+
+export function safeStringify(value: unknown): string | undefined {
+  try {
+    return jsonStringify(sanitize(value))
+  } catch {
+    // ignore
+  }
+}

package/src/tools/stackTrace/computeStackTrace.ts

@@ -4,6 +4,8 @@
  * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js
  */
 
+import { isIndexableObject } from '@kubesense/kubesense-js-core/util'
+
 export interface StackFrame {
   url?: string
   func?: string
@@ -31,7 +33,7 @@ export function computeStackTrace(ex: unknown): StackTrace {
 
   let stackProperty = tryToGetString(ex, 'stack')
   const exString = String(ex)
-  if (stackProperty && stackProperty.startsWith(exString)) {
+  if (stackProperty?.startsWith(exString)) {
     stackProperty = stackProperty.slice(exString.length)
   }
   if (stackProperty) {
@@ -77,8 +79,7 @@ export function computeStackTrace(ex: unknown): StackTrace {
     stack,
   }
 }
-const fileUrl =
-  '((?:file|https?|blob|chrome-extension|electron|native|eval|webpack|snippet|<anonymous>|\\w+\\.|\\/).*?)'
+const fileUrl = '((?:blob|native|eval|<anonymous>|[a-zA-Z][a-zA-Z0-9+.-]*:\\/\\/|\\w+\\.|\\/).*?)'
 const filePosition = '(?::(\\d+))'
 const CHROME_LINE_RE = new RegExp(`^\\s*at (.*?) ?\\(${fileUrl}${filePosition}?${filePosition}?\\)?\\s*$`, 'i')
 
@@ -91,8 +92,8 @@ function parseChromeLine(line: string): StackFrame | undefined {
     return
   }
 
-  const isNative = parts[2] && parts[2].indexOf('native') === 0 // start of line
-  const isEval = parts[2] && parts[2].indexOf('eval') === 0 // start of line
+  const isNative = parts[2]?.indexOf('native') === 0 // start of line
+  const isEval = parts[2]?.indexOf('eval') === 0 // start of line
   const submatch = CHROME_EVAL_RE.exec(parts[2])
 
   if (isEval && submatch) {
@@ -111,7 +112,11 @@ function parseChromeLine(line: string): StackFrame | undefined {
   }
 }
 
-const CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(`^\\s*at ?${fileUrl}${filePosition}?${filePosition}??\\s*$`, 'i')
+const htmlAnonymousPart = '(?:(.*)?(?: @))'
+const CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(
+  `^\\s*at\\s*${htmlAnonymousPart}?\\s*${fileUrl}${filePosition}?${filePosition}??\\s*$`,
+  'i'
+)
 
 function parseChromeAnonymousLine(line: string): StackFrame | undefined {
   const parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line)
@@ -122,10 +127,10 @@ function parseChromeAnonymousLine(line: string): StackFrame | undefined {
 
   return {
     args: [],
-    column: parts[3] ? +parts[3] : undefined,
-    func: UNKNOWN_FUNCTION,
-    line: parts[2] ? +parts[2] : undefined,
-    url: parts[1],
+    column: parts[4] ? +parts[4] : undefined,
+    func: parts[1] || UNKNOWN_FUNCTION,
+    line: parts[3] ? +parts[3] : undefined,
+    url: parts[2],
   }
 }
 
@@ -177,11 +182,7 @@ function parseGeckoLine(line: string): StackFrame | undefined {
 }
 
 function tryToGetString(candidate: unknown, property: string) {
-  if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {
-    return undefined
-  }
-  const value = (candidate as { [k: string]: unknown })[property]
-  return typeof value === 'string' ? value : undefined
+  return isIndexableObject(candidate) && typeof candidate[property] === 'string' ? candidate[property] : undefined
 }
 
 export function computeStackTraceFromOnErrorMessage(
@@ -214,7 +215,6 @@ function tryToParseMessage(messageObj: unknown) {
   return { name, message }
 }
 
-
 // Custom error stacktrace fix
 // Some browsers (safari/firefox) add the error constructor as a frame in the stacktrace
 // In order to normalize the stacktrace, we need to remove it
@@ -231,14 +231,14 @@ function isWronglyReportingCustomErrors() {
   }
 
   /* eslint-disable no-restricted-syntax */
-  class KubesenseTestCustomError extends Error {
+  class KubeSenseTestCustomError extends Error {
     constructor() {
       super()
       this.name = 'Error' // set name to Error so that no browser would default to the constructor name
     }
   }
 
-  const [customError, nativeError] = [KubesenseTestCustomError, Error].map((errConstructor) => new errConstructor()) // so that both errors should exactly have the same stacktrace
+  const [customError, nativeError] = [KubeSenseTestCustomError, Error].map((errConstructor) => new errConstructor()) // so that both errors should exactly have the same stacktrace
 
   isWronglyReportingCustomErrorsCache =
     // If customError is not a class, it means that this was built with ES5 as target, converting the class to a normal object.
@@ -248,4 +248,4 @@ function isWronglyReportingCustomErrors() {
     nativeError.stack !== customError.stack
 
   return isWronglyReportingCustomErrorsCache
-}
+}

package/src/tools/stackTrace/handlingStack.ts

@@ -1,4 +1,4 @@
-import { callMonitored } from '../monitor'
+import { callMonitored } from '@kubesense/kubesense-js-core/monitor'
 import type { StackTrace } from './computeStackTrace'
 import { computeStackTrace } from './computeStackTrace'
 
@@ -9,7 +9,20 @@ import { computeStackTrace } from './computeStackTrace'
  * - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.
  */
 export function createHandlingStack(
-  type: 'console error' | 'action' | 'error' | 'instrumented method' | 'log' | 'react error'
+  type:
+    | 'console error'
+    | 'action'
+    | 'error'
+    | 'instrumented method'
+    | 'instrumented constructor'
+    | 'log'
+    | 'nuxt error'
+    | 'react error'
+    | 'nextjs error'
+    | 'vue error'
+    | 'angular error'
+    | 'view'
+    | 'vital'
 ): string {
   /**
    * Skip the two internal frames:

package/src/tools/taskQueue.ts

@@ -1,4 +1,4 @@
-import { ONE_SECOND } from './utils/timeUtils'
+import { ONE_SECOND } from '@kubesense/kubesense-js-core/time'
 import { requestIdleCallback } from './requestIdleCallback'
 
 /**
@@ -28,9 +28,11 @@ type Task = () => void
 export function createTaskQueue(): TaskQueue {
   const pendingTasks: Task[] = []
 
-  function run(deadline: IdleDeadline) {
+  function run(deadline: IdleDeadline | null) {
     let executionTimeRemaining: () => number
-    if (deadline.didTimeout) {
+    // `deadline` can be null when `requestIdleCallback` is replaced by a page-injected polyfill
+    // (e.g. `setTimeout(cb, 0)` in some WKWebViews) that invokes the callback with no argument.
+    if (!deadline || deadline.didTimeout) {
       const start = performance.now()
       executionTimeRemaining = () => MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start)
     } else {

package/src/tools/thenable.ts

@@ -0,0 +1,23 @@
+import type { TimeoutId } from './timer'
+import { setTimeout, clearTimeout } from './timer'
+
+export function isThenable<T>(value: unknown): value is PromiseLike<T> {
+  return !!value && typeof (value as { then?: unknown }).then === 'function'
+}
+
+export const TIMEOUT_ERROR_MESSAGE = 'Timeout'
+export function isTimeoutError(error: unknown): error is Error {
+  return error instanceof Error && error.message === TIMEOUT_ERROR_MESSAGE
+}
+
+/**
+ * Resolves or rejects with `thenable`, or rejects with a `TIMEOUT_ERROR_MESSAGE` error if it
+ * doesn't settle within `timeout` ms.
+ */
+export function waitForThenable<T>(thenable: PromiseLike<T>, timeout = 3000): Promise<T> {
+  let timeoutId: TimeoutId
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(TIMEOUT_ERROR_MESSAGE)), timeout)
+  })
+  return Promise.race([thenable, timeoutPromise]).finally(() => clearTimeout(timeoutId))
+}

package/src/tools/timer.ts

@@ -1,21 +1,22 @@
+import type { GlobalObject } from '@kubesense/kubesense-js-core/util'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
-import { monitor } from './monitor'
-import { getGlobalObject } from './globalObject'
 
-export type TimeoutId = ReturnType<typeof globalThis.setTimeout>
+export type TimeoutId = ReturnType<GlobalObject['setTimeout']>
 
 export function setTimeout(callback: () => void, delay?: number): TimeoutId {
-  return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay)
+  return getZoneJsOriginalValue(globalObject, 'setTimeout')(monitor(callback), delay)
 }
 
 export function clearTimeout(timeoutId: TimeoutId | undefined) {
-  getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId)
+  getZoneJsOriginalValue(globalObject, 'clearTimeout')(timeoutId)
 }
 
 export function setInterval(callback: () => void, delay?: number): TimeoutId {
-  return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay)
+  return getZoneJsOriginalValue(globalObject, 'setInterval')(monitor(callback), delay)
 }
 
 export function clearInterval(timeoutId: TimeoutId | undefined) {
-  getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId)
+  getZoneJsOriginalValue(globalObject, 'clearInterval')(timeoutId)
 }

package/src/tools/utils/arrayUtils.ts

@@ -10,7 +10,13 @@ export function removeItem<T>(array: T[], item: T) {
     array.splice(index, 1)
   }
 }
-
 export function isNonEmptyArray<T>(value: unknown): value is T[] {
   return Array.isArray(value) && value.length > 0
-}
+}
+
+export function mergeArrays<T>(current: T[] | undefined, next: T[] | undefined): T[] | undefined {
+  if (!next?.length) {
+    return current
+  }
+  return current ? current.concat(next) : next
+}

package/src/tools/utils/browserDetection.ts

@@ -37,3 +37,11 @@ export function detectBrowser(browserWindow: Window = window) {
 
   return Browser.OTHER
 }
+
+export function detectVersion() {
+  const userAgent = window.navigator.userAgent
+  const match = userAgent.match(/(?:chrome|headlesschrome|version)\/(\d+)/i)
+  if (match) {
+    return parseInt(match[1], 10)
+  }
+}

package/src/tools/utils/byteUtils.ts

@@ -16,11 +16,7 @@ export function computeBytesCount(candidate: string): number {
     return candidate.length
   }
 
-  if (window.TextEncoder !== undefined) {
-    return new TextEncoder().encode(candidate).length
-  }
-
-  return new Blob([candidate]).size
+  return new TextEncoder().encode(candidate).length
 }
 
 export function concatBuffers(buffers: Uint8ArrayBuffer[]): Uint8ArrayBuffer {
@@ -28,7 +24,7 @@ export function concatBuffers(buffers: Uint8ArrayBuffer[]): Uint8ArrayBuffer {
   if (buffers.length === 1) {
     return buffers[0]
   }
-  
+
   const length = buffers.reduce((total, buffer) => total + buffer.length, 0)
   const result: Uint8ArrayBuffer = new Uint8Array(length)
   let offset = 0

package/src/tools/utils/functionUtils.ts

@@ -7,8 +7,8 @@ export function throttle<T extends (...args: any[]) => void>(
   wait: number,
   options?: { leading?: boolean; trailing?: boolean }
 ) {
-  const needLeadingExecution = options && options.leading !== undefined ? options.leading : true
-  const needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true
+  const needLeadingExecution = options?.leading !== undefined ? options.leading : true
+  const needTrailingExecution = options?.trailing !== undefined ? options.trailing : true
   let inWaitPeriod = false
   let pendingExecutionWithParameters: Parameters<T> | undefined
   let pendingTimeoutId: TimeoutId

package/src/tools/utils/numberUtils.ts

@@ -1,19 +1,7 @@
-/**
- * Return true if the draw is successful
- * @param threshold - Threshold between 0 and 100
- */
-export function performDraw(threshold: number): boolean {
-  return threshold !== 0 && Math.random() * 100 <= threshold
-}
-
 export function round(num: number, decimals: 0 | 1 | 2 | 3 | 4) {
   return +num.toFixed(decimals)
 }
 
-export function isPercentage(value: unknown) {
-  return isNumber(value) && value >= 0 && value <= 100
-}
-
 export function isNumber(value: unknown): value is number {
   return typeof value === 'number'
 }

package/src/tools/utils/objectUtils.ts

@@ -1,3 +1,14 @@
+// Prevent prototype pollution: __proto__ as an own property in parsed JSON can corrupt Object.prototype
+const stripDangerousKeys = (key: string, value: unknown) => (key === '__proto__' ? undefined : value)
+
+export function tryJsonParse<T = unknown>(text: string): T | undefined {
+  try {
+    return JSON.parse(text, stripDangerousKeys) as T
+  } catch {
+    // ignore
+  }
+}
+
 export function shallowClone<T>(object: T): T & Record<string, never> {
   return { ...object } as T & Record<string, never>
 }
@@ -17,3 +28,12 @@ export function mapValues<A, B>(object: { [key: string]: A }, fn: (arg: A) => B)
   }
   return newObject
 }
+
+export function getConstructorName(value: unknown): string | undefined {
+  try {
+    const name = (value as { constructor?: { name?: unknown } } | null | undefined)?.constructor?.name
+    return typeof name === 'string' && name ? name : undefined
+  } catch {
+    // ignore: accessing `constructor` can throw on hostile objects
+  }
+}