@openobserve/browser-core 0.3.4 → 0.4.0-beta.2

package/src/tools/matchOption.ts

@@ -1,5 +1,5 @@
+import { getType } from '@openobserve/js-core/util'
 import { display } from './display'
-import { getType } from './utils/typeUtils'
 
 export type MatchOption = string | RegExp | ((value: string) => boolean)
 
@@ -19,6 +19,8 @@ export function matchList(list: MatchOption[], value: string, useStartsWith = fa
       if (typeof item === 'function') {
         return item(value)
       } else if (item instanceof RegExp) {
+        // Prevent stateful matching
+        item.lastIndex = 0
         return item.test(value)
       } else if (typeof item === 'string') {
         return useStartsWith ? value.startsWith(item) : item === value

package/src/tools/mockable.ts

@@ -0,0 +1,32 @@
+declare const __BUILD_ENV__SDK_VERSION__: string
+
+export const mockableReplacements = new Map<unknown, unknown>()
+
+/**
+ * Wraps a value to make it mockable in tests. In production builds, this is a no-op
+ * that returns the value as-is. In test builds, it checks if a mock replacement has
+ * been registered and returns that instead.
+ *
+ * @example
+ * // In source file:
+ * import { mockable } from '../tools/mockable'
+ * export function formatNavigationEntry(): string {
+ *   const navigationEntry = mockable(getNavigationEntry)()
+ *   ...
+ * }
+ *
+ * // In test file:
+ * import { replaceMockable } from '@openobserve/browser-core/test'
+ * it('...', () => {
+ *   replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)
+ *   expect(formatNavigationEntry()).toEqual(...)
+ * })
+ */
+export function mockable<T>(value: T): T {
+  // In test builds, return a wrapper that checks for mocks at call time
+  if (__BUILD_ENV__SDK_VERSION__ === 'test' && mockableReplacements.has(value)) {
+    return mockableReplacements.get(value)! as T
+  }
+  // In production, return the value as-is
+  return value
+}

package/src/tools/monitor.ts

@@ -1,72 +1,24 @@
+/* eslint-disable local-rules/disallow-side-effects */
+import { createMonitor } from '@openobserve/js-core/monitor'
+import { setDebugMode } from '@openobserve/js-core/util'
 import { display } from './display'
 
-let onMonitorErrorCollected: undefined | ((error: unknown) => void)
-let debugMode = false
+// The error-collection callback is wired lazily (via `startMonitorErrorCollection`, during telemetry
+// init), so we pass a stable forwarding function to `createMonitor` and keep the real callback in a
+// mutable holder.
+let onMonitorErrorCollected: ((error: unknown) => void) | undefined
+
+const { monitored, monitor, callMonitored, monitorError } = createMonitor(display, (error) =>
+  onMonitorErrorCollected?.(error)
+)
+
+export { monitored, monitor, callMonitored, monitorError }
 
 export function startMonitorErrorCollection(newOnMonitorErrorCollected: (error: unknown) => void) {
   onMonitorErrorCollected = newOnMonitorErrorCollected
 }
 
-export function setDebugMode(newDebugMode: boolean) {
-  debugMode = newDebugMode
-}
-
 export function resetMonitor() {
   onMonitorErrorCollected = undefined
-  debugMode = false
-}
-
-export function monitored<T extends (...params: any[]) => unknown>(
-  _: any,
-  __: string,
-  descriptor: TypedPropertyDescriptor<T>
-) {
-  const originalMethod = descriptor.value!
-  descriptor.value = function (this: any, ...args: Parameters<T>) {
-    const decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod
-    return decorated.apply(this, args) as ReturnType<T>
-  } as T
-}
-
-export function monitor<T extends (...args: any[]) => any>(fn: T): T {
-  return function (this: any) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return callMonitored(fn, this, arguments as unknown as Parameters<T>)
-  } as unknown as T // consider output type has input type
-}
-
-export function callMonitored<T extends (...args: any[]) => any>(
-  fn: T,
-  context: ThisParameterType<T>,
-  args: Parameters<T>
-): ReturnType<T> | undefined
-export function callMonitored<T extends (this: void) => any>(fn: T): ReturnType<T> | undefined
-export function callMonitored<T extends (...args: any[]) => any>(
-  fn: T,
-  context?: any,
-  args?: any
-): ReturnType<T> | undefined {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return fn.apply(context, args)
-  } catch (e) {
-    monitorError(e)
-  }
-}
-
-export function monitorError(e: unknown) {
-  displayIfDebugEnabled(e)
-  if (onMonitorErrorCollected) {
-    try {
-      onMonitorErrorCollected(e)
-    } catch (e) {
-      displayIfDebugEnabled(e)
-    }
-  }
-}
-
-export function displayIfDebugEnabled(...args: any[]) {
-  if (debugMode) {
-    display.error('[MONITOR]', ...args)
-  }
+  setDebugMode(false)
 }

package/src/tools/observable.ts

@@ -51,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()
   }
 
@@ -60,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)
   }
@@ -98,6 +103,9 @@ 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

@@ -2,7 +2,12 @@ import { monitor } from './monitor'
 import { globalObject } from './globalObject'
 
 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 '@openobserve/js-core/time'
 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/serialisation/sanitize.ts

@@ -6,7 +6,7 @@ import { detachToJsonMethod } from './jsonStringify'
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 type PrimitivesAndFunctions = string | number | boolean | undefined | null | symbol | bigint | Function
-type ExtendedContextValue = PrimitivesAndFunctions | object | ExtendedContext | ExtendedContextArray
+type ExtendedContextValue = PrimitivesAndFunctions | ExtendedContext | ExtendedContextArray
 interface ExtendedContext {
   [key: string]: ExtendedContextValue
 }
@@ -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()
+  }
 }
 
 /**
@@ -177,7 +179,7 @@ function sanitizeProcessor(
   const currentPath = key !== undefined ? `${parentPath}.${key}` : parentPath
   const target = Array.isArray(sourceToSanitize) ? ([] as ContextArray) : ({} as Context)
   visitedObjectsWithPath.set(sourceAsObject, currentPath)
-  queue.push({ source: sourceToSanitize as ExtendedContext | ExtendedContextArray, target, path: currentPath })
+  queue.push({ source: sourceToSanitize, target, path: currentPath })
 
   return target
 }
@@ -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 {

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 '@openobserve/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) {
@@ -91,8 +93,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 +113,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 +128,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 +183,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(

package/src/tools/stackTrace/handlingStack.ts

@@ -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 '@openobserve/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/timer.ts

@@ -1,21 +1,22 @@
 import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
 import { monitor } from './monitor'
-import { getGlobalObject } from './globalObject'
+import type { GlobalObject } from './globalObject'
+import { globalObject } 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

@@ -13,3 +13,10 @@ export function removeItem<T>(array: T[], item: T) {
 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 {

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/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
+  }
+}