@pratham.raval/browser-core 6.22.3

package/cjs/tools/display.js

@@ -0,0 +1,44 @@
+"use strict";
+/* eslint-disable local-rules/disallow-side-effects */
+/**
+ * Keep references on console methods to avoid triggering patched behaviors
+ *
+ * NB: in some setup, console could already be patched by another SDK.
+ * In this case, some display messages can be sent by the other SDK
+ * but we should be safe from infinite loop nonetheless.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MORE_DETAILS = exports.DOCS_TROUBLESHOOTING = exports.DOCS_ORIGIN = exports.display = exports.originalConsoleMethods = exports.globalConsole = exports.ConsoleApiName = void 0;
+exports.ConsoleApiName = {
+    log: 'log',
+    debug: 'debug',
+    info: 'info',
+    warn: 'warn',
+    error: 'error',
+};
+/**
+ * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove
+ * "console.*" references. This causes some issue as we expect `console.*` to be defined.
+ * As a workaround, let's use a variable alias, so those expressions won't be taken into account by
+ * simple static analysis.
+ *
+ * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/
+ * [2]: https://github.com/terser/terser#compress-options (look for drop_console)
+ */
+exports.globalConsole = console;
+exports.originalConsoleMethods = {};
+Object.keys(exports.ConsoleApiName).forEach((name) => {
+    exports.originalConsoleMethods[name] = exports.globalConsole[name];
+});
+const PREFIX = 'Datadog Browser SDK:';
+exports.display = {
+    debug: exports.originalConsoleMethods.debug.bind(exports.globalConsole, PREFIX),
+    log: exports.originalConsoleMethods.log.bind(exports.globalConsole, PREFIX),
+    info: exports.originalConsoleMethods.info.bind(exports.globalConsole, PREFIX),
+    warn: exports.originalConsoleMethods.warn.bind(exports.globalConsole, PREFIX),
+    error: exports.originalConsoleMethods.error.bind(exports.globalConsole, PREFIX),
+};
+exports.DOCS_ORIGIN = 'https://docs.datadoghq.com';
+exports.DOCS_TROUBLESHOOTING = `${exports.DOCS_ORIGIN}/real_user_monitoring/browser/troubleshooting`;
+exports.MORE_DETAILS = 'More details:';
+//# sourceMappingURL=display.js.map

package/cjs/tools/display.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.js","sourceRoot":"","sources":["../../src/tools/display.ts"],"names":[],"mappings":";AAAA,sDAAsD;AACtD;;;;;;GAMG;;;AAEU,QAAA,cAAc,GAAG;IAC5B,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;CACN,CAAA;AAYV;;;;;;;;GAQG;AACU,QAAA,aAAa,GAAG,OAAO,CAAA;AAEvB,QAAA,sBAAsB,GAAG,EAAa,CAAA;AACnD,MAAM,CAAC,IAAI,CAAC,sBAAc,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;IAC3C,8BAAsB,CAAC,IAAsB,CAAC,GAAG,qBAAa,CAAC,IAAsB,CAAC,CAAA;AACxF,CAAC,CAAC,CAAA;AAEF,MAAM,MAAM,GAAG,sBAAsB,CAAA;AAExB,QAAA,OAAO,GAAY;IAC9B,KAAK,EAAE,8BAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,qBAAa,EAAE,MAAM,CAAC;IAC/D,GAAG,EAAE,8BAAsB,CAAC,GAAG,CAAC,IAAI,CAAC,qBAAa,EAAE,MAAM,CAAC;IAC3D,IAAI,EAAE,8BAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAa,EAAE,MAAM,CAAC;IAC7D,IAAI,EAAE,8BAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAa,EAAE,MAAM,CAAC;IAC7D,KAAK,EAAE,8BAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,qBAAa,EAAE,MAAM,CAAC;CAChE,CAAA;AAEY,QAAA,WAAW,GAAG,4BAA4B,CAAA;AAC1C,QAAA,oBAAoB,GAAG,GAAG,mBAAW,+CAA+C,CAAA;AACpF,QAAA,YAAY,GAAG,eAAe,CAAA"}

package/cjs/tools/encoder.d.ts

@@ -0,0 +1,54 @@
+import type { Uint8ArrayBuffer } from './utils/byteUtils';
+export interface Encoder<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
+    /**
+     * Whether this encoder might call the provided callbacks asynchronously
+     */
+    isAsync: boolean;
+    /**
+     * Whether some data has been written since the last finish() or finishSync() call
+     */
+    isEmpty: boolean;
+    /**
+     * Write a string to be encoded.
+     *
+     * This operation can be synchronous or asynchronous depending on the encoder implementation.
+     *
+     * If specified, the callback will be invoked when the operation finishes, unless the operation is
+     * asynchronous and finish() or finishSync() is called in the meantime.
+     */
+    write(data: string, callback?: (additionalEncodedBytesCount: number) => void): void;
+    /**
+     * Waits for pending data to be encoded and resets the encoder state.
+     *
+     * This operation can be synchronous or asynchronous depending on the encoder implementation.
+     *
+     * The callback will be invoked when the operation finishes, unless the operation is asynchronous
+     * and another call to finish() or finishSync() occurs in the meantime.
+     */
+    finish(callback: (result: EncoderResult<Output>) => void): void;
+    /**
+     * Resets the encoder state then returns the encoded data and any potential pending data directly,
+     * discarding all pending write operations and finish() callbacks.
+     */
+    finishSync(): EncoderResult<Output> & {
+        pendingData: string;
+    };
+    /**
+     * Returns a rough estimation of the bytes count if the data was encoded.
+     */
+    estimateEncodedBytesCount(data: string): number;
+}
+export interface EncoderResult<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
+    output: Output;
+    outputBytesCount: number;
+    /**
+     * An encoding type supported by HTTP Content-Encoding, if applicable.
+     * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding#directives
+     */
+    encoding?: 'deflate';
+    /**
+     * Total bytes count of the input strings encoded to UTF-8.
+     */
+    rawBytesCount: number;
+}
+export declare function createIdentityEncoder(): Encoder<string>;

package/cjs/tools/encoder.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentityEncoder = createIdentityEncoder;
+const byteUtils_1 = require("./utils/byteUtils");
+function createIdentityEncoder() {
+    let output = '';
+    let outputBytesCount = 0;
+    return {
+        isAsync: false,
+        get isEmpty() {
+            return !output;
+        },
+        write(data, callback) {
+            const additionalEncodedBytesCount = (0, byteUtils_1.computeBytesCount)(data);
+            outputBytesCount += additionalEncodedBytesCount;
+            output += data;
+            if (callback) {
+                callback(additionalEncodedBytesCount);
+            }
+        },
+        finish(callback) {
+            callback(this.finishSync());
+        },
+        finishSync() {
+            const result = {
+                output,
+                outputBytesCount,
+                rawBytesCount: outputBytesCount,
+                pendingData: '',
+            };
+            output = '';
+            outputBytesCount = 0;
+            return result;
+        },
+        estimateEncodedBytesCount(data) {
+            return data.length;
+        },
+    };
+}
+//# sourceMappingURL=encoder.js.map

package/cjs/tools/encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.js","sourceRoot":"","sources":["../../src/tools/encoder.ts"],"names":[],"mappings":";;AA8DA,sDAwCC;AArGD,iDAAqD;AA6DrD,SAAgB,qBAAqB;IACnC,IAAI,MAAM,GAAG,EAAE,CAAA;IACf,IAAI,gBAAgB,GAAG,CAAC,CAAA;IAExB,OAAO;QACL,OAAO,EAAE,KAAK;QAEd,IAAI,OAAO;YACT,OAAO,CAAC,MAAM,CAAA;QAChB,CAAC;QAED,KAAK,CAAC,IAAI,EAAE,QAAQ;YAClB,MAAM,2BAA2B,GAAG,IAAA,6BAAiB,EAAC,IAAI,CAAC,CAAA;YAC3D,gBAAgB,IAAI,2BAA2B,CAAA;YAC/C,MAAM,IAAI,IAAI,CAAA;YACd,IAAI,QAAQ,EAAE,CAAC;gBACb,QAAQ,CAAC,2BAA2B,CAAC,CAAA;YACvC,CAAC;QACH,CAAC;QAED,MAAM,CAAC,QAAQ;YACb,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAA;QAC7B,CAAC;QAED,UAAU;YACR,MAAM,MAAM,GAAG;gBACb,MAAM;gBACN,gBAAgB;gBAChB,aAAa,EAAE,gBAAgB;gBAC/B,WAAW,EAAE,EAAE;aAChB,CAAA;YACD,MAAM,GAAG,EAAE,CAAA;YACX,gBAAgB,GAAG,CAAC,CAAA;YACpB,OAAO,MAAM,CAAA;QACf,CAAC;QAED,yBAAyB,CAAC,IAAI;YAC5B,OAAO,IAAI,CAAC,MAAM,CAAA;QACpB,CAAC;KACF,CAAA;AACH,CAAC"}

package/cjs/tools/experimentalFeatures.d.ts

@@ -0,0 +1,20 @@
+/**
+ * LIMITATION:
+ * For NPM setup, this feature flag singleton is shared between RUM and Logs product.
+ * This means that an experimental flag set on the RUM product will be set on the Logs product.
+ * So keep in mind that in certain configurations, your experimental feature flag may affect other products.
+ *
+ * FORMAT:
+ * All feature flags should be snake_cased
+ */
+export declare enum ExperimentalFeature {
+    TRACK_INTAKE_REQUESTS = "track_intake_requests",
+    USE_TREE_WALKER_FOR_ACTION_NAME = "use_tree_walker_for_action_name",
+    FEATURE_OPERATION_VITAL = "feature_operation_vital",
+    SHORT_SESSION_INVESTIGATION = "short_session_investigation"
+}
+export declare function initFeatureFlags(enableExperimentalFeatures: string[] | undefined): void;
+export declare function addExperimentalFeatures(enabledFeatures: ExperimentalFeature[]): void;
+export declare function isExperimentalFeatureEnabled(featureName: ExperimentalFeature): boolean;
+export declare function resetExperimentalFeatures(): void;
+export declare function getExperimentalFeatures(): Set<ExperimentalFeature>;

package/cjs/tools/experimentalFeatures.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * LIMITATION:
+ * For NPM setup, this feature flag singleton is shared between RUM and Logs product.
+ * This means that an experimental flag set on the RUM product will be set on the Logs product.
+ * So keep in mind that in certain configurations, your experimental feature flag may affect other products.
+ *
+ * FORMAT:
+ * All feature flags should be snake_cased
+ */
+// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary
+// string is an expected feature flag
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExperimentalFeature = void 0;
+exports.initFeatureFlags = initFeatureFlags;
+exports.addExperimentalFeatures = addExperimentalFeatures;
+exports.isExperimentalFeatureEnabled = isExperimentalFeatureEnabled;
+exports.resetExperimentalFeatures = resetExperimentalFeatures;
+exports.getExperimentalFeatures = getExperimentalFeatures;
+const objectUtils_1 = require("./utils/objectUtils");
+// eslint-disable-next-line no-restricted-syntax
+var ExperimentalFeature;
+(function (ExperimentalFeature) {
+    ExperimentalFeature["TRACK_INTAKE_REQUESTS"] = "track_intake_requests";
+    ExperimentalFeature["USE_TREE_WALKER_FOR_ACTION_NAME"] = "use_tree_walker_for_action_name";
+    ExperimentalFeature["FEATURE_OPERATION_VITAL"] = "feature_operation_vital";
+    ExperimentalFeature["SHORT_SESSION_INVESTIGATION"] = "short_session_investigation";
+})(ExperimentalFeature || (exports.ExperimentalFeature = ExperimentalFeature = {}));
+const enabledExperimentalFeatures = new Set();
+function initFeatureFlags(enableExperimentalFeatures) {
+    if (Array.isArray(enableExperimentalFeatures)) {
+        addExperimentalFeatures(enableExperimentalFeatures.filter((flag) => (0, objectUtils_1.objectHasValue)(ExperimentalFeature, flag)));
+    }
+}
+function addExperimentalFeatures(enabledFeatures) {
+    enabledFeatures.forEach((flag) => {
+        enabledExperimentalFeatures.add(flag);
+    });
+}
+function isExperimentalFeatureEnabled(featureName) {
+    return enabledExperimentalFeatures.has(featureName);
+}
+function resetExperimentalFeatures() {
+    enabledExperimentalFeatures.clear();
+}
+function getExperimentalFeatures() {
+    return enabledExperimentalFeatures;
+}
+//# sourceMappingURL=experimentalFeatures.js.map

package/cjs/tools/experimentalFeatures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"experimentalFeatures.js","sourceRoot":"","sources":["../../src/tools/experimentalFeatures.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;AACH,oGAAoG;AACpG,qCAAqC;;;AAcrC,4CAQC;AAED,0DAIC;AAED,oEAEC;AAED,8DAEC;AAED,0DAEC;AAtCD,qDAAoD;AAEpD,gDAAgD;AAChD,IAAY,mBAKX;AALD,WAAY,mBAAmB;IAC7B,sEAA+C,CAAA;IAC/C,0FAAmE,CAAA;IACnE,0EAAmD,CAAA;IACnD,kFAA2D,CAAA;AAC7D,CAAC,EALW,mBAAmB,mCAAnB,mBAAmB,QAK9B;AAED,MAAM,2BAA2B,GAA6B,IAAI,GAAG,EAAE,CAAA;AAEvE,SAAgB,gBAAgB,CAAC,0BAAgD;IAC/E,IAAI,KAAK,CAAC,OAAO,CAAC,0BAA0B,CAAC,EAAE,CAAC;QAC9C,uBAAuB,CACrB,0BAA0B,CAAC,MAAM,CAAC,CAAC,IAAI,EAA+B,EAAE,CACtE,IAAA,4BAAc,EAAC,mBAAmB,EAAE,IAAI,CAAC,CAC1C,CACF,CAAA;IACH,CAAC;AACH,CAAC;AAED,SAAgB,uBAAuB,CAAC,eAAsC;IAC5E,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC/B,2BAA2B,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACvC,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,SAAgB,4BAA4B,CAAC,WAAgC;IAC3E,OAAO,2BAA2B,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AACrD,CAAC;AAED,SAAgB,yBAAyB;IACvC,2BAA2B,CAAC,KAAK,EAAE,CAAA;AACrC,CAAC;AAED,SAAgB,uBAAuB;IACrC,OAAO,2BAA2B,CAAA;AACpC,CAAC"}

package/cjs/tools/getZoneJsOriginalValue.d.ts

@@ -0,0 +1,19 @@
+export interface BrowserWindowWithZoneJs extends Window {
+    Zone?: {
+        __symbol__?: (name: string) => string;
+    };
+}
+/**
+ * Gets the original value for a DOM API that was potentially patched by Zone.js.
+ *
+ * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original
+ * value of the patched functions/constructors/methods in a hidden property prefixed by
+ * __zone_symbol__.
+ *
+ * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to
+ * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to
+ * use the original DOM API instead of the one patched by Zone.js.
+ *
+ * [1]: https://github.com/angular/angular/tree/main/packages/zone.js
+ */
+export declare function getZoneJsOriginalValue<Target, Name extends keyof Target & string>(target: Target, name: Name): Target[Name];

package/cjs/tools/getZoneJsOriginalValue.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZoneJsOriginalValue = getZoneJsOriginalValue;
+const globalObject_1 = require("./globalObject");
+/**
+ * Gets the original value for a DOM API that was potentially patched by Zone.js.
+ *
+ * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original
+ * value of the patched functions/constructors/methods in a hidden property prefixed by
+ * __zone_symbol__.
+ *
+ * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to
+ * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to
+ * use the original DOM API instead of the one patched by Zone.js.
+ *
+ * [1]: https://github.com/angular/angular/tree/main/packages/zone.js
+ */
+function getZoneJsOriginalValue(target, name) {
+    const browserWindow = (0, globalObject_1.getGlobalObject)();
+    let original;
+    if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {
+        original = target[browserWindow.Zone.__symbol__(name)];
+    }
+    if (!original) {
+        original = target[name];
+    }
+    return original;
+}
+//# sourceMappingURL=getZoneJsOriginalValue.js.map

package/cjs/tools/getZoneJsOriginalValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getZoneJsOriginalValue.js","sourceRoot":"","sources":["../../src/tools/getZoneJsOriginalValue.ts"],"names":[],"mappings":";;AAwBA,wDAaC;AArCD,iDAAgD;AAWhD;;;;;;;;;;;;GAYG;AACH,SAAgB,sBAAsB,CACpC,MAAc,EACd,IAAU;IAEV,MAAM,aAAa,GAAG,IAAA,8BAAe,GAA2B,CAAA;IAChE,IAAI,QAAkC,CAAA;IACtC,IAAI,aAAa,CAAC,IAAI,IAAI,OAAO,aAAa,CAAC,IAAI,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAC9E,QAAQ,GAAI,MAAc,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAA;IACjE,CAAC;IACD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IACzB,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC"}

package/cjs/tools/globalObject.d.ts

@@ -0,0 +1,19 @@
+/**
+ * inspired by https://mathiasbynens.be/notes/globalthis
+ */
+interface WorkerGlobalScope {
+    empty: never;
+}
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+export type GlobalObject = XOR<Window, WorkerGlobalScope>;
+export declare function getGlobalObject<T = typeof globalThis>(): T;
+/**
+ * Cached reference to the global object so it can be imported and re-used without
+ * re-evaluating the heavyweight fallback logic in `getGlobalObject()`.
+ */
+export declare const globalObject: (Without<Window, WorkerGlobalScope> & WorkerGlobalScope) | (Without<WorkerGlobalScope, Window> & Window);
+export declare const isWorkerEnvironment: boolean;
+export {};

package/cjs/tools/globalObject.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * inspired by https://mathiasbynens.be/notes/globalthis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerEnvironment = exports.globalObject = void 0;
+exports.getGlobalObject = getGlobalObject;
+function getGlobalObject() {
+    if (typeof globalThis === 'object') {
+        return globalThis;
+    }
+    Object.defineProperty(Object.prototype, '_dd_temp_', {
+        get() {
+            return this;
+        },
+        configurable: true,
+    });
+    // @ts-ignore _dd_temp is defined using defineProperty
+    let globalObject = _dd_temp_;
+    // @ts-ignore _dd_temp is defined using defineProperty
+    delete Object.prototype._dd_temp_;
+    if (typeof globalObject !== 'object') {
+        // on safari _dd_temp_ is available on window but not globally
+        // fallback on other browser globals check
+        if (typeof self === 'object') {
+            globalObject = self;
+        }
+        else if (typeof window === 'object') {
+            globalObject = window;
+        }
+        else {
+            globalObject = {};
+        }
+    }
+    return globalObject;
+}
+/**
+ * Cached reference to the global object so it can be imported and re-used without
+ * re-evaluating the heavyweight fallback logic in `getGlobalObject()`.
+ */
+// eslint-disable-next-line local-rules/disallow-side-effects
+exports.globalObject = getGlobalObject();
+exports.isWorkerEnvironment = 'WorkerGlobalScope' in exports.globalObject;
+//# sourceMappingURL=globalObject.js.map

package/cjs/tools/globalObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalObject.js","sourceRoot":"","sources":["../../src/tools/globalObject.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAaH,0CA0BC;AA1BD,SAAgB,eAAe;IAC7B,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QACnC,OAAO,UAA0B,CAAA;IACnC,CAAC;IACD,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,EAAE,WAAW,EAAE;QACnD,GAAG;YACD,OAAO,IAAc,CAAA;QACvB,CAAC;QACD,YAAY,EAAE,IAAI;KACnB,CAAC,CAAA;IACF,sDAAsD;IACtD,IAAI,YAAY,GAAY,SAAS,CAAA;IACrC,sDAAsD;IACtD,OAAO,MAAM,CAAC,SAAS,CAAC,SAAS,CAAA;IACjC,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE,CAAC;QACrC,8DAA8D;QAC9D,0CAA0C;QAC1C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,YAAY,GAAG,IAAI,CAAA;QACrB,CAAC;aAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YACtC,YAAY,GAAG,MAAM,CAAA;QACvB,CAAC;aAAM,CAAC;YACN,YAAY,GAAG,EAAE,CAAA;QACnB,CAAC;IACH,CAAC;IACD,OAAO,YAAiB,CAAA;AAC1B,CAAC;AAED;;;GAGG;AACH,6DAA6D;AAChD,QAAA,YAAY,GAAG,eAAe,EAAgB,CAAA;AAE9C,QAAA,mBAAmB,GAAG,mBAAmB,IAAI,oBAAY,CAAA"}

package/cjs/tools/instrumentMethod.d.ts

@@ -0,0 +1,75 @@
+import { noop } from './utils/functionUtils';
+/**
+ * Object passed to the callback of an instrumented method call. See `instrumentMethod` for more
+ * info.
+ */
+export interface InstrumentedMethodCall<TARGET extends {
+    [key: string]: any;
+}, METHOD extends keyof TARGET> {
+    /**
+     * The target object on which the method was called.
+     */
+    target: TARGET;
+    /**
+     * The parameters with which the method was called.
+     *
+     * Note: if needed, parameters can be mutated by the instrumentation
+     */
+    parameters: Parameters<TARGET[METHOD]>;
+    /**
+     * Registers a callback that will be called after the original method is called, with the method
+     * result passed as argument.
+     */
+    onPostCall: (callback: PostCallCallback<TARGET, METHOD>) => void;
+    /**
+     * The stack trace of the method call.
+     */
+    handlingStack?: string;
+}
+type PostCallCallback<TARGET extends {
+    [key: string]: any;
+}, METHOD extends keyof TARGET> = (result: ReturnType<TARGET[METHOD]>) => void;
+/**
+ * Instruments a method on a object, calling the given callback before the original method is
+ * invoked. The callback receives an object with information about the method call.
+ *
+ * This function makes sure that we are "good citizens" regarding third party instrumentations: when
+ * removing the instrumentation, the original method is usually restored, but if a third party
+ * instrumentation was set after ours, we keep it in place and just replace our instrumentation with
+ * a noop.
+ *
+ * Note: it is generally better to instrument methods that are "owned" by the object instead of ones
+ * that are inherited from the prototype chain. Example:
+ * * do:    `instrumentMethod(Array.prototype, 'push', ...)`
+ * * don't: `instrumentMethod([], 'push', ...)`
+ *
+ * This method is also used to set event handler properties (ex: window.onerror = ...), as it has
+ * the same requirements as instrumenting a method:
+ * * if the event handler is already set by a third party, we need to call it and not just blindly
+ * override it.
+ * * if the event handler is set by a third party after us, we need to keep it in place when
+ * removing ours.
+ *
+ * @example
+ *
+ *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {
+ *    console.log('Before calling fetch on', target, 'with parameters', parameters)
+ *
+ *    onPostCall((result) => {
+ *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)
+ *    })
+ *  })
+ */
+export declare function instrumentMethod<TARGET extends {
+    [key: string]: any;
+}, METHOD extends keyof TARGET & string>(targetPrototype: TARGET, method: METHOD, onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void, { computeHandlingStack }?: {
+    computeHandlingStack?: boolean;
+}): {
+    stop: typeof noop;
+};
+export declare function instrumentSetter<TARGET extends {
+    [key: string]: any;
+}, PROPERTY extends keyof TARGET>(targetPrototype: TARGET, property: PROPERTY, after: (target: TARGET, value: TARGET[PROPERTY]) => void): {
+    stop: typeof noop;
+};
+export {};

package/cjs/tools/instrumentMethod.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentMethod = instrumentMethod;
+exports.instrumentSetter = instrumentSetter;
+const timer_1 = require("./timer");
+const monitor_1 = require("./monitor");
+const functionUtils_1 = require("./utils/functionUtils");
+const handlingStack_1 = require("./stackTrace/handlingStack");
+/**
+ * Instruments a method on a object, calling the given callback before the original method is
+ * invoked. The callback receives an object with information about the method call.
+ *
+ * This function makes sure that we are "good citizens" regarding third party instrumentations: when
+ * removing the instrumentation, the original method is usually restored, but if a third party
+ * instrumentation was set after ours, we keep it in place and just replace our instrumentation with
+ * a noop.
+ *
+ * Note: it is generally better to instrument methods that are "owned" by the object instead of ones
+ * that are inherited from the prototype chain. Example:
+ * * do:    `instrumentMethod(Array.prototype, 'push', ...)`
+ * * don't: `instrumentMethod([], 'push', ...)`
+ *
+ * This method is also used to set event handler properties (ex: window.onerror = ...), as it has
+ * the same requirements as instrumenting a method:
+ * * if the event handler is already set by a third party, we need to call it and not just blindly
+ * override it.
+ * * if the event handler is set by a third party after us, we need to keep it in place when
+ * removing ours.
+ *
+ * @example
+ *
+ *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {
+ *    console.log('Before calling fetch on', target, 'with parameters', parameters)
+ *
+ *    onPostCall((result) => {
+ *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)
+ *    })
+ *  })
+ */
+function instrumentMethod(targetPrototype, method, onPreCall, { computeHandlingStack } = {}) {
+    let original = targetPrototype[method];
+    if (typeof original !== 'function') {
+        if (method in targetPrototype && method.startsWith('on')) {
+            original = functionUtils_1.noop;
+        }
+        else {
+            return { stop: functionUtils_1.noop };
+        }
+    }
+    let stopped = false;
+    const instrumentation = function () {
+        if (stopped) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+            return original.apply(this, arguments);
+        }
+        const parameters = Array.from(arguments);
+        let postCallCallback;
+        (0, monitor_1.callMonitored)(onPreCall, null, [
+            {
+                target: this,
+                parameters,
+                onPostCall: (callback) => {
+                    postCallCallback = callback;
+                },
+                handlingStack: computeHandlingStack ? (0, handlingStack_1.createHandlingStack)('instrumented method') : undefined,
+            },
+        ]);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        const result = original.apply(this, parameters);
+        if (postCallCallback) {
+            (0, monitor_1.callMonitored)(postCallCallback, null, [result]);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return result;
+    };
+    targetPrototype[method] = instrumentation;
+    return {
+        stop: () => {
+            stopped = true;
+            // If the instrumentation has been removed by a third party, keep the last one
+            if (targetPrototype[method] === instrumentation) {
+                targetPrototype[method] = original;
+            }
+        },
+    };
+}
+function instrumentSetter(targetPrototype, property, after) {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);
+    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {
+        return { stop: functionUtils_1.noop };
+    }
+    const stoppedInstrumentation = functionUtils_1.noop;
+    let instrumentation = (target, value) => {
+        // put hooked setter into event loop to avoid of set latency
+        (0, timer_1.setTimeout)(() => {
+            if (instrumentation !== stoppedInstrumentation) {
+                after(target, value);
+            }
+        }, 0);
+    };
+    const instrumentationWrapper = function (value) {
+        originalDescriptor.set.call(this, value);
+        instrumentation(this, value);
+    };
+    Object.defineProperty(targetPrototype, property, {
+        set: instrumentationWrapper,
+    });
+    return {
+        stop: () => {
+            var _a;
+            if (((_a = Object.getOwnPropertyDescriptor(targetPrototype, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {
+                Object.defineProperty(targetPrototype, property, originalDescriptor);
+            }
+            instrumentation = stoppedInstrumentation;
+        },
+    };
+}
+//# sourceMappingURL=instrumentMethod.js.map

package/cjs/tools/instrumentMethod.js.map

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

package/cjs/tools/matchOption.d.ts

@@ -0,0 +1,8 @@
+export type MatchOption = string | RegExp | ((value: string) => boolean);
+export declare function isMatchOption(item: unknown): item is MatchOption;
+/**
+ * Returns true if value can be matched by at least one of the provided MatchOptions.
+ * When comparing strings, setting useStartsWith to true will compare the value with the start of
+ * the option, instead of requiring an exact match.
+ */
+export declare function matchList(list: MatchOption[], value: string, useStartsWith?: boolean): boolean;

package/cjs/tools/matchOption.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMatchOption = isMatchOption;
+exports.matchList = matchList;
+const display_1 = require("./display");
+const typeUtils_1 = require("./utils/typeUtils");
+function isMatchOption(item) {
+    const itemType = (0, typeUtils_1.getType)(item);
+    return itemType === 'string' || itemType === 'function' || item instanceof RegExp;
+}
+/**
+ * Returns true if value can be matched by at least one of the provided MatchOptions.
+ * When comparing strings, setting useStartsWith to true will compare the value with the start of
+ * the option, instead of requiring an exact match.
+ */
+function matchList(list, value, useStartsWith = false) {
+    return list.some((item) => {
+        try {
+            if (typeof item === 'function') {
+                return item(value);
+            }
+            else if (item instanceof RegExp) {
+                return item.test(value);
+            }
+            else if (typeof item === 'string') {
+                return useStartsWith ? value.startsWith(item) : item === value;
+            }
+        }
+        catch (e) {
+            display_1.display.error(e);
+        }
+        return false;
+    });
+}
+//# sourceMappingURL=matchOption.js.map

package/cjs/tools/matchOption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchOption.js","sourceRoot":"","sources":["../../src/tools/matchOption.ts"],"names":[],"mappings":";;AAKA,sCAGC;AAOD,8BAeC;AA9BD,uCAAmC;AACnC,iDAA2C;AAI3C,SAAgB,aAAa,CAAC,IAAa;IACzC,MAAM,QAAQ,GAAG,IAAA,mBAAO,EAAC,IAAI,CAAC,CAAA;IAC9B,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,UAAU,IAAI,IAAI,YAAY,MAAM,CAAA;AACnF,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAC,IAAmB,EAAE,KAAa,EAAE,aAAa,GAAG,KAAK;IACjF,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,IAAI,CAAC;YACH,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;gBAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA;YACpB,CAAC;iBAAM,IAAI,IAAI,YAAY,MAAM,EAAE,CAAC;gBAClC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACzB,CAAC;iBAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACpC,OAAO,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAA;YAChE,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,iBAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAClB,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/cjs/tools/mergeInto.d.ts

@@ -0,0 +1,25 @@
+type Merged<TDestination, TSource> = TSource extends undefined ? TDestination : TDestination extends undefined ? TSource : TSource extends any[] ? TDestination extends any[] ? TDestination & TSource : TSource : TSource extends object ? TDestination extends object ? TDestination extends any[] ? TSource : TDestination & TSource : TSource : TSource;
+/**
+ * Iterate over source and affect its sub values into destination, recursively.
+ * If the source and destination can't be merged, return source.
+ */
+export declare function mergeInto<D, S>(destination: D, source: S, circularReferenceChecker?: CircularReferenceChecker): Merged<D, S>;
+/**
+ * A simplistic implementation of a deep clone algorithm.
+ * Caveats:
+ * - It doesn't maintain prototype chains - don't use with instances of custom classes.
+ * - It doesn't handle Map and Set
+ */
+export declare function deepClone<T>(value: T): T;
+type Combined<A, B> = A extends null ? B : B extends null ? A : Merged<A, B>;
+export declare function combine<A, B>(a: A, b: B): Combined<A, B>;
+export declare function combine<A, B, C>(a: A, b: B, c: C): Combined<Combined<A, B>, C>;
+export declare function combine<A, B, C, D>(a: A, b: B, c: C, d: D): Combined<Combined<Combined<A, B>, C>, D>;
+export declare function combine<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): Combined<Combined<Combined<Combined<A, B>, C>, D>, E>;
+export declare function combine<A, B, C, D, E, F>(a: A, b: B, c: C, d: D, e: E, f: F): Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>;
+export declare function combine<A, B, C, D, E, F, G>(a: A, b: B, c: C, d: D, e: E, f: F, g: G): Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>;
+export declare function combine<A, B, C, D, E, F, G, H>(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H): Combined<Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>, H>;
+interface CircularReferenceChecker {
+    hasAlreadyBeenSeen(value: any): boolean;
+}
+export {};