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

package/esm/tools/serialisation/jsonStringify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonStringify.mjs","names":[],"sources":["../../../src/tools/serialisation/jsonStringify.ts"],"sourcesContent":["import { noop } from '../utils/functionUtils'\n\n/**\n * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that\n * because some sites badly override toJSON on certain objects. Removing all toJSON methods from\n * nested values would be too costly, so we just detach them from the root value, and native classes\n * used to build JSON values (Array and Object).\n *\n * Note: this still assumes that JSON.stringify is correct.\n */\nexport function jsonStringify(\n  value: unknown,\n  replacer?: Array<string | number>,\n  space?: string | number\n): string | undefined {\n  if (typeof value !== 'object' || value === null) {\n    return JSON.stringify(value)\n  }\n\n  // Note: The order matter here. We need to detach toJSON methods on parent classes before their\n  // subclasses.\n  const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)\n  const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)\n  const restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value))\n  const restoreValueToJson = detachToJsonMethod(value)\n\n  try {\n    return JSON.stringify(value, replacer, space)\n  } catch {\n    return '<error: unable to serialize object>'\n  } finally {\n    restoreObjectPrototypeToJson()\n    restoreArrayPrototypeToJson()\n    restoreValuePrototypeToJson()\n    restoreValueToJson()\n  }\n}\n\nexport interface ObjectWithToJsonMethod {\n  toJSON?: () => unknown\n}\n\nexport function detachToJsonMethod(value: object) {\n  const object = value as ObjectWithToJsonMethod\n  const objectToJson = object.toJSON\n  if (objectToJson) {\n    delete object.toJSON\n    return () => {\n      object.toJSON = objectToJson\n    }\n  }\n  return noop\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,cACd,OACA,UACA,OACoB;CACpB,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO,KAAK,UAAU,KAAK;CAK7B,MAAM,+BAA+B,mBAAmB,OAAO,SAAS;CACxE,MAAM,8BAA8B,mBAAmB,MAAM,SAAS;CACtE,MAAM,8BAA8B,mBAAmB,OAAO,eAAe,KAAK,CAAC;CACnF,MAAM,qBAAqB,mBAAmB,KAAK;CAEnD,IAAI;EACF,OAAO,KAAK,UAAU,OAAO,UAAU,KAAK;CAC9C,QAAQ;EACN,OAAO;CACT,UAAU;EACR,6BAA6B;EAC7B,4BAA4B;EAC5B,4BAA4B;EAC5B,mBAAmB;CACrB;AACF;AAMA,SAAgB,mBAAmB,OAAe;CAChD,MAAM,SAAS;CACf,MAAM,eAAe,OAAO;CAC5B,IAAI,cAAc;EAChB,OAAO,OAAO;EACd,aAAa;GACX,OAAO,SAAS;EAClB;CACF;CACA,OAAO;AACT"}

package/esm/tools/serialisation/sanitize.mjs

@@ -0,0 +1,131 @@
+import { display } from "../display.mjs";
+import { ONE_KIBI_BYTE } from "../utils/byteUtils.mjs";
+import { detachToJsonMethod } from "./jsonStringify.mjs";
+//#region src/tools/serialisation/sanitize.ts
+const SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE;
+const JSON_PATH_ROOT_ELEMENT = "$";
+const KEY_DECORATION_LENGTH = 3;
+function sanitize(source, maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT) {
+	const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);
+	const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);
+	try {
+		const containerQueue = [];
+		const visitedObjectsWithPath = /* @__PURE__ */ new WeakMap();
+		const sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, void 0, containerQueue, visitedObjectsWithPath);
+		const serializedSanitizedData = JSON.stringify(sanitizedData);
+		let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0;
+		if (accumulatedCharacterCount > maxCharacterCount) {
+			warnOverCharacterLimit(maxCharacterCount, "discarded", source);
+			return;
+		}
+		while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
+			const containerToProcess = containerQueue.shift();
+			let separatorLength = 0;
+			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);
+				if (targetData !== void 0) accumulatedCharacterCount += JSON.stringify(targetData).length;
+				else accumulatedCharacterCount += 4;
+				accumulatedCharacterCount += separatorLength;
+				separatorLength = 1;
+				if (accumulatedCharacterCount > maxCharacterCount) {
+					warnOverCharacterLimit(maxCharacterCount, "truncated", source);
+					break;
+				}
+				containerToProcess.target[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);
+				if (targetData !== void 0) {
+					accumulatedCharacterCount += JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;
+					separatorLength = 1;
+				}
+				if (accumulatedCharacterCount > maxCharacterCount) {
+					warnOverCharacterLimit(maxCharacterCount, "truncated", source);
+					break;
+				}
+				containerToProcess.target[key] = targetData;
+			}
+		}
+		return sanitizedData;
+	} finally {
+		restoreObjectPrototypeToJson();
+		restoreArrayPrototypeToJson();
+	}
+}
+/**
+* Internal function to factorize the process common to the
+* initial call to sanitize, and iterations for Arrays and Objects
+*
+*/
+function sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {
+	const sourceToSanitize = tryToApplyToJSON(source);
+	if (!sourceToSanitize || typeof sourceToSanitize !== "object") return sanitizePrimitivesAndFunctions(sourceToSanitize);
+	const sanitizedSource = sanitizeObjects(sourceToSanitize);
+	if (sanitizedSource !== "[Object]" && sanitizedSource !== "[Array]" && sanitizedSource !== "[Error]") return sanitizedSource;
+	const sourceAsObject = source;
+	if (visitedObjectsWithPath.has(sourceAsObject)) return `[Reference seen at ${visitedObjectsWithPath.get(sourceAsObject)}]`;
+	const currentPath = key !== void 0 ? `${parentPath}.${key}` : parentPath;
+	const target = Array.isArray(sourceToSanitize) ? [] : {};
+	visitedObjectsWithPath.set(sourceAsObject, currentPath);
+	queue.push({
+		source: sourceToSanitize,
+		target,
+		path: currentPath
+	});
+	return target;
+}
+/**
+* Handles sanitization of simple, non-object types
+*
+*/
+function sanitizePrimitivesAndFunctions(value) {
+	if (typeof value === "bigint") return `[BigInt] ${value.toString()}`;
+	if (typeof value === "function") return `[Function] ${value.name || "unknown"}`;
+	if (typeof value === "symbol") return `[Symbol] ${value.description || value.toString()}`;
+	return value;
+}
+/**
+* Handles sanitization of object types
+*
+* LIMITATIONS
+* - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.
+* To avoid this, a toJSON method can be defined.
+*/
+function sanitizeObjects(value) {
+	try {
+		if (value instanceof Event) return sanitizeEvent(value);
+		if (value instanceof RegExp) return `[RegExp] ${value.toString()}`;
+		const match = Object.prototype.toString.call(value).match(/\[object (.*)\]/);
+		if (match?.[1]) return `[${match[1]}]`;
+	} catch {}
+	return "[Unserializable]";
+}
+function sanitizeEvent(event) {
+	return {
+		type: event.type,
+		isTrusted: event.isTrusted,
+		currentTarget: event.currentTarget ? sanitizeObjects(event.currentTarget) : null,
+		target: event.target ? sanitizeObjects(event.target) : null
+	};
+}
+/**
+* Checks if a toJSON function exists and tries to execute it
+*
+*/
+function tryToApplyToJSON(value) {
+	const object = value;
+	if (object && typeof object.toJSON === "function") try {
+		return object.toJSON();
+	} catch {}
+	return value;
+}
+/**
+* Helper function to display the warning when the accumulated character count is over the limit
+*/
+function warnOverCharacterLimit(maxCharacterCount, changeType, source) {
+	display.warn(`The data provided has been ${changeType} as it is over the limit of ${maxCharacterCount} characters:`, source);
+}
+//#endregion
+export { SANITIZE_DEFAULT_MAX_CHARACTER_COUNT, sanitize };
+
+//# sourceMappingURL=sanitize.mjs.map

