posthog-node 5.8.8 → 5.9.0

package/dist/extensions/error-tracking/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>ErrorTracking
+});
+const external_autocapture_js_namespaceObject = require("./autocapture.js");
+const core_namespaceObject = require("@posthog/core");
+const external_error_conversion_js_namespaceObject = require("./error-conversion.js");
+const SHUTDOWN_TIMEOUT = 2000;
+class ErrorTracking {
+    constructor(client, options, _logger){
+        this.client = client;
+        this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
+        this._logger = _logger;
+        this._rateLimiter = new core_namespaceObject.BucketedRateLimiter({
+            refillRate: 1,
+            bucketSize: 10,
+            refillInterval: 10000,
+            _logger: this._logger
+        });
+        this.startAutocaptureIfEnabled();
+    }
+    static async buildEventMessage(error, hint, distinctId, additionalProperties) {
+        const properties = {
+            ...additionalProperties
+        };
+        if (!distinctId) properties.$process_person_profile = false;
+        const exceptionProperties = await (0, external_error_conversion_js_namespaceObject.propertiesFromUnknownInput)(this.stackParser, this.frameModifiers, error, hint);
+        return {
+            event: '$exception',
+            distinctId: distinctId || (0, core_namespaceObject.uuidv7)(),
+            properties: {
+                ...exceptionProperties,
+                ...properties
+            }
+        };
+    }
+    startAutocaptureIfEnabled() {
+        if (this.isEnabled()) {
+            (0, external_autocapture_js_namespaceObject.addUncaughtExceptionListener)(this.onException.bind(this), this.onFatalError.bind(this));
+            (0, external_autocapture_js_namespaceObject.addUnhandledRejectionListener)(this.onException.bind(this));
+        }
+    }
+    async onException(exception, hint) {
+        this.client.addPendingPromise((async ()=>{
+            const eventMessage = await ErrorTracking.buildEventMessage(exception, hint);
+            const exceptionProperties = eventMessage.properties;
+            const exceptionType = exceptionProperties?.$exception_list[0]?.type ?? 'Exception';
+            const isRateLimited = this._rateLimiter.consumeRateLimit(exceptionType);
+            if (isRateLimited) return void this._logger.info('Skipping exception capture because of client rate limiting.', {
+                exception: exceptionType
+            });
+            return this.client.capture(eventMessage);
+        })());
+    }
+    async onFatalError(exception) {
+        console.error(exception);
+        await this.client.shutdown(SHUTDOWN_TIMEOUT);
+        process.exit(1);
+    }
+    isEnabled() {
+        return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
+    }
+    shutdown() {
+        this._rateLimiter.stop();
+    }
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/error-tracking/index.mjs

@@ -0,0 +1,63 @@
+import { addUncaughtExceptionListener, addUnhandledRejectionListener } from "./autocapture.mjs";
+import { BucketedRateLimiter, uuidv7 } from "@posthog/core";
+import { propertiesFromUnknownInput } from "./error-conversion.mjs";
+const SHUTDOWN_TIMEOUT = 2000;
+class ErrorTracking {
+    constructor(client, options, _logger){
+        this.client = client;
+        this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
+        this._logger = _logger;
+        this._rateLimiter = new BucketedRateLimiter({
+            refillRate: 1,
+            bucketSize: 10,
+            refillInterval: 10000,
+            _logger: this._logger
+        });
+        this.startAutocaptureIfEnabled();
+    }
+    static async buildEventMessage(error, hint, distinctId, additionalProperties) {
+        const properties = {
+            ...additionalProperties
+        };
+        if (!distinctId) properties.$process_person_profile = false;
+        const exceptionProperties = await propertiesFromUnknownInput(this.stackParser, this.frameModifiers, error, hint);
+        return {
+            event: '$exception',
+            distinctId: distinctId || uuidv7(),
+            properties: {
+                ...exceptionProperties,
+                ...properties
+            }
+        };
+    }
+    startAutocaptureIfEnabled() {
+        if (this.isEnabled()) {
+            addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this));
+            addUnhandledRejectionListener(this.onException.bind(this));
+        }
+    }
+    async onException(exception, hint) {
+        this.client.addPendingPromise((async ()=>{
+            const eventMessage = await ErrorTracking.buildEventMessage(exception, hint);
+            const exceptionProperties = eventMessage.properties;
+            const exceptionType = exceptionProperties?.$exception_list[0]?.type ?? 'Exception';
+            const isRateLimited = this._rateLimiter.consumeRateLimit(exceptionType);
+            if (isRateLimited) return void this._logger.info('Skipping exception capture because of client rate limiting.', {
+                exception: exceptionType
+            });
+            return this.client.capture(eventMessage);
+        })());
+    }
+    async onFatalError(exception) {
+        console.error(exception);
+        await this.client.shutdown(SHUTDOWN_TIMEOUT);
+        process.exit(1);
+    }
+    isEnabled() {
+        return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
+    }
+    shutdown() {
+        this._rateLimiter.stop();
+    }
+}
+export { ErrorTracking as default };

package/dist/extensions/error-tracking/reduceable-cache.d.ts

@@ -0,0 +1,13 @@
+/** A simple Least Recently Used map */
+export declare class ReduceableCache<K, V> {
+    private readonly _maxSize;
+    private readonly _cache;
+    constructor(_maxSize: number);
+    /** Get an entry or undefined if it was not in the cache. Re-inserts to update the recently used order */
+    get(key: K): V | undefined;
+    /** Insert an entry and evict an older entry if we've reached maxSize */
+    set(key: K, value: V): void;
+    /** Remove an entry and return the entry if it was in the cache */
+    reduce(): void;
+}
+//# sourceMappingURL=reduceable-cache.d.ts.map

package/dist/extensions/error-tracking/reduceable-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduceable-cache.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/reduceable-cache.ts"],"names":[],"mappings":"AAGA,uCAAuC;AACvC,qBAAa,eAAe,CAAC,CAAC,EAAE,CAAC;IAGZ,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;gBAEE,QAAQ,EAAE,MAAM;IAIpD,yGAAyG;IAClG,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAWjC,wEAAwE;IACjE,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAIlC,kEAAkE;IAC3D,MAAM,IAAI,IAAI;CAStB"}

package/dist/extensions/error-tracking/reduceable-cache.js

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ReduceableCache: ()=>ReduceableCache
+});
+class ReduceableCache {
+    constructor(_maxSize){
+        this._maxSize = _maxSize;
+        this._cache = new Map();
+    }
+    get(key) {
+        const value = this._cache.get(key);
+        if (void 0 === value) return;
+        this._cache.delete(key);
+        this._cache.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        this._cache.set(key, value);
+    }
+    reduce() {
+        while(this._cache.size >= this._maxSize){
+            const value = this._cache.keys().next().value;
+            if (value) this._cache.delete(value);
+        }
+    }
+}
+exports.ReduceableCache = __webpack_exports__.ReduceableCache;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ReduceableCache"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/error-tracking/reduceable-cache.mjs

@@ -0,0 +1,23 @@
+class ReduceableCache {
+    constructor(_maxSize){
+        this._maxSize = _maxSize;
+        this._cache = new Map();
+    }
+    get(key) {
+        const value = this._cache.get(key);
+        if (void 0 === value) return;
+        this._cache.delete(key);
+        this._cache.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        this._cache.set(key, value);
+    }
+    reduce() {
+        while(this._cache.size >= this._maxSize){
+            const value = this._cache.keys().next().value;
+            if (value) this._cache.delete(value);
+        }
+    }
+}
+export { ReduceableCache };

package/dist/extensions/error-tracking/stack-parser.d.ts

@@ -0,0 +1,3 @@
+import { GetModuleFn, StackParser } from './types';
+export declare function createStackParser(getModule?: GetModuleFn): StackParser;
+//# sourceMappingURL=stack-parser.d.ts.map

package/dist/extensions/error-tracking/stack-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-parser.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/stack-parser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAkD,WAAW,EAAE,MAAM,SAAS,CAAA;AAmJlG,wBAAgB,iBAAiB,CAAC,SAAS,CAAC,EAAE,WAAW,GAAG,WAAW,CAyCtE"}

package/dist/extensions/error-tracking/stack-parser.js

@@ -0,0 +1,148 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createStackParser: ()=>createStackParser
+});
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STACKTRACE_FRAME_LIMIT = 50;
+const UNKNOWN_FUNCTION = '?';
+function node(getModule) {
+    const FILENAME_MATCH = /^\s*[-]{4,}$/;
+    const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+    return (line)=>{
+        const lineMatch = line.match(FULL_MATCH);
+        if (lineMatch) {
+            let object;
+            let method;
+            let functionName;
+            let typeName;
+            let methodName;
+            if (lineMatch[1]) {
+                functionName = lineMatch[1];
+                let methodStart = functionName.lastIndexOf('.');
+                if ('.' === functionName[methodStart - 1]) methodStart--;
+                if (methodStart > 0) {
+                    object = functionName.slice(0, methodStart);
+                    method = functionName.slice(methodStart + 1);
+                    const objectEnd = object.indexOf('.Module');
+                    if (objectEnd > 0) {
+                        functionName = functionName.slice(objectEnd + 1);
+                        object = object.slice(0, objectEnd);
+                    }
+                }
+                typeName = void 0;
+            }
+            if (method) {
+                typeName = object;
+                methodName = method;
+            }
+            if ('<anonymous>' === method) {
+                methodName = void 0;
+                functionName = void 0;
+            }
+            if (void 0 === functionName) {
+                methodName = methodName || UNKNOWN_FUNCTION;
+                functionName = typeName ? `${typeName}.${methodName}` : methodName;
+            }
+            let filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2];
+            const isNative = 'native' === lineMatch[5];
+            if (filename?.match(/\/[A-Z]:/)) filename = filename.slice(1);
+            if (!filename && lineMatch[5] && !isNative) filename = lineMatch[5];
+            return {
+                filename: filename ? decodeURI(filename) : void 0,
+                module: getModule ? getModule(filename) : void 0,
+                function: functionName,
+                lineno: _parseIntOrUndefined(lineMatch[3]),
+                colno: _parseIntOrUndefined(lineMatch[4]),
+                in_app: filenameIsInApp(filename || '', isNative),
+                platform: "node:javascript"
+            };
+        }
+        if (line.match(FILENAME_MATCH)) return {
+            filename: line,
+            platform: "node:javascript"
+        };
+    };
+}
+function filenameIsInApp(filename, isNative = false) {
+    const isInternal = isNative || filename && !filename.startsWith('/') && !filename.match(/^[A-Z]:/) && !filename.startsWith('.') && !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//);
+    return !isInternal && void 0 !== filename && !filename.includes('node_modules/');
+}
+function _parseIntOrUndefined(input) {
+    return parseInt(input || '', 10) || void 0;
+}
+function nodeStackLineParser(getModule) {
+    return [
+        90,
+        node(getModule)
+    ];
+}
+function createStackParser(getModule) {
+    const parsers = [
+        nodeStackLineParser(getModule)
+    ];
+    const sortedParsers = parsers.sort((a, b)=>a[0] - b[0]).map((p)=>p[1]);
+    return (stack, skipFirstLines = 0)=>{
+        const frames = [];
+        const lines = stack.split('\n');
+        for(let i = skipFirstLines; i < lines.length; i++){
+            const line = lines[i];
+            if (line.length > 1024) continue;
+            const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
+            if (!cleanedLine.match(/\S*Error: /)) {
+                for (const parser of sortedParsers){
+                    const frame = parser(cleanedLine);
+                    if (frame) {
+                        frames.push(frame);
+                        break;
+                    }
+                }
+                if (frames.length >= STACKTRACE_FRAME_LIMIT) break;
+            }
+        }
+        return reverseAndStripFrames(frames);
+    };
+}
+function reverseAndStripFrames(stack) {
+    if (!stack.length) return [];
+    const localStack = Array.from(stack);
+    localStack.reverse();
+    return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame)=>({
+            ...frame,
+            filename: frame.filename || getLastStackFrame(localStack).filename,
+            function: frame.function || UNKNOWN_FUNCTION
+        }));
+}
+function getLastStackFrame(arr) {
+    return arr[arr.length - 1] || {};
+}
+exports.createStackParser = __webpack_exports__.createStackParser;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createStackParser"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/error-tracking/stack-parser.mjs

@@ -0,0 +1,114 @@
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STACKTRACE_FRAME_LIMIT = 50;
+const UNKNOWN_FUNCTION = '?';
+function node(getModule) {
+    const FILENAME_MATCH = /^\s*[-]{4,}$/;
+    const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+    return (line)=>{
+        const lineMatch = line.match(FULL_MATCH);
+        if (lineMatch) {
+            let object;
+            let method;
+            let functionName;
+            let typeName;
+            let methodName;
+            if (lineMatch[1]) {
+                functionName = lineMatch[1];
+                let methodStart = functionName.lastIndexOf('.');
+                if ('.' === functionName[methodStart - 1]) methodStart--;
+                if (methodStart > 0) {
+                    object = functionName.slice(0, methodStart);
+                    method = functionName.slice(methodStart + 1);
+                    const objectEnd = object.indexOf('.Module');
+                    if (objectEnd > 0) {
+                        functionName = functionName.slice(objectEnd + 1);
+                        object = object.slice(0, objectEnd);
+                    }
+                }
+                typeName = void 0;
+            }
+            if (method) {
+                typeName = object;
+                methodName = method;
+            }
+            if ('<anonymous>' === method) {
+                methodName = void 0;
+                functionName = void 0;
+            }
+            if (void 0 === functionName) {
+                methodName = methodName || UNKNOWN_FUNCTION;
+                functionName = typeName ? `${typeName}.${methodName}` : methodName;
+            }
+            let filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2];
+            const isNative = 'native' === lineMatch[5];
+            if (filename?.match(/\/[A-Z]:/)) filename = filename.slice(1);
+            if (!filename && lineMatch[5] && !isNative) filename = lineMatch[5];
+            return {
+                filename: filename ? decodeURI(filename) : void 0,
+                module: getModule ? getModule(filename) : void 0,
+                function: functionName,
+                lineno: _parseIntOrUndefined(lineMatch[3]),
+                colno: _parseIntOrUndefined(lineMatch[4]),
+                in_app: filenameIsInApp(filename || '', isNative),
+                platform: "node:javascript"
+            };
+        }
+        if (line.match(FILENAME_MATCH)) return {
+            filename: line,
+            platform: "node:javascript"
+        };
+    };
+}
+function filenameIsInApp(filename, isNative = false) {
+    const isInternal = isNative || filename && !filename.startsWith('/') && !filename.match(/^[A-Z]:/) && !filename.startsWith('.') && !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//);
+    return !isInternal && void 0 !== filename && !filename.includes('node_modules/');
+}
+function _parseIntOrUndefined(input) {
+    return parseInt(input || '', 10) || void 0;
+}
+function nodeStackLineParser(getModule) {
+    return [
+        90,
+        node(getModule)
+    ];
+}
+function createStackParser(getModule) {
+    const parsers = [
+        nodeStackLineParser(getModule)
+    ];
+    const sortedParsers = parsers.sort((a, b)=>a[0] - b[0]).map((p)=>p[1]);
+    return (stack, skipFirstLines = 0)=>{
+        const frames = [];
+        const lines = stack.split('\n');
+        for(let i = skipFirstLines; i < lines.length; i++){
+            const line = lines[i];
+            if (line.length > 1024) continue;
+            const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
+            if (!cleanedLine.match(/\S*Error: /)) {
+                for (const parser of sortedParsers){
+                    const frame = parser(cleanedLine);
+                    if (frame) {
+                        frames.push(frame);
+                        break;
+                    }
+                }
+                if (frames.length >= STACKTRACE_FRAME_LIMIT) break;
+            }
+        }
+        return reverseAndStripFrames(frames);
+    };
+}
+function reverseAndStripFrames(stack) {
+    if (!stack.length) return [];
+    const localStack = Array.from(stack);
+    localStack.reverse();
+    return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame)=>({
+            ...frame,
+            filename: frame.filename || getLastStackFrame(localStack).filename,
+            function: frame.function || UNKNOWN_FUNCTION
+        }));
+}
+function getLastStackFrame(arr) {
+    return arr[arr.length - 1] || {};
+}
+export { createStackParser };

package/dist/extensions/error-tracking/type-checking.d.ts

@@ -0,0 +1,8 @@
+import { PolymorphicEvent } from './types';
+export declare function isEvent(candidate: unknown): candidate is PolymorphicEvent;
+export declare function isPlainObject(candidate: unknown): candidate is Record<string, unknown>;
+export declare function isError(candidate: unknown): candidate is Error;
+export declare function isInstanceOf(candidate: unknown, base: any): boolean;
+export declare function isErrorEvent(event: unknown): boolean;
+export declare function isBuiltin(candidate: unknown, className: string): boolean;
+//# sourceMappingURL=type-checking.d.ts.map

package/dist/extensions/error-tracking/type-checking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checking.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/type-checking.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE1C,wBAAgB,OAAO,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,gBAAgB,CAEzE;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtF;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,KAAK,CAU9D;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAMnE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEpD;AAED,wBAAgB,SAAS,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAExE"}

package/dist/extensions/error-tracking/type-checking.js

@@ -0,0 +1,80 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isBuiltin: ()=>isBuiltin,
+    isError: ()=>isError,
+    isErrorEvent: ()=>isErrorEvent,
+    isEvent: ()=>isEvent,
+    isInstanceOf: ()=>isInstanceOf,
+    isPlainObject: ()=>isPlainObject
+});
+function isEvent(candidate) {
+    return 'undefined' != typeof Event && isInstanceOf(candidate, Event);
+}
+function isPlainObject(candidate) {
+    return isBuiltin(candidate, 'Object');
+}
+function isError(candidate) {
+    switch(Object.prototype.toString.call(candidate)){
+        case '[object Error]':
+        case '[object Exception]':
+        case '[object DOMException]':
+        case '[object WebAssembly.Exception]':
+            return true;
+        default:
+            return isInstanceOf(candidate, Error);
+    }
+}
+function isInstanceOf(candidate, base) {
+    try {
+        return candidate instanceof base;
+    } catch  {
+        return false;
+    }
+}
+function isErrorEvent(event) {
+    return isBuiltin(event, 'ErrorEvent');
+}
+function isBuiltin(candidate, className) {
+    return Object.prototype.toString.call(candidate) === `[object ${className}]`;
+}
+exports.isBuiltin = __webpack_exports__.isBuiltin;
+exports.isError = __webpack_exports__.isError;
+exports.isErrorEvent = __webpack_exports__.isErrorEvent;
+exports.isEvent = __webpack_exports__.isEvent;
+exports.isInstanceOf = __webpack_exports__.isInstanceOf;
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isBuiltin",
+    "isError",
+    "isErrorEvent",
+    "isEvent",
+    "isInstanceOf",
+    "isPlainObject"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/error-tracking/type-checking.mjs

@@ -0,0 +1,31 @@
+function isEvent(candidate) {
+    return 'undefined' != typeof Event && isInstanceOf(candidate, Event);
+}
+function isPlainObject(candidate) {
+    return isBuiltin(candidate, 'Object');
+}
+function isError(candidate) {
+    switch(Object.prototype.toString.call(candidate)){
+        case '[object Error]':
+        case '[object Exception]':
+        case '[object DOMException]':
+        case '[object WebAssembly.Exception]':
+            return true;
+        default:
+            return isInstanceOf(candidate, Error);
+    }
+}
+function isInstanceOf(candidate, base) {
+    try {
+        return candidate instanceof base;
+    } catch  {
+        return false;
+    }
+}
+function isErrorEvent(event) {
+    return isBuiltin(event, 'ErrorEvent');
+}
+function isBuiltin(candidate, className) {
+    return Object.prototype.toString.call(candidate) === `[object ${className}]`;
+}
+export { isBuiltin, isError, isErrorEvent, isEvent, isInstanceOf, isPlainObject };