@pratham.raval/browser-core 6.22.3

package/esm/tools/observable.d.ts

@@ -0,0 +1,30 @@
+export interface Subscription {
+    unsubscribe: () => void;
+}
+type Observer<T> = (data: T) => void;
+export declare class Observable<T> {
+    private onFirstSubscribe?;
+    protected observers: Array<Observer<T>>;
+    private onLastUnsubscribe?;
+    constructor(onFirstSubscribe?: ((observable: Observable<T>) => (() => void) | void) | undefined);
+    subscribe(observer: Observer<T>): Subscription;
+    notify(data: T): void;
+    protected addObserver(observer: Observer<T>): void;
+    protected removeObserver(observer: Observer<T>): void;
+}
+export declare function mergeObservables<T>(...observables: Array<Observable<T>>): Observable<T>;
+export declare class BufferedObservable<T> extends Observable<T> {
+    private maxBufferSize;
+    private buffer;
+    constructor(maxBufferSize: number);
+    notify(data: T): void;
+    subscribe(observer: Observer<T>): Subscription;
+    /**
+     * Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not
+     * needed anymore. This can be seen as a performance optimization, and things will work probably
+     * even if this method isn't called, but still useful to clarify our intent and lowering our
+     * memory impact.
+     */
+    unbuffer(): void;
+}
+export {};

package/esm/tools/observable.js

@@ -0,0 +1,83 @@
+import { queueMicrotask } from './queueMicrotask';
+// eslint-disable-next-line no-restricted-syntax
+export class Observable {
+    constructor(onFirstSubscribe) {
+        this.onFirstSubscribe = onFirstSubscribe;
+        this.observers = [];
+    }
+    subscribe(observer) {
+        this.addObserver(observer);
+        return {
+            unsubscribe: () => this.removeObserver(observer),
+        };
+    }
+    notify(data) {
+        this.observers.forEach((observer) => observer(data));
+    }
+    addObserver(observer) {
+        this.observers.push(observer);
+        if (this.observers.length === 1 && this.onFirstSubscribe) {
+            this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined;
+        }
+    }
+    removeObserver(observer) {
+        this.observers = this.observers.filter((other) => observer !== other);
+        if (!this.observers.length && this.onLastUnsubscribe) {
+            this.onLastUnsubscribe();
+        }
+    }
+}
+export function mergeObservables(...observables) {
+    return new Observable((globalObservable) => {
+        const subscriptions = observables.map((observable) => observable.subscribe((data) => globalObservable.notify(data)));
+        return () => subscriptions.forEach((subscription) => subscription.unsubscribe());
+    });
+}
+// eslint-disable-next-line no-restricted-syntax
+export class BufferedObservable extends Observable {
+    constructor(maxBufferSize) {
+        super();
+        this.maxBufferSize = maxBufferSize;
+        this.buffer = [];
+    }
+    notify(data) {
+        this.buffer.push(data);
+        if (this.buffer.length > this.maxBufferSize) {
+            this.buffer.shift();
+        }
+        super.notify(data);
+    }
+    subscribe(observer) {
+        let closed = false;
+        const subscription = {
+            unsubscribe: () => {
+                closed = true;
+                this.removeObserver(observer);
+            },
+        };
+        queueMicrotask(() => {
+            for (const data of this.buffer) {
+                if (closed) {
+                    return;
+                }
+                observer(data);
+            }
+            if (!closed) {
+                this.addObserver(observer);
+            }
+        });
+        return subscription;
+    }
+    /**
+     * Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not
+     * needed anymore. This can be seen as a performance optimization, and things will work probably
+     * even if this method isn't called, but still useful to clarify our intent and lowering our
+     * memory impact.
+     */
+    unbuffer() {
+        queueMicrotask(() => {
+            this.maxBufferSize = this.buffer.length = 0;
+        });
+    }
+}
+//# sourceMappingURL=observable.js.map

package/esm/tools/observable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.js","sourceRoot":"","sources":["../../src/tools/observable.ts"],"names":[],"mappings":"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"}

package/esm/tools/queueMicrotask.d.ts

@@ -0,0 +1 @@
+export declare function queueMicrotask(callback: () => void): void;

package/esm/tools/queueMicrotask.js