package/esm/tools/serialisation/sanitize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.mjs","names":[],"sources":["../../../src/tools/serialisation/sanitize.ts"],"sourcesContent":["import { display } from '../display'\nimport { ONE_KIBI_BYTE } from '../utils/byteUtils'\nimport type { Context, ContextArray, ContextValue } from './context'\nimport type { ObjectWithToJsonMethod } from './jsonStringify'\nimport { detachToJsonMethod } from './jsonStringify'\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\ntype PrimitivesAndFunctions = string | number | boolean | undefined | null | symbol | bigint | Function\ntype ExtendedContextValue = PrimitivesAndFunctions | ExtendedContext | ExtendedContextArray\ninterface ExtendedContext {\n  [key: string]: ExtendedContextValue\n}\ntype ExtendedContextArray = ExtendedContextValue[]\n\ninterface ContainerElementToProcess {\n  source: ExtendedContextArray | ExtendedContext\n  target: ContextArray | Context\n  path: string\n}\n\ninterface SanitizedEvent extends Context {\n  type: string\n  isTrusted: boolean\n  currentTarget: string | null | undefined\n  target: string | null | undefined\n}\n\n// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data\n// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...\nexport const SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE\n\n// Symbol for the root element of the JSONPath used for visited objects\nconst JSON_PATH_ROOT_ELEMENT = '$'\n\n// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as \"key\".\n// With the separator (:), we need to add 3 characters to the count.\nconst KEY_DECORATION_LENGTH = 3\n\n/**\n * Ensures user-provided data is 'safe' for the SDK\n * - Deep clones data\n * - Removes cyclic references\n * - Transforms unserializable types to a string representation\n *\n * LIMITATIONS:\n * - Size is in characters, not byte count (may differ according to character encoding)\n * - Size does not take into account indentation that can be applied to JSON.stringify\n * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify\n *\n * @param source              - User-provided data meant to be serialized using JSON.stringify\n * @param maxCharacterCount   - Maximum number of characters allowed in serialized form\n */\nexport function sanitize(source: string, maxCharacterCount?: number): string | undefined\nexport function sanitize(source: Context, maxCharacterCount?: number): Context\nexport function sanitize(source: unknown, maxCharacterCount?: number): ContextValue\nexport function sanitize(source: unknown, maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT) {\n  // Unbind any toJSON function we may have on [] or {} prototypes\n  const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)\n  const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)\n\n  try {\n    // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object\n    const containerQueue: ContainerElementToProcess[] = []\n    const visitedObjectsWithPath = new WeakMap<object, string>()\n    const sanitizedData = sanitizeProcessor(\n      source as ExtendedContextValue,\n      JSON_PATH_ROOT_ELEMENT,\n      undefined,\n      containerQueue,\n      visitedObjectsWithPath\n    )\n    const serializedSanitizedData = JSON.stringify(sanitizedData)\n    let accumulatedCharacterCount = serializedSanitizedData ? serializedSanitizedData.length : 0\n\n    if (accumulatedCharacterCount > maxCharacterCount) {\n      warnOverCharacterLimit(maxCharacterCount, 'discarded', source)\n      return undefined\n    }\n\n    while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {\n      const containerToProcess = containerQueue.shift()!\n      let separatorLength = 0 // 0 for the first element, 1 for subsequent elements\n\n      // Arrays and Objects have to be handled distinctly to ensure\n      // we do not pick up non-numerical properties from Arrays\n      if (Array.isArray(containerToProcess.source)) {\n        for (let key = 0; key < containerToProcess.source.length; key++) {\n          const targetData = sanitizeProcessor(\n            containerToProcess.source[key],\n            containerToProcess.path,\n            key,\n            containerQueue,\n            visitedObjectsWithPath\n          )\n\n          if (targetData !== undefined) {\n            accumulatedCharacterCount += JSON.stringify(targetData).length\n          } else {\n            // When an element of an Array (targetData) is undefined, it is serialized as null:\n            // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters\n            accumulatedCharacterCount += 4\n          }\n          accumulatedCharacterCount += separatorLength\n          separatorLength = 1\n          if (accumulatedCharacterCount > maxCharacterCount) {\n            warnOverCharacterLimit(maxCharacterCount, 'truncated', source)\n            break\n          }\n          ;(containerToProcess.target as ContextArray)[key] = targetData\n        }\n      } else {\n        for (const key in containerToProcess.source) {\n          if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {\n            const targetData = sanitizeProcessor(\n              containerToProcess.source[key],\n              containerToProcess.path,\n              key,\n              containerQueue,\n              visitedObjectsWithPath\n            )\n            // When a property of an object has an undefined value, it will be dropped during serialization:\n            // JSON.stringify({a:undefined}) => '{}'\n            if (targetData !== undefined) {\n              accumulatedCharacterCount +=\n                JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH\n              separatorLength = 1\n            }\n            if (accumulatedCharacterCount > maxCharacterCount) {\n              warnOverCharacterLimit(maxCharacterCount, 'truncated', source)\n              break\n            }\n            ;(containerToProcess.target as Context)[key] = targetData\n          }\n        }\n      }\n    }\n\n    return sanitizedData\n  } finally {\n    // Rebind detached toJSON functions\n    restoreObjectPrototypeToJson()\n    restoreArrayPrototypeToJson()\n  }\n}\n\n/**\n * Internal function to factorize the process common to the\n * initial call to sanitize, and iterations for Arrays and Objects\n *\n */\nfunction sanitizeProcessor(\n  source: ExtendedContextValue,\n  parentPath: string,\n  key: string | number | undefined,\n  queue: ContainerElementToProcess[],\n  visitedObjectsWithPath: WeakMap<object, string>\n) {\n  // Start by handling toJSON, as we want to sanitize its output\n  const sourceToSanitize = tryToApplyToJSON(source)\n\n  if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {\n    return sanitizePrimitivesAndFunctions(sourceToSanitize)\n  }\n\n  const sanitizedSource = sanitizeObjects(sourceToSanitize)\n  if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {\n    return sanitizedSource\n  }\n\n  // Handle potential cyclic references\n  // We need to use source as sourceToSanitize could be a reference to a new object\n  // At this stage, we know the source is an object type\n  const sourceAsObject = source as object\n  if (visitedObjectsWithPath.has(sourceAsObject)) {\n    return `[Reference seen at ${visitedObjectsWithPath.get(sourceAsObject)!}]`\n  }\n\n  // Add processed source to queue\n  const currentPath = key !== undefined ? `${parentPath}.${key}` : parentPath\n  const target = Array.isArray(sourceToSanitize) ? ([] as ContextArray) : ({} as Context)\n  visitedObjectsWithPath.set(sourceAsObject, currentPath)\n  queue.push({ source: sourceToSanitize, target, path: currentPath })\n\n  return target\n}\n\n/**\n * Handles sanitization of simple, non-object types\n *\n */\nfunction sanitizePrimitivesAndFunctions(value: PrimitivesAndFunctions) {\n  // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation\n  if (typeof value === 'bigint') {\n    return `[BigInt] ${value.toString()}`\n  }\n  // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted\n  // so it won't prevent stringify from serializing later\n  if (typeof value === 'function') {\n    return `[Function] ${value.name || 'unknown'}`\n  }\n  // JSON.stringify() does not serialize symbols.\n  if (typeof value === 'symbol') {\n    // symbol.description is part of ES2019+\n    type symbolWithDescription = symbol & { description: string }\n    return `[Symbol] ${(value as symbolWithDescription).description || value.toString()}`\n  }\n\n  return value\n}\n\n/**\n * Handles sanitization of object types\n *\n * LIMITATIONS\n * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.\n * To avoid this, a toJSON method can be defined.\n */\nfunction sanitizeObjects(value: object): string | SanitizedEvent {\n  try {\n    if (value instanceof Event) {\n      return sanitizeEvent(value)\n    }\n\n    if (value instanceof RegExp) {\n      return `[RegExp] ${value.toString()}`\n    }\n\n    // Handle all remaining object types in a generic way\n    const result = Object.prototype.toString.call(value)\n    const match = result.match(/\\[object (.*)\\]/)\n    if (match?.[1]) {\n      return `[${match[1]}]`\n    }\n  } catch {\n    // If the previous serialization attempts failed, and we cannot convert using\n    // Object.prototype.toString, declare the value unserializable\n  }\n  return '[Unserializable]'\n}\n\nfunction sanitizeEvent(event: Event): SanitizedEvent {\n  return {\n    type: event.type,\n    isTrusted: event.isTrusted,\n    currentTarget: event.currentTarget ? (sanitizeObjects(event.currentTarget) as string) : null,\n    target: event.target ? (sanitizeObjects(event.target) as string) : null,\n  }\n}\n\n/**\n * Checks if a toJSON function exists and tries to execute it\n *\n */\nfunction tryToApplyToJSON(value: ExtendedContextValue) {\n  const object = value as ObjectWithToJsonMethod\n  if (object && typeof object.toJSON === 'function') {\n    try {\n      return object.toJSON() as ExtendedContextValue\n    } catch {\n      // If toJSON fails, we continue by trying to serialize the value manually\n    }\n  }\n\n  return value\n}\n\n/**\n * Helper function to display the warning when the accumulated character count is over the limit\n */\nfunction warnOverCharacterLimit(maxCharacterCount: number, changeType: 'discarded' | 'truncated', source: unknown) {\n  display.warn(\n    `The data provided has been ${changeType} as it is over the limit of ${maxCharacterCount} characters:`,\n    source\n  )\n}\n"],"mappings":";;;;AA6BA,MAAa,uCAAuC,MAAM;AAG1D,MAAM,yBAAyB;AAI/B,MAAM,wBAAwB;AAmB9B,SAAgB,SAAS,QAAiB,oBAAoB,sCAAsC;CAElG,MAAM,+BAA+B,mBAAmB,OAAO,SAAS;CACxE,MAAM,8BAA8B,mBAAmB,MAAM,SAAS;CAEtE,IAAI;EAEF,MAAM,iBAA8C,CAAC;EACrD,MAAM,yCAAyB,IAAI,QAAwB;EAC3D,MAAM,gBAAgB,kBACpB,QACA,wBACA,KAAA,GACA,gBACA,sBACF;EACA,MAAM,0BAA0B,KAAK,UAAU,aAAa;EAC5D,IAAI,4BAA4B,0BAA0B,wBAAwB,SAAS;EAE3F,IAAI,4BAA4B,mBAAmB;GACjD,uBAAuB,mBAAmB,aAAa,MAAM;GAC7D;EACF;EAEA,OAAO,eAAe,SAAS,KAAK,4BAA4B,mBAAmB;GACjF,MAAM,qBAAqB,eAAe,MAAM;GAChD,IAAI,kBAAkB;GAItB,IAAI,MAAM,QAAQ,mBAAmB,MAAM,GACzC,KAAK,IAAI,MAAM,GAAG,MAAM,mBAAmB,OAAO,QAAQ,OAAO;IAC/D,MAAM,aAAa,kBACjB,mBAAmB,OAAO,MAC1B,mBAAmB,MACnB,KACA,gBACA,sBACF;IAEA,IAAI,eAAe,KAAA,GACjB,6BAA6B,KAAK,UAAU,UAAU,CAAC,CAAC;SAIxD,6BAA6B;IAE/B,6BAA6B;IAC7B,kBAAkB;IAClB,IAAI,4BAA4B,mBAAmB;KACjD,uBAAuB,mBAAmB,aAAa,MAAM;KAC7D;IACF;IACC,mBAAoB,OAAwB,OAAO;GACtD;QAEA,KAAK,MAAM,OAAO,mBAAmB,QACnC,IAAI,OAAO,UAAU,eAAe,KAAK,mBAAmB,QAAQ,GAAG,GAAG;IACxE,MAAM,aAAa,kBACjB,mBAAmB,OAAO,MAC1B,mBAAmB,MACnB,KACA,gBACA,sBACF;IAGA,IAAI,eAAe,KAAA,GAAW;KAC5B,6BACE,KAAK,UAAU,UAAU,CAAC,CAAC,SAAS,kBAAkB,IAAI,SAAS;KACrE,kBAAkB;IACpB;IACA,IAAI,4BAA4B,mBAAmB;KACjD,uBAAuB,mBAAmB,aAAa,MAAM;KAC7D;IACF;IACC,mBAAoB,OAAmB,OAAO;GACjD;EAGN;EAEA,OAAO;CACT,UAAU;EAER,6BAA6B;EAC7B,4BAA4B;CAC9B;AACF;;;;;;AAOA,SAAS,kBACP,QACA,YACA,KACA,OACA,wBACA;CAEA,MAAM,mBAAmB,iBAAiB,MAAM;CAEhD,IAAI,CAAC,oBAAoB,OAAO,qBAAqB,UACnD,OAAO,+BAA+B,gBAAgB;CAGxD,MAAM,kBAAkB,gBAAgB,gBAAgB;CACxD,IAAI,oBAAoB,cAAc,oBAAoB,aAAa,oBAAoB,WACzF,OAAO;CAMT,MAAM,iBAAiB;CACvB,IAAI,uBAAuB,IAAI,cAAc,GAC3C,OAAO,sBAAsB,uBAAuB,IAAI,cAAc,EAAG;CAI3E,MAAM,cAAc,QAAQ,KAAA,IAAY,GAAG,WAAW,GAAG,QAAQ;CACjE,MAAM,SAAS,MAAM,QAAQ,gBAAgB,IAAK,CAAC,IAAsB,CAAC;CAC1E,uBAAuB,IAAI,gBAAgB,WAAW;CACtD,MAAM,KAAK;EAAE,QAAQ;EAAkB;EAAQ,MAAM;CAAY,CAAC;CAElE,OAAO;AACT;;;;;AAMA,SAAS,+BAA+B,OAA+B;CAErE,IAAI,OAAO,UAAU,UACnB,OAAO,YAAY,MAAM,SAAS;CAIpC,IAAI,OAAO,UAAU,YACnB,OAAO,cAAc,MAAM,QAAQ;CAGrC,IAAI,OAAO,UAAU,UAGnB,OAAO,YAAa,MAAgC,eAAe,MAAM,SAAS;CAGpF,OAAO;AACT;;;;;;;;AASA,SAAS,gBAAgB,OAAwC;CAC/D,IAAI;EACF,IAAI,iBAAiB,OACnB,OAAO,cAAc,KAAK;EAG5B,IAAI,iBAAiB,QACnB,OAAO,YAAY,MAAM,SAAS;EAKpC,MAAM,QADS,OAAO,UAAU,SAAS,KAAK,KAC3B,CAAC,CAAC,MAAM,iBAAiB;EAC5C,IAAI,QAAQ,IACV,OAAO,IAAI,MAAM,GAAG;CAExB,QAAQ,CAGR;CACA,OAAO;AACT;AAEA,SAAS,cAAc,OAA8B;CACnD,OAAO;EACL,MAAM,MAAM;EACZ,WAAW,MAAM;EACjB,eAAe,MAAM,gBAAiB,gBAAgB,MAAM,aAAa,IAAe;EACxF,QAAQ,MAAM,SAAU,gBAAgB,MAAM,MAAM,IAAe;CACrE;AACF;;;;;AAMA,SAAS,iBAAiB,OAA6B;CACrD,MAAM,SAAS;CACf,IAAI,UAAU,OAAO,OAAO,WAAW,YACrC,IAAI;EACF,OAAO,OAAO,OAAO;CACvB,QAAQ,CAER;CAGF,OAAO;AACT;;;;AAKA,SAAS,uBAAuB,mBAA2B,YAAuC,QAAiB;CACjH,QAAQ,KACN,8BAA8B,WAAW,8BAA8B,kBAAkB,eACzF,MACF;AACF"}

package/esm/tools/serialisation/stringify.mjs

@@ -0,0 +1,17 @@
+import { jsonStringify } from "./jsonStringify.mjs";
+import { sanitize } from "./sanitize.mjs";
+//#region src/tools/serialisation/stringify.ts
+function safeToString(value) {
+	try {
+		return String(value);
+	} catch {}
+}
+function safeStringify(value) {
+	try {
+		return jsonStringify(sanitize(value));
+	} catch {}
+}
+//#endregion
+export { safeStringify, safeToString };
+
+//# sourceMappingURL=stringify.mjs.map

package/esm/tools/serialisation/stringify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.mjs","names":[],"sources":["../../../src/tools/serialisation/stringify.ts"],"sourcesContent":["import { jsonStringify } from './jsonStringify'\nimport { sanitize } from './sanitize'\n\nexport function safeToString(value: unknown): string | undefined {\n  try {\n    return String(value)\n  } catch {\n    // ignore\n  }\n}\n\nexport function safeStringify(value: unknown): string | undefined {\n  try {\n    return jsonStringify(sanitize(value))\n  } catch {\n    // ignore\n  }\n}\n"],"mappings":";;;AAGA,SAAgB,aAAa,OAAoC;CAC/D,IAAI;EACF,OAAO,OAAO,KAAK;CACrB,QAAQ,CAER;AACF;AAEA,SAAgB,cAAc,OAAoC;CAChE,IAAI;EACF,OAAO,cAAc,SAAS,KAAK,CAAC;CACtC,QAAQ,CAER;AACF"}

package/esm/tools/stackTrace/computeStackTrace.mjs

@@ -0,0 +1,148 @@
+import { isIndexableObject } from "@openobserve/js-core/util";
+//#region src/tools/stackTrace/computeStackTrace.ts
+/**
+* Cross-browser stack trace computation.
+*
+* Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js
+*/
+const UNKNOWN_FUNCTION = "?";
+function computeStackTrace(ex) {
+	const stack = [];
+	let stackProperty = tryToGetString(ex, "stack");
+	const exString = String(ex);
+	if (stackProperty?.startsWith(exString)) stackProperty = stackProperty.slice(exString.length);
+	if (stackProperty) stackProperty.split("\n").forEach((line) => {
+		const stackFrame = parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line);
+		if (stackFrame) {
+			if (!stackFrame.func && stackFrame.line) stackFrame.func = UNKNOWN_FUNCTION;
+			stack.push(stackFrame);
+		}
+	});
+	if (stack.length > 0 && isWronglyReportingCustomErrors() && ex instanceof Error) {
+		const constructors = [];
+		let currentPrototype = ex;
+		while ((currentPrototype = Object.getPrototypeOf(currentPrototype)) && isNonNativeClassPrototype(currentPrototype)) {
+			const constructorName = currentPrototype.constructor?.name || UNKNOWN_FUNCTION;
+			constructors.push(constructorName);
+		}
+		for (let i = constructors.length - 1; i >= 0 && stack[0]?.func === constructors[i]; i--) stack.shift();
+	}
+	return {
+		message: tryToGetString(ex, "message"),
+		name: tryToGetString(ex, "name"),
+		stack
+	};
+}
+const fileUrl = "((?:file|https?|blob|chrome-extension|electron|native|eval|webpack|snippet|<anonymous>|\\w+\\.|\\/).*?)";
+const filePosition = "(?::(\\d+))";
+const CHROME_LINE_RE = new RegExp(`^\\s*at (.*?) ?\\(${fileUrl}${filePosition}?${filePosition}?\\)?\\s*$`, "i");
+const CHROME_EVAL_RE = new RegExp(`\\((\\S*)${filePosition}${filePosition}\\)`);
+function parseChromeLine(line) {
+	const parts = CHROME_LINE_RE.exec(line);
+	if (!parts) return;
+	const isNative = parts[2]?.indexOf("native") === 0;
+	const isEval = parts[2]?.indexOf("eval") === 0;
+	const submatch = CHROME_EVAL_RE.exec(parts[2]);
+	if (isEval && submatch) {
+		parts[2] = submatch[1];
+		parts[3] = submatch[2];
+		parts[4] = submatch[3];
+	}
+	return {
+		args: isNative ? [parts[2]] : [],
+		column: parts[4] ? +parts[4] : void 0,
+		func: parts[1] || UNKNOWN_FUNCTION,
+		line: parts[3] ? +parts[3] : void 0,
+		url: !isNative ? parts[2] : void 0
+	};
+}
+const CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(`^\\s*at\\s*(?:(.*)?(?: @))?\\s*${fileUrl}${filePosition}?${filePosition}??\\s*$`, "i");
+function parseChromeAnonymousLine(line) {
+	const parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line);
+	if (!parts) return;
+	return {
+		args: [],
+		column: parts[4] ? +parts[4] : void 0,
+		func: parts[1] || UNKNOWN_FUNCTION,
+		line: parts[3] ? +parts[3] : void 0,
+		url: parts[2]
+	};
+}
+const WINJS_LINE_RE = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+function parseWinLine(line) {
+	const parts = WINJS_LINE_RE.exec(line);
+	if (!parts) return;
+	return {
+		args: [],
+		column: parts[4] ? +parts[4] : void 0,
+		func: parts[1] || UNKNOWN_FUNCTION,
+		line: +parts[3],
+		url: parts[2]
+	};
+}
+const GECKO_LINE_RE = /^\s*(.*?)(?:\((.*?)\))?(?:(?:(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\[native).*?|[^@]*bundle|\[wasm code\])(?::(\d+))?(?::(\d+))?)|@)\s*$/i;
+const GECKO_EVAL_RE = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+function parseGeckoLine(line) {
+	const parts = GECKO_LINE_RE.exec(line);
+	if (!parts) return;
+	const isEval = parts[3] && parts[3].indexOf(" > eval") > -1;
+	const submatch = GECKO_EVAL_RE.exec(parts[3]);
+	if (isEval && submatch) {
+		parts[3] = submatch[1];
+		parts[4] = submatch[2];
+		parts[5] = void 0;
+	}
+	return {
+		args: parts[2] ? parts[2].split(",") : [],
+		column: parts[5] ? +parts[5] : void 0,
+		func: parts[1] || UNKNOWN_FUNCTION,
+		line: parts[4] ? +parts[4] : void 0,
+		url: parts[3]
+	};
+}
+function tryToGetString(candidate, property) {
+	return isIndexableObject(candidate) && typeof candidate[property] === "string" ? candidate[property] : void 0;
+}
+function computeStackTraceFromOnErrorMessage(messageObj, url, line, column) {
+	if (url === void 0) return;
+	const { name, message } = tryToParseMessage(messageObj);
+	return {
+		name,
+		message,
+		stack: [{
+			url,
+			column,
+			line
+		}]
+	};
+}
+const ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\s\S]*)$/;
+function tryToParseMessage(messageObj) {
+	let name;
+	let message;
+	if ({}.toString.call(messageObj) === "[object String]") [, name, message] = ERROR_TYPES_RE.exec(messageObj);
+	return {
+		name,
+		message
+	};
+}
+function isNonNativeClassPrototype(prototype) {
+	return String(prototype.constructor).startsWith("class ");
+}
+let isWronglyReportingCustomErrorsCache;
+function isWronglyReportingCustomErrors() {
+	if (isWronglyReportingCustomErrorsCache !== void 0) return isWronglyReportingCustomErrorsCache;
+	class DatadogTestCustomError extends Error {
+		constructor() {
+			super();
+			this.name = "Error";
+		}
+	}
+	const [customError, nativeError] = [DatadogTestCustomError, Error].map((errConstructor) => new errConstructor());
+	isWronglyReportingCustomErrorsCache = isNonNativeClassPrototype(Object.getPrototypeOf(customError)) && nativeError.stack !== customError.stack;
+	return isWronglyReportingCustomErrorsCache;
+}
+//#endregion
+export { computeStackTrace, computeStackTraceFromOnErrorMessage };
+
+//# sourceMappingURL=computeStackTrace.mjs.map

package/esm/tools/stackTrace/computeStackTrace.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeStackTrace.mjs","names":[],"sources":["../../../src/tools/stackTrace/computeStackTrace.ts"],"sourcesContent":["/**\n * Cross-browser stack trace computation.\n *\n * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js\n */\n\nimport { isIndexableObject } from '@openobserve/js-core/util'\n\nexport interface StackFrame {\n  url?: string\n  func?: string\n  /** The arguments passed to the function, if known. */\n  args?: string[]\n  line?: number\n  column?: number\n  /** An array of source code lines; the middle element corresponds to the correct line. */\n  context?: string[]\n}\n\nexport interface StackTrace {\n  name?: string\n  message?: string\n  url?: string\n  stack: StackFrame[]\n  incomplete?: boolean\n  partial?: boolean\n}\n\nconst UNKNOWN_FUNCTION = '?'\n\nexport function computeStackTrace(ex: unknown): StackTrace {\n  const stack: StackFrame[] = []\n\n  let stackProperty = tryToGetString(ex, 'stack')\n  const exString = String(ex)\n  if (stackProperty?.startsWith(exString)) {\n    stackProperty = stackProperty.slice(exString.length)\n  }\n  if (stackProperty) {\n    stackProperty.split('\\n').forEach((line) => {\n      const stackFrame =\n        parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line)\n      if (stackFrame) {\n        if (!stackFrame.func && stackFrame.line) {\n          stackFrame.func = UNKNOWN_FUNCTION\n        }\n\n        stack.push(stackFrame)\n      }\n    })\n  }\n\n  if (stack.length > 0 && isWronglyReportingCustomErrors() && ex instanceof Error) {\n    // if we are wrongly reporting custom errors\n    const constructors: string[] = []\n\n    // go through each inherited constructor\n    let currentPrototype: object | undefined = ex\n    while (\n      (currentPrototype = Object.getPrototypeOf(currentPrototype)) &&\n      isNonNativeClassPrototype(currentPrototype)\n    ) {\n      const constructorName = currentPrototype.constructor?.name || UNKNOWN_FUNCTION\n      constructors.push(constructorName)\n    }\n\n    // traverse the stacktrace in reverse order because the stacktrace starts with the last inherited constructor\n    // we check constructor names to ensure we remove the correct frame (and there isn't a weird unsupported environment behavior)\n    for (let i = constructors.length - 1; i >= 0 && stack[0]?.func === constructors[i]; i--) {\n      // if the first stack frame is the custom error constructor\n      // null stack frames may represent frames that failed to be parsed because the error class did not have a constructor\n      stack.shift() // remove it\n    }\n  }\n\n  return {\n    message: tryToGetString(ex, 'message'),\n    name: tryToGetString(ex, 'name'),\n    stack,\n  }\n}\nconst fileUrl =\n  '((?:file|https?|blob|chrome-extension|electron|native|eval|webpack|snippet|<anonymous>|\\\\w+\\\\.|\\\\/).*?)'\nconst filePosition = '(?::(\\\\d+))'\nconst CHROME_LINE_RE = new RegExp(`^\\\\s*at (.*?) ?\\\\(${fileUrl}${filePosition}?${filePosition}?\\\\)?\\\\s*$`, 'i')\n\nconst CHROME_EVAL_RE = new RegExp(`\\\\((\\\\S*)${filePosition}${filePosition}\\\\)`)\n\nfunction parseChromeLine(line: string): StackFrame | undefined {\n  const parts = CHROME_LINE_RE.exec(line)\n\n  if (!parts) {\n    return\n  }\n\n  const isNative = parts[2]?.indexOf('native') === 0 // start of line\n  const isEval = parts[2]?.indexOf('eval') === 0 // start of line\n  const submatch = CHROME_EVAL_RE.exec(parts[2])\n\n  if (isEval && submatch) {\n    // throw out eval line/column and use top-most line/column number\n    parts[2] = submatch[1] // url\n    parts[3] = submatch[2] // line\n    parts[4] = submatch[3] // column\n  }\n\n  return {\n    args: isNative ? [parts[2]] : [],\n    column: parts[4] ? +parts[4] : undefined,\n    func: parts[1] || UNKNOWN_FUNCTION,\n    line: parts[3] ? +parts[3] : undefined,\n    url: !isNative ? parts[2] : undefined,\n  }\n}\n\nconst htmlAnonymousPart = '(?:(.*)?(?: @))'\nconst CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(\n  `^\\\\s*at\\\\s*${htmlAnonymousPart}?\\\\s*${fileUrl}${filePosition}?${filePosition}??\\\\s*$`,\n  'i'\n)\n\nfunction parseChromeAnonymousLine(line: string): StackFrame | undefined {\n  const parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line)\n\n  if (!parts) {\n    return\n  }\n\n  return {\n    args: [],\n    column: parts[4] ? +parts[4] : undefined,\n    func: parts[1] || UNKNOWN_FUNCTION,\n    line: parts[3] ? +parts[3] : undefined,\n    url: parts[2],\n  }\n}\n\nconst WINJS_LINE_RE =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i\n\nfunction parseWinLine(line: string): StackFrame | undefined {\n  const parts = WINJS_LINE_RE.exec(line)\n  if (!parts) {\n    return\n  }\n\n  return {\n    args: [],\n    column: parts[4] ? +parts[4] : undefined,\n    func: parts[1] || UNKNOWN_FUNCTION,\n    line: +parts[3],\n    url: parts[2],\n  }\n}\n\nconst GECKO_LINE_RE =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:(?:(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle|\\[wasm code\\])(?::(\\d+))?(?::(\\d+))?)|@)\\s*$/i\nconst GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i\n\nfunction parseGeckoLine(line: string): StackFrame | undefined {\n  const parts = GECKO_LINE_RE.exec(line)\n  if (!parts) {\n    return\n  }\n\n  const isEval = parts[3] && parts[3].indexOf(' > eval') > -1\n  const submatch = GECKO_EVAL_RE.exec(parts[3])\n\n  if (isEval && submatch) {\n    // throw out eval line/column and use top-most line number\n    parts[3] = submatch[1]\n    parts[4] = submatch[2]\n    parts[5] = undefined! // no column when eval\n  }\n\n  return {\n    args: parts[2] ? parts[2].split(',') : [],\n    column: parts[5] ? +parts[5] : undefined,\n    func: parts[1] || UNKNOWN_FUNCTION,\n    line: parts[4] ? +parts[4] : undefined,\n    url: parts[3],\n  }\n}\n\nfunction tryToGetString(candidate: unknown, property: string) {\n  return isIndexableObject(candidate) && typeof candidate[property] === 'string' ? candidate[property] : undefined\n}\n\nexport function computeStackTraceFromOnErrorMessage(\n  messageObj: unknown,\n  url?: string,\n  line?: number,\n  column?: number\n): StackTrace | undefined {\n  if (url === undefined) {\n    return\n  }\n  const { name, message } = tryToParseMessage(messageObj)\n  return {\n    name,\n    message,\n    stack: [{ url, column, line }],\n  }\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nconst ERROR_TYPES_RE =\n  /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\\s\\S]*)$/\n\nfunction tryToParseMessage(messageObj: unknown) {\n  let name\n  let message\n  if ({}.toString.call(messageObj) === '[object String]') {\n    ;[, name, message] = ERROR_TYPES_RE.exec(messageObj as string)!\n  }\n  return { name, message }\n}\n\n// Custom error stacktrace fix\n// Some browsers (safari/firefox) add the error constructor as a frame in the stacktrace\n// In order to normalize the stacktrace, we need to remove it\n\nfunction isNonNativeClassPrototype(prototype: object) {\n  return String(prototype.constructor).startsWith('class ')\n}\n\nlet isWronglyReportingCustomErrorsCache: boolean | undefined\n\nfunction isWronglyReportingCustomErrors() {\n  if (isWronglyReportingCustomErrorsCache !== undefined) {\n    return isWronglyReportingCustomErrorsCache\n  }\n\n  /* eslint-disable no-restricted-syntax */\n  class DatadogTestCustomError extends Error {\n    constructor() {\n      super()\n      this.name = 'Error' // set name to Error so that no browser would default to the constructor name\n    }\n  }\n\n  const [customError, nativeError] = [DatadogTestCustomError, Error].map((errConstructor) => new errConstructor()) // so that both errors should exactly have the same stacktrace\n\n  isWronglyReportingCustomErrorsCache =\n    // If customError is not a class, it means that this was built with ES5 as target, converting the class to a normal object.\n    // Thus, error constructors will be reported on all browsers, which is the expected behavior.\n    isNonNativeClassPrototype(Object.getPrototypeOf(customError)) &&\n    // If the browser is correctly reporting the stacktrace, the normal error stacktrace should be the same as the custom error stacktrace\n    nativeError.stack !== customError.stack\n\n  return isWronglyReportingCustomErrorsCache\n}\n"],"mappings":"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"}

package/esm/tools/stackTrace/handlingStack.mjs

@@ -0,0 +1,45 @@
+import { callMonitored } from "../monitor.mjs";
+import { computeStackTrace } from "./computeStackTrace.mjs";
+//#region src/tools/stackTrace/handlingStack.ts
+/**
+* Creates a stacktrace without SDK internal frames.
+* Constraints:
+* - Has to be called at the utmost position of the call stack.
+* - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.
+*/
+function createHandlingStack(type) {
+	/**
+	* Skip the two internal frames:
+	* - SDK API (console.error, ...)
+	* - this function
+	* in order to keep only the user calls
+	*/
+	const internalFramesToSkip = 2;
+	const error = new Error(type);
+	error.name = "HandlingStack";
+	let formattedStack;
+	callMonitored(() => {
+		const stackTrace = computeStackTrace(error);
+		stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);
+		formattedStack = toStackTraceString(stackTrace);
+	});
+	return formattedStack;
+}
+function toStackTraceString(stack) {
+	let result = formatErrorMessage(stack);
+	stack.stack.forEach((frame) => {
+		const func = frame.func === "?" ? "<anonymous>" : frame.func;
+		const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(", ")})` : "";
+		const line = frame.line ? `:${frame.line}` : "";
+		const column = frame.line && frame.column ? `:${frame.column}` : "";
+		result += `\n  at ${func}${args} @ ${frame.url}${line}${column}`;
+	});
+	return result;
+}
+function formatErrorMessage(stack) {
+	return `${stack.name || "Error"}: ${stack.message}`;
+}
+//#endregion
+export { createHandlingStack, formatErrorMessage, toStackTraceString };
+
+//# sourceMappingURL=handlingStack.mjs.map

package/esm/tools/stackTrace/handlingStack.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlingStack.mjs","names":[],"sources":["../../../src/tools/stackTrace/handlingStack.ts"],"sourcesContent":["import { callMonitored } from '../monitor'\nimport type { StackTrace } from './computeStackTrace'\nimport { computeStackTrace } from './computeStackTrace'\n\n/**\n * Creates a stacktrace without SDK internal frames.\n * Constraints:\n * - Has to be called at the utmost position of the call stack.\n * - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.\n */\nexport function createHandlingStack(\n  type:\n    | 'console error'\n    | 'action'\n    | 'error'\n    | 'instrumented method'\n    | 'instrumented constructor'\n    | 'log'\n    | 'nuxt error'\n    | 'react error'\n    | 'nextjs error'\n    | 'vue error'\n    | 'angular error'\n    | 'view'\n    | 'vital'\n): string {\n  /**\n   * Skip the two internal frames:\n   * - SDK API (console.error, ...)\n   * - this function\n   * in order to keep only the user calls\n   */\n  const internalFramesToSkip = 2\n  const error = new Error(type)\n  error.name = 'HandlingStack'\n  let formattedStack: string\n\n  callMonitored(() => {\n    const stackTrace = computeStackTrace(error)\n    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)\n    formattedStack = toStackTraceString(stackTrace)\n  })\n\n  return formattedStack!\n}\n\nexport function toStackTraceString(stack: StackTrace) {\n  let result = formatErrorMessage(stack)\n  stack.stack.forEach((frame) => {\n    const func = frame.func === '?' ? '<anonymous>' : frame.func\n    const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(', ')})` : ''\n    const line = frame.line ? `:${frame.line}` : ''\n    const column = frame.line && frame.column ? `:${frame.column}` : ''\n    result += `\\n  at ${func!}${args} @ ${frame.url!}${line}${column}`\n  })\n  return result\n}\n\nexport function formatErrorMessage(stack: StackTrace) {\n  return `${stack.name || 'Error'}: ${stack.message!}`\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,oBACd,MAcQ;;;;;;;CAOR,MAAM,uBAAuB;CAC7B,MAAM,QAAQ,IAAI,MAAM,IAAI;CAC5B,MAAM,OAAO;CACb,IAAI;CAEJ,oBAAoB;EAClB,MAAM,aAAa,kBAAkB,KAAK;EAC1C,WAAW,QAAQ,WAAW,MAAM,MAAM,oBAAoB;EAC9D,iBAAiB,mBAAmB,UAAU;CAChD,CAAC;CAED,OAAO;AACT;AAEA,SAAgB,mBAAmB,OAAmB;CACpD,IAAI,SAAS,mBAAmB,KAAK;CACrC,MAAM,MAAM,SAAS,UAAU;EAC7B,MAAM,OAAO,MAAM,SAAS,MAAM,gBAAgB,MAAM;EACxD,MAAM,OAAO,MAAM,QAAQ,MAAM,KAAK,SAAS,IAAI,IAAI,MAAM,KAAK,KAAK,IAAI,EAAE,KAAK;EAClF,MAAM,OAAO,MAAM,OAAO,IAAI,MAAM,SAAS;EAC7C,MAAM,SAAS,MAAM,QAAQ,MAAM,SAAS,IAAI,MAAM,WAAW;EACjE,UAAU,UAAU,OAAQ,KAAK,KAAK,MAAM,MAAO,OAAO;CAC5D,CAAC;CACD,OAAO;AACT;AAEA,SAAgB,mBAAmB,OAAmB;CACpD,OAAO,GAAG,MAAM,QAAQ,QAAQ,IAAI,MAAM;AAC5C"}

package/esm/tools/taskQueue.mjs

@@ -0,0 +1,45 @@
+import { requestIdleCallback } from "./requestIdleCallback.mjs";
+import { ONE_SECOND } from "@openobserve/js-core/time";
+//#region src/tools/taskQueue.ts
+/**
+* Maximum delay before starting to execute tasks in the queue. We don't want to wait too long
+* before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose
+* the opportunity to send some data). We also don't want to run tasks too often, as it might hurt
+* performance.
+*/
+const IDLE_CALLBACK_TIMEOUT = ONE_SECOND;
+/**
+* Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is
+* reached. We should not run tasks for too long as it will hurt performance, but we should still
+* run some tasks to avoid postponing them forever.
+*
+* Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.
+*/
+const MAX_EXECUTION_TIME_ON_TIMEOUT = 30;
+function createTaskQueue() {
+	const pendingTasks = [];
+	function run(deadline) {
+		let executionTimeRemaining;
+		if (!deadline || deadline.didTimeout) {
+			const start = performance.now();
+			executionTimeRemaining = () => 30 - (performance.now() - start);
+		} else executionTimeRemaining = deadline.timeRemaining.bind(deadline);
+		while (executionTimeRemaining() > 0 && pendingTasks.length) pendingTasks.shift()();
+		if (pendingTasks.length) scheduleNextRun();
+	}
+	function scheduleNextRun() {
+		requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT });
+	}
+	return {
+		push(task) {
+			if (pendingTasks.push(task) === 1) scheduleNextRun();
+		},
+		stop() {
+			pendingTasks.length = 0;
+		}
+	};
+}
+//#endregion
+export { MAX_EXECUTION_TIME_ON_TIMEOUT, createTaskQueue };
+
+//# sourceMappingURL=taskQueue.mjs.map

package/esm/tools/taskQueue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskQueue.mjs","names":[],"sources":["../../src/tools/taskQueue.ts"],"sourcesContent":["import { ONE_SECOND } from '@openobserve/js-core/time'\nimport { requestIdleCallback } from './requestIdleCallback'\n\n/**\n * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long\n * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose\n * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt\n * performance.\n */\nconst IDLE_CALLBACK_TIMEOUT = ONE_SECOND\n\n/**\n * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is\n * reached. We should not run tasks for too long as it will hurt performance, but we should still\n * run some tasks to avoid postponing them forever.\n *\n * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.\n */\nexport const MAX_EXECUTION_TIME_ON_TIMEOUT = 30\n\nexport interface TaskQueue {\n  push(task: Task): void\n  stop(): void\n}\n\ntype Task = () => void\n\nexport function createTaskQueue(): TaskQueue {\n  const pendingTasks: Task[] = []\n\n  function run(deadline: IdleDeadline | null) {\n    let executionTimeRemaining: () => number\n    // `deadline` can be null when `requestIdleCallback` is replaced by a page-injected polyfill\n    // (e.g. `setTimeout(cb, 0)` in some WKWebViews) that invokes the callback with no argument.\n    if (!deadline || deadline.didTimeout) {\n      const start = performance.now()\n      executionTimeRemaining = () => MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start)\n    } else {\n      executionTimeRemaining = deadline.timeRemaining.bind(deadline)\n    }\n\n    while (executionTimeRemaining() > 0 && pendingTasks.length) {\n      pendingTasks.shift()!()\n    }\n\n    if (pendingTasks.length) {\n      scheduleNextRun()\n    }\n  }\n\n  function scheduleNextRun() {\n    requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT })\n  }\n\n  return {\n    push(task) {\n      if (pendingTasks.push(task) === 1) {\n        scheduleNextRun()\n      }\n    },\n    stop() {\n      pendingTasks.length = 0\n    },\n  }\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,wBAAwB;;;;;;;;AAS9B,MAAa,gCAAgC;AAS7C,SAAgB,kBAA6B;CAC3C,MAAM,eAAuB,CAAC;CAE9B,SAAS,IAAI,UAA+B;EAC1C,IAAI;EAGJ,IAAI,CAAC,YAAY,SAAS,YAAY;GACpC,MAAM,QAAQ,YAAY,IAAI;GAC9B,+BAAA,MAAgE,YAAY,IAAI,IAAI;EACtF,OACE,yBAAyB,SAAS,cAAc,KAAK,QAAQ;EAG/D,OAAO,uBAAuB,IAAI,KAAK,aAAa,QAClD,aAAa,MAAM,CAAC,CAAE;EAGxB,IAAI,aAAa,QACf,gBAAgB;CAEpB;CAEA,SAAS,kBAAkB;EACzB,oBAAoB,KAAK,EAAE,SAAS,sBAAsB,CAAC;CAC7D;CAEA,OAAO;EACL,KAAK,MAAM;GACT,IAAI,aAAa,KAAK,IAAI,MAAM,GAC9B,gBAAgB;EAEpB;EACA,OAAO;GACL,aAAa,SAAS;EACxB;CACF;AACF"}

package/esm/tools/timer.mjs

@@ -0,0 +1,20 @@
+import { globalObject } from "./globalObject.mjs";
+import { monitor } from "./monitor.mjs";
+import { getZoneJsOriginalValue } from "./getZoneJsOriginalValue.mjs";
+//#region src/tools/timer.ts
+function setTimeout(callback, delay) {
+	return getZoneJsOriginalValue(globalObject, "setTimeout")(monitor(callback), delay);
+}
+function clearTimeout(timeoutId) {
+	getZoneJsOriginalValue(globalObject, "clearTimeout")(timeoutId);
+}
+function setInterval(callback, delay) {
+	return getZoneJsOriginalValue(globalObject, "setInterval")(monitor(callback), delay);
+}
+function clearInterval(timeoutId) {
+	getZoneJsOriginalValue(globalObject, "clearInterval")(timeoutId);
+}
+//#endregion
+export { clearInterval, clearTimeout, setInterval, setTimeout };
+
+//# sourceMappingURL=timer.mjs.map

package/esm/tools/timer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.mjs","names":[],"sources":["../../src/tools/timer.ts"],"sourcesContent":["import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'\nimport { monitor } from './monitor'\nimport type { GlobalObject } from './globalObject'\nimport { globalObject } from './globalObject'\n\nexport type TimeoutId = ReturnType<GlobalObject['setTimeout']>\n\nexport function setTimeout(callback: () => void, delay?: number): TimeoutId {\n  return getZoneJsOriginalValue(globalObject, 'setTimeout')(monitor(callback), delay)\n}\n\nexport function clearTimeout(timeoutId: TimeoutId | undefined) {\n  getZoneJsOriginalValue(globalObject, 'clearTimeout')(timeoutId)\n}\n\nexport function setInterval(callback: () => void, delay?: number): TimeoutId {\n  return getZoneJsOriginalValue(globalObject, 'setInterval')(monitor(callback), delay)\n}\n\nexport function clearInterval(timeoutId: TimeoutId | undefined) {\n  getZoneJsOriginalValue(globalObject, 'clearInterval')(timeoutId)\n}\n"],"mappings":";;;;AAOA,SAAgB,WAAW,UAAsB,OAA2B;CAC1E,OAAO,uBAAuB,cAAc,YAAY,CAAC,CAAC,QAAQ,QAAQ,GAAG,KAAK;AACpF;AAEA,SAAgB,aAAa,WAAkC;CAC7D,uBAAuB,cAAc,cAAc,CAAC,CAAC,SAAS;AAChE;AAEA,SAAgB,YAAY,UAAsB,OAA2B;CAC3E,OAAO,uBAAuB,cAAc,aAAa,CAAC,CAAC,QAAQ,QAAQ,GAAG,KAAK;AACrF;AAEA,SAAgB,cAAc,WAAkC;CAC9D,uBAAuB,cAAc,eAAe,CAAC,CAAC,SAAS;AACjE"}

package/esm/tools/utils/arrayUtils.mjs

@@ -0,0 +1,21 @@
+//#region src/tools/utils/arrayUtils.ts
+function removeDuplicates(array) {
+	const set = /* @__PURE__ */ new Set();
+	array.forEach((item) => set.add(item));
+	return Array.from(set);
+}
+function removeItem(array, item) {
+	const index = array.indexOf(item);
+	if (index >= 0) array.splice(index, 1);
+}
+function isNonEmptyArray(value) {
+	return Array.isArray(value) && value.length > 0;
+}
+function mergeArrays(current, next) {
+	if (!next?.length) return current;
+	return current ? current.concat(next) : next;
+}
+//#endregion
+export { isNonEmptyArray, mergeArrays, removeDuplicates, removeItem };
+
+//# sourceMappingURL=arrayUtils.mjs.map

package/esm/tools/utils/arrayUtils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayUtils.mjs","names":[],"sources":["../../../src/tools/utils/arrayUtils.ts"],"sourcesContent":["export function removeDuplicates<T>(array: T[]) {\n  const set = new Set<T>()\n  array.forEach((item) => set.add(item))\n  return Array.from(set)\n}\n\nexport function removeItem<T>(array: T[], item: T) {\n  const index = array.indexOf(item)\n  if (index >= 0) {\n    array.splice(index, 1)\n  }\n}\nexport function isNonEmptyArray<T>(value: unknown): value is T[] {\n  return Array.isArray(value) && value.length > 0\n}\n\nexport function mergeArrays<T>(current: T[] | undefined, next: T[] | undefined): T[] | undefined {\n  if (!next?.length) {\n    return current\n  }\n  return current ? current.concat(next) : next\n}\n"],"mappings":";AAAA,SAAgB,iBAAoB,OAAY;CAC9C,MAAM,sBAAM,IAAI,IAAO;CACvB,MAAM,SAAS,SAAS,IAAI,IAAI,IAAI,CAAC;CACrC,OAAO,MAAM,KAAK,GAAG;AACvB;AAEA,SAAgB,WAAc,OAAY,MAAS;CACjD,MAAM,QAAQ,MAAM,QAAQ,IAAI;CAChC,IAAI,SAAS,GACX,MAAM,OAAO,OAAO,CAAC;AAEzB;AACA,SAAgB,gBAAmB,OAA8B;CAC/D,OAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS;AAChD;AAEA,SAAgB,YAAe,SAA0B,MAAwC;CAC/F,IAAI,CAAC,MAAM,QACT,OAAO;CAET,OAAO,UAAU,QAAQ,OAAO,IAAI,IAAI;AAC1C"}

package/esm/tools/utils/browserDetection.mjs

@@ -0,0 +1,31 @@
+//#region src/tools/utils/browserDetection.ts
+let Browser = /* @__PURE__ */ function(Browser) {
+	Browser[Browser["CHROMIUM"] = 0] = "CHROMIUM";
+	Browser[Browser["SAFARI"] = 1] = "SAFARI";
+	Browser[Browser["OTHER"] = 2] = "OTHER";
+	return Browser;
+}({});
+function isChromium() {
+	return detectBrowserCached() === 0;
+}
+function isSafari() {
+	return detectBrowserCached() === 1;
+}
+let browserCache;
+function detectBrowserCached() {
+	return browserCache ?? (browserCache = detectBrowser());
+}
+function detectBrowser(browserWindow = window) {
+	const userAgent = browserWindow.navigator.userAgent;
+	if (browserWindow.chrome || /HeadlessChrome/.test(userAgent)) return 0;
+	if (browserWindow.navigator.vendor?.indexOf("Apple") === 0 || /safari/i.test(userAgent) && !/chrome|android/i.test(userAgent)) return 1;
+	return 2;
+}
+function detectVersion() {
+	const match = window.navigator.userAgent.match(/(?:chrome|headlesschrome|version)\/(\d+)/i);
+	if (match) return parseInt(match[1], 10);
+}
+//#endregion
+export { Browser, detectBrowser, detectVersion, isChromium, isSafari };
+
+//# sourceMappingURL=browserDetection.mjs.map

package/esm/tools/utils/browserDetection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserDetection.mjs","names":[],"sources":["../../../src/tools/utils/browserDetection.ts"],"sourcesContent":["// Exported only for tests\nexport const enum Browser {\n  CHROMIUM,\n  SAFARI,\n  OTHER,\n}\n\nexport function isChromium() {\n  return detectBrowserCached() === Browser.CHROMIUM\n}\n\nexport function isSafari() {\n  return detectBrowserCached() === Browser.SAFARI\n}\n\nlet browserCache: Browser | undefined\nfunction detectBrowserCached() {\n  return browserCache ?? (browserCache = detectBrowser())\n}\n\n// Exported only for tests\nexport function detectBrowser(browserWindow: Window = window) {\n  const userAgent = browserWindow.navigator.userAgent\n  if ((browserWindow as any).chrome || /HeadlessChrome/.test(userAgent)) {\n    return Browser.CHROMIUM\n  }\n\n  if (\n    // navigator.vendor is deprecated, but it is the most resilient way we found to detect\n    // \"Apple maintained browsers\" (AKA Safari). If one day it gets removed, we still have the\n    // useragent test as a semi-working fallback.\n    browserWindow.navigator.vendor?.indexOf('Apple') === 0 ||\n    (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent))\n  ) {\n    return Browser.SAFARI\n  }\n\n  return Browser.OTHER\n}\n\nexport function detectVersion() {\n  const userAgent = window.navigator.userAgent\n  const match = userAgent.match(/(?:chrome|headlesschrome|version)\\/(\\d+)/i)\n  if (match) {\n    return parseInt(match[1], 10)\n  }\n}\n"],"mappings":";AACA,IAAkB,UAAX,yBAAA,SAAA;CACL,QAAA,QAAA,cAAA,KAAA;CACA,QAAA,QAAA,YAAA,KAAA;CACA,QAAA,QAAA,WAAA,KAAA;;AACF,EAAA,CAAA,CAAA;AAEA,SAAgB,aAAa;CAC3B,OAAO,oBAAoB,MAAA;AAC7B;AAEA,SAAgB,WAAW;CACzB,OAAO,oBAAoB,MAAA;AAC7B;AAEA,IAAI;AACJ,SAAS,sBAAsB;CAC7B,OAAO,iBAAiB,eAAe,cAAc;AACvD;AAGA,SAAgB,cAAc,gBAAwB,QAAQ;CAC5D,MAAM,YAAY,cAAc,UAAU;CAC1C,IAAK,cAAsB,UAAU,iBAAiB,KAAK,SAAS,GAClE,OAAA;CAGF,IAIE,cAAc,UAAU,QAAQ,QAAQ,OAAO,MAAM,KACpD,UAAU,KAAK,SAAS,KAAK,CAAC,kBAAkB,KAAK,SAAS,GAE/D,OAAA;CAGF,OAAA;AACF;AAEA,SAAgB,gBAAgB;CAE9B,MAAM,QADY,OAAO,UAAU,UACX,MAAM,2CAA2C;CACzE,IAAI,OACF,OAAO,SAAS,MAAM,IAAI,EAAE;AAEhC"}

package/esm/tools/utils/byteUtils.mjs

@@ -0,0 +1,23 @@
+//#region src/tools/utils/byteUtils.ts
+const ONE_KIBI_BYTE = 1024;
+const ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE;
+const HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/;
+function computeBytesCount(candidate) {
+	if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) return candidate.length;
+	return new TextEncoder().encode(candidate).length;
+}
+function concatBuffers(buffers) {
+	if (buffers.length === 1) return buffers[0];
+	const length = buffers.reduce((total, buffer) => total + buffer.length, 0);
+	const result = new Uint8Array(length);
+	let offset = 0;
+	for (const buffer of buffers) {
+		result.set(buffer, offset);
+		offset += buffer.length;
+	}
+	return result;
+}
+//#endregion
+export { ONE_KIBI_BYTE, ONE_MEBI_BYTE, computeBytesCount, concatBuffers };
+
+//# sourceMappingURL=byteUtils.mjs.map

package/esm/tools/utils/byteUtils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"byteUtils.mjs","names":[],"sources":["../../../src/tools/utils/byteUtils.ts"],"sourcesContent":["export const ONE_KIBI_BYTE = 1024\nexport const ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE\n\n// eslint-disable-next-line no-control-regex\nconst HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/\n\nexport interface Uint8ArrayBuffer extends Uint8Array {\n  readonly buffer: ArrayBuffer\n\n  subarray(begin?: number, end?: number): Uint8ArrayBuffer\n}\n\nexport function computeBytesCount(candidate: string): number {\n  // Accurate bytes count computations can degrade performances when there is a lot of events to process\n  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {\n    return candidate.length\n  }\n\n  return new TextEncoder().encode(candidate).length\n}\n\nexport function concatBuffers(buffers: Uint8ArrayBuffer[]): Uint8ArrayBuffer {\n  // Optimization: if there is a single buffer, no need to copy it\n  if (buffers.length === 1) {\n    return buffers[0]\n  }\n\n  const length = buffers.reduce((total, buffer) => total + buffer.length, 0)\n  const result: Uint8ArrayBuffer = new Uint8Array(length)\n  let offset = 0\n  for (const buffer of buffers) {\n    result.set(buffer, offset)\n    offset += buffer.length\n  }\n  return result\n}\n"],"mappings":";AAAA,MAAa,gBAAgB;AAC7B,MAAa,gBAAgB,OAAO;AAGpC,MAAM,6BAA6B;AAQnC,SAAgB,kBAAkB,WAA2B;CAE3D,IAAI,CAAC,2BAA2B,KAAK,SAAS,GAC5C,OAAO,UAAU;CAGnB,OAAO,IAAI,YAAY,CAAC,CAAC,OAAO,SAAS,CAAC,CAAC;AAC7C;AAEA,SAAgB,cAAc,SAA+C;CAE3E,IAAI,QAAQ,WAAW,GACrB,OAAO,QAAQ;CAGjB,MAAM,SAAS,QAAQ,QAAQ,OAAO,WAAW,QAAQ,OAAO,QAAQ,CAAC;CACzE,MAAM,SAA2B,IAAI,WAAW,MAAM;CACtD,IAAI,SAAS;CACb,KAAK,MAAM,UAAU,SAAS;EAC5B,OAAO,IAAI,QAAQ,MAAM;EACzB,UAAU,OAAO;CACnB;CACA,OAAO;AACT"}

package/esm/tools/utils/functionUtils.mjs

@@ -0,0 +1,35 @@
+import { clearTimeout, setTimeout } from "../timer.mjs";
+//#region src/tools/utils/functionUtils.ts
+function throttle(fn, wait, options) {
+	const needLeadingExecution = options?.leading !== void 0 ? options.leading : true;
+	const needTrailingExecution = options?.trailing !== void 0 ? options.trailing : true;
+	let inWaitPeriod = false;
+	let pendingExecutionWithParameters;
+	let pendingTimeoutId;
+	return {
+		throttled: (...parameters) => {
+			if (inWaitPeriod) {
+				pendingExecutionWithParameters = parameters;
+				return;
+			}
+			if (needLeadingExecution) fn(...parameters);
+			else pendingExecutionWithParameters = parameters;
+			inWaitPeriod = true;
+			pendingTimeoutId = setTimeout(() => {
+				if (needTrailingExecution && pendingExecutionWithParameters) fn(...pendingExecutionWithParameters);
+				inWaitPeriod = false;
+				pendingExecutionWithParameters = void 0;
+			}, wait);
+		},
+		cancel: () => {
+			clearTimeout(pendingTimeoutId);
+			inWaitPeriod = false;
+			pendingExecutionWithParameters = void 0;
+		}
+	};
+}
+function noop() {}
+//#endregion
+export { noop, throttle };
+
+//# sourceMappingURL=functionUtils.mjs.map