@@ -0,0 +1,14 @@
+import { monitor } from './monitor';
+import { globalObject } from './globalObject';
+export function queueMicrotask(callback) {
+    var _a;
+    const nativeImplementation = (_a = globalObject.queueMicrotask) === null || _a === void 0 ? void 0 : _a.bind(globalObject);
+    if (typeof nativeImplementation === 'function') {
+        nativeImplementation(monitor(callback));
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises -- the callback is monitored, so it'll never throw
+        Promise.resolve().then(monitor(callback));
+    }
+}
+//# sourceMappingURL=queueMicrotask.js.map

package/esm/tools/queueMicrotask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queueMicrotask.js","sourceRoot":"","sources":["../../src/tools/queueMicrotask.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,MAAM,UAAU,cAAc,CAAC,QAAoB;;IACjD,MAAM,oBAAoB,GAAG,MAAA,YAAY,CAAC,cAAc,0CAAE,IAAI,CAAC,YAAY,CAAC,CAAA;IAE5E,IAAI,OAAO,oBAAoB,KAAK,UAAU,EAAE,CAAC;QAC/C,oBAAoB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAA;IACzC,CAAC;SAAM,CAAC;QACN,sHAAsH;QACtH,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC3C,CAAC;AACH,CAAC"}

package/esm/tools/readBytesFromStream.d.ts

@@ -0,0 +1,11 @@
+interface Options {
+    bytesLimit: number;
+    collectStreamBody?: boolean;
+}
+/**
+ * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
+ * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
+ * has been exceeded if more bytes were available.
+ */
+export declare function readBytesFromStream(stream: ReadableStream<Uint8Array>, callback: (error?: Error, bytes?: Uint8Array, limitExceeded?: boolean) => void, options: Options): void;
+export {};

package/esm/tools/readBytesFromStream.js

@@ -0,0 +1,60 @@
+import { monitor } from './monitor';
+import { noop } from './utils/functionUtils';
+/**
+ * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
+ * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
+ * has been exceeded if more bytes were available.
+ */
+export function readBytesFromStream(stream, callback, options) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let readBytesCount = 0;
+    readMore();
+    function readMore() {
+        reader.read().then(monitor((result) => {
+            if (result.done) {
+                onDone();
+                return;
+            }
+            if (options.collectStreamBody) {
+                chunks.push(result.value);
+            }
+            readBytesCount += result.value.length;
+            if (readBytesCount > options.bytesLimit) {
+                onDone();
+            }
+            else {
+                readMore();
+            }
+        }), monitor((error) => callback(error)));
+    }
+    function onDone() {
+        reader.cancel().catch(
+        // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+        // as an unhandled rejection
+        noop);
+        let bytes;
+        let limitExceeded;
+        if (options.collectStreamBody) {
+            let completeBuffer;
+            if (chunks.length === 1) {
+                // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just
+                // use it directly.
+                completeBuffer = chunks[0];
+            }
+            else {
+                // else, we need to copy buffers into a larger buffer to concatenate them.
+                completeBuffer = new Uint8Array(readBytesCount);
+                let offset = 0;
+                chunks.forEach((chunk) => {
+                    completeBuffer.set(chunk, offset);
+                    offset += chunk.length;
+                });
+            }
+            bytes = completeBuffer.slice(0, options.bytesLimit);
+            limitExceeded = completeBuffer.length > options.bytesLimit;
+        }
+        callback(undefined, bytes, limitExceeded);
+    }
+}
+//# sourceMappingURL=readBytesFromStream.js.map

package/esm/tools/readBytesFromStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readBytesFromStream.js","sourceRoot":"","sources":["../../src/tools/readBytesFromStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAA;AAM5C;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAkC,EAClC,QAA8E,EAC9E,OAAgB;IAEhB,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAA;IACjC,MAAM,MAAM,GAAiB,EAAE,CAAA;IAC/B,IAAI,cAAc,GAAG,CAAC,CAAA;IAEtB,QAAQ,EAAE,CAAA;IAEV,SAAS,QAAQ;QACf,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,CAChB,OAAO,CAAC,CAAC,MAA4C,EAAE,EAAE;YACvD,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBAChB,MAAM,EAAE,CAAA;gBACR,OAAM;YACR,CAAC;YAED,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;gBAC9B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YAC3B,CAAC;YACD,cAAc,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAA;YAErC,IAAI,cAAc,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;gBACxC,MAAM,EAAE,CAAA;YACV,CAAC;iBAAM,CAAC;gBACN,QAAQ,EAAE,CAAA;YACZ,CAAC;QACH,CAAC,CAAC,EACF,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CACpC,CAAA;IACH,CAAC;IAED,SAAS,MAAM;QACb,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK;QACnB,4FAA4F;QAC5F,4BAA4B;QAC5B,IAAI,CACL,CAAA;QAED,IAAI,KAA6B,CAAA;QACjC,IAAI,aAAkC,CAAA;QACtC,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;YAC9B,IAAI,cAA0B,CAAA;YAC9B,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACxB,0GAA0G;gBAC1G,mBAAmB;gBACnB,cAAc,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;YAC5B,CAAC;iBAAM,CAAC;gBACN,0EAA0E;gBAC1E,cAAc,GAAG,IAAI,UAAU,CAAC,cAAc,CAAC,CAAA;gBAC/C,IAAI,MAAM,GAAG,CAAC,CAAA;gBACd,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;oBACvB,cAAc,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;oBACjC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAA;gBACxB,CAAC,CAAC,CAAA;YACJ,CAAC;YACD,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;YACnD,aAAa,GAAG,cAAc,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,CAAA;QAC5D,CAAC;QAED,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,aAAa,CAAC,CAAA;IAC3C,CAAC;AACH,CAAC"}

package/esm/tools/requestIdleCallback.d.ts

@@ -0,0 +1,12 @@
+export interface IdleDeadline {
+    readonly didTimeout: boolean;
+    timeRemaining(): DOMHighResTimeStamp;
+}
+/**
+ * 'requestIdleCallback' with a shim.
+ */
+export declare function requestIdleCallback(callback: (deadline: IdleDeadline) => void, opts?: {
+    timeout?: number;
+}): () => void;
+export declare const MAX_TASK_TIME = 50;
+export declare function requestIdleCallbackShim(callback: (deadline: IdleDeadline) => void): () => void;

package/esm/tools/requestIdleCallback.js

@@ -0,0 +1,30 @@
+import { setTimeout, clearTimeout } from './timer';
+import { monitor } from './monitor';
+import { dateNow } from './utils/timeUtils';
+/**
+ * 'requestIdleCallback' with a shim.
+ */
+export function requestIdleCallback(callback, opts) {
+    // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.
+    if (window.requestIdleCallback && window.cancelIdleCallback) {
+        const id = window.requestIdleCallback(monitor(callback), opts);
+        return () => window.cancelIdleCallback(id);
+    }
+    return requestIdleCallbackShim(callback);
+}
+export const MAX_TASK_TIME = 50;
+/*
+ * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback
+ * Note: there is no simple way to support the "timeout" option, so we ignore it.
+ */
+export function requestIdleCallbackShim(callback) {
+    const start = dateNow();
+    const timeoutId = setTimeout(() => {
+        callback({
+            didTimeout: false,
+            timeRemaining: () => Math.max(0, MAX_TASK_TIME - (dateNow() - start)),
+        });
+    }, 0);
+    return () => clearTimeout(timeoutId);
+}
+//# sourceMappingURL=requestIdleCallback.js.map

package/esm/tools/requestIdleCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestIdleCallback.js","sourceRoot":"","sources":["../../src/tools/requestIdleCallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAU3C;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAA0C,EAAE,IAA2B;IACzG,yIAAyI;IACzI,IAAI,MAAM,CAAC,mBAAmB,IAAI,MAAM,CAAC,kBAAkB,EAAE,CAAC;QAC5D,MAAM,EAAE,GAAG,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAA;QAC9D,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAA;IAC5C,CAAC;IACD,OAAO,uBAAuB,CAAC,QAAQ,CAAC,CAAA;AAC1C,CAAC;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAA;AAE/B;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,QAA0C;IAChF,MAAM,KAAK,GAAG,OAAO,EAAE,CAAA;IACvB,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;QAChC,QAAQ,CAAC;YACP,UAAU,EAAE,KAAK;YACjB,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,aAAa,GAAG,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,CAAC;SACtE,CAAC,CAAA;IACJ,CAAC,EAAE,CAAC,CAAC,CAAA;IACL,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,CAAA;AACtC,CAAC"}

package/esm/tools/sendToExtension.d.ts

@@ -0,0 +1,3 @@
+type ExtensionMessageType = 'logs' | 'record' | 'rum' | 'telemetry';
+export declare function sendToExtension(type: ExtensionMessageType, payload: unknown): void;
+export {};

package/esm/tools/sendToExtension.js

@@ -0,0 +1,8 @@
+import { globalObject } from './globalObject';
+export function sendToExtension(type, payload) {
+    const callback = globalObject.__ddBrowserSdkExtensionCallback;
+    if (callback) {
+        callback({ type, payload });
+    }
+}
+//# sourceMappingURL=sendToExtension.js.map

package/esm/tools/sendToExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendToExtension.js","sourceRoot":"","sources":["../../src/tools/sendToExtension.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAQ7C,MAAM,UAAU,eAAe,CAAC,IAA0B,EAAE,OAAgB;IAC1E,MAAM,QAAQ,GAAI,YAA8B,CAAC,+BAA+B,CAAA;IAChF,IAAI,QAAQ,EAAE,CAAC;QACb,QAAQ,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAA;IAC7B,CAAC;AACH,CAAC"}

package/esm/tools/serialisation/context.d.ts

@@ -0,0 +1,9 @@
+export interface Context {
+    [x: string]: ContextValue;
+}
+export type ContextValue = string | number | boolean | Context | ContextArray | undefined | null;
+/**
+ * @hidden
+ */
+export interface ContextArray extends Array<ContextValue> {
+}

package/esm/tools/serialisation/context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.js.map

package/esm/tools/serialisation/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/tools/serialisation/context.ts"],"names":[],"mappings":""}

package/esm/tools/serialisation/jsonStringify.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that
+ * because some sites badly override toJSON on certain objects. Removing all toJSON methods from
+ * nested values would be too costly, so we just detach them from the root value, and native classes
+ * used to build JSON values (Array and Object).
+ *
+ * Note: this still assumes that JSON.stringify is correct.
+ */
+export declare function jsonStringify(value: unknown, replacer?: Array<string | number>, space?: string | number): string | undefined;
+export interface ObjectWithToJsonMethod {
+    toJSON?: () => unknown;
+}
+export declare function detachToJsonMethod(value: object): () => void;

package/esm/tools/serialisation/jsonStringify.js

@@ -0,0 +1,44 @@
+import { noop } from '../utils/functionUtils';
+/**
+ * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that
+ * because some sites badly override toJSON on certain objects. Removing all toJSON methods from
+ * nested values would be too costly, so we just detach them from the root value, and native classes
+ * used to build JSON values (Array and Object).
+ *
+ * Note: this still assumes that JSON.stringify is correct.
+ */
+export function jsonStringify(value, replacer, space) {
+    if (typeof value !== 'object' || value === null) {
+        return JSON.stringify(value);
+    }
+    // Note: The order matter here. We need to detach toJSON methods on parent classes before their
+    // subclasses.
+    const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);
+    const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);
+    const restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));
+    const restoreValueToJson = detachToJsonMethod(value);
+    try {
+        return JSON.stringify(value, replacer, space);
+    }
+    catch (_a) {
+        return '<error: unable to serialize object>';
+    }
+    finally {
+        restoreObjectPrototypeToJson();
+        restoreArrayPrototypeToJson();
+        restoreValuePrototypeToJson();
+        restoreValueToJson();
+    }
+}
+export function detachToJsonMethod(value) {
+    const object = value;
+    const objectToJson = object.toJSON;
+    if (objectToJson) {
+        delete object.toJSON;
+        return () => {
+            object.toJSON = objectToJson;
+        };
+    }
+    return noop;
+}
+//# sourceMappingURL=jsonStringify.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonStringify.js","sourceRoot":"","sources":["../../../src/tools/serialisation/jsonStringify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAA;AAE7C;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAc,EACd,QAAiC,EACjC,KAAuB;IAEvB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;IAC9B,CAAC;IAED,+FAA+F;IAC/F,cAAc;IACd,MAAM,4BAA4B,GAAG,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IACzE,MAAM,2BAA2B,GAAG,kBAAkB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;IACvE,MAAM,2BAA2B,GAAG,kBAAkB,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAA;IACpF,MAAM,kBAAkB,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAA;IAEpD,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAA;IAC/C,CAAC;IAAC,WAAM,CAAC;QACP,OAAO,qCAAqC,CAAA;IAC9C,CAAC;YAAS,CAAC;QACT,4BAA4B,EAAE,CAAA;QAC9B,2BAA2B,EAAE,CAAA;QAC7B,2BAA2B,EAAE,CAAA;QAC7B,kBAAkB,EAAE,CAAA;IACtB,CAAC;AACH,CAAC;AAMD,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,MAAM,MAAM,GAAG,KAA+B,CAAA;IAC9C,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAA;IAClC,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC,MAAM,CAAA;QACpB,OAAO,GAAG,EAAE;YACV,MAAM,CAAC,MAAM,GAAG,YAAY,CAAA;QAC9B,CAAC,CAAA;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/esm/tools/serialisation/sanitize.d.ts

@@ -0,0 +1,18 @@
+import type { Context, ContextValue } from './context';
+/**
+ * Ensures user-provided data is 'safe' for the SDK
+ * - Deep clones data
+ * - Removes cyclic references
+ * - Transforms unserializable types to a string representation
+ *
+ * LIMITATIONS:
+ * - Size is in characters, not byte count (may differ according to character encoding)
+ * - Size does not take into account indentation that can be applied to JSON.stringify
+ * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify
+ *
+ * @param source              - User-provided data meant to be serialized using JSON.stringify
+ * @param maxCharacterCount   - Maximum number of characters allowed in serialized form
+ */
+export declare function sanitize(source: string, maxCharacterCount?: number): string | undefined;
+export declare function sanitize(source: Context, maxCharacterCount?: number): Context;
+export declare function sanitize(source: unknown, maxCharacterCount?: number): ContextValue;

package/esm/tools/serialisation/sanitize.js

@@ -0,0 +1,185 @@
+import { display } from '../display';
+import { ONE_KIBI_BYTE } from '../utils/byteUtils';
+import { detachToJsonMethod } from './jsonStringify';
+// 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;
+// Symbol for the root element of the JSONPath used for visited objects
+const JSON_PATH_ROOT_ELEMENT = '$';
+// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as "key".
+// With the separator (:), we need to add 3 characters to the count.
+const KEY_DECORATION_LENGTH = 3;
+export function sanitize(source, maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT) {
+    // Unbind any toJSON function we may have on [] or {} prototypes
+    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 = [];
+    const visitedObjectsWithPath = new WeakMap();
+    const sanitizedData = sanitizeProcessor(source, 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;
+    }
+    while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
+        const containerToProcess = containerQueue.shift();
+        let separatorLength = 0; // 0 for the first element, 1 for subsequent elements
+        // 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);
+                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[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[key] = targetData;
+                }
+            }
+        }
+    }
+    // Rebind detached toJSON functions
+    restoreObjectPrototypeToJson();
+    restoreArrayPrototypeToJson();
+    return sanitizedData;
+}
+/**
+ * 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) {
+    // Start by handling toJSON, as we want to sanitize its output
+    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;
+    }
+    // Handle potential cyclic references
+    // We need to use source as sourceToSanitize could be a reference to a new object
+    // At this stage, we know the source is an object type
+    const sourceAsObject = source;
+    if (visitedObjectsWithPath.has(sourceAsObject)) {
+        return `[Reference seen at ${visitedObjectsWithPath.get(sourceAsObject)}]`;
+    }
+    // Add processed source to queue
+    const currentPath = key !== undefined ? `${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) {
+    // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation
+    if (typeof value === 'bigint') {
+        return `[BigInt] ${value.toString()}`;
+    }
+    // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted
+    // so it won't prevent stringify from serializing later
+    if (typeof value === 'function') {
+        return `[Function] ${value.name || 'unknown'}`;
+    }
+    // JSON.stringify() does not serialize symbols.
+    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()}`;
+        }
+        // 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]) {
+            return `[${match[1]}]`;
+        }
+    }
+    catch (_a) {
+        // If the previous serialization attempts failed, and we cannot convert using
+        // Object.prototype.toString, declare the value unserializable
+    }
+    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 (_a) {
+            // If toJSON fails, we continue by trying to serialize the value manually
+        }
+    }
+    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);
+}
+//# sourceMappingURL=sanitize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.js","sourceRoot":"","sources":["../../../src/tools/serialisation/sanitize.ts"],"names":[],"mappings":"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"}

package/esm/tools/stackTrace/computeStackTrace.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Cross-browser stack trace computation.
+ *
+ * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js
+ */
+export interface StackFrame {
+    url?: string;
+    func?: string;
+    /** The arguments passed to the function, if known. */
+    args?: string[];
+    line?: number;
+    column?: number;
+    /** An array of source code lines; the middle element corresponds to the correct line. */
+    context?: string[];
+}
+export interface StackTrace {
+    name?: string;
+    message?: string;
+    url?: string;
+    stack: StackFrame[];
+    incomplete?: boolean;
+    partial?: boolean;
+}
+export declare function computeStackTrace(ex: unknown): StackTrace;
+export declare function computeStackTraceFromOnErrorMessage(messageObj: unknown, url?: string, line?: number, column?: number): StackTrace | undefined;