@posthog/core 1.0.2 → 1.2.0

package/dist/error-tracking/coercers/object-coercer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-coercer.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/object-coercer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAiC,MAAM,UAAU,CAAA;AAG9G,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzC,qBAAa,aAAc,YAAW,oBAAoB,CAAC,UAAU,CAAC;IACpE,KAAK,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,UAAU;IAIlD,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,GAAG,SAAS;IAe9E,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAI7C,QAAQ,CAAC,GAAG,EAAE,MAAM;IAmBpB,OAAO,CAAC,eAAe;IAIvB,8EAA8E;IAC9E,OAAO,CAAC,0BAA0B;IAalC,OAAO,CAAC,kBAAkB;CAQ3B"}

package/dist/error-tracking/coercers/object-coercer.js

@@ -0,0 +1,85 @@
+"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__, {
+    ObjectCoercer: ()=>ObjectCoercer
+});
+const index_js_namespaceObject = require("../../utils/index.js");
+const external_types_js_namespaceObject = require("../types.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+class ObjectCoercer {
+    match(candidate) {
+        return 'object' == typeof candidate && null !== candidate;
+    }
+    coerce(candidate, ctx) {
+        const errorProperty = this.getErrorPropertyFromObject(candidate);
+        if (errorProperty) return ctx.apply(errorProperty);
+        return {
+            type: this.getType(candidate),
+            value: this.getValue(candidate),
+            stack: ctx.syntheticException?.stack,
+            level: this.isSeverityLevel(candidate.level) ? candidate.level : 'error',
+            synthetic: true
+        };
+    }
+    getType(err) {
+        return (0, index_js_namespaceObject.isEvent)(err) ? err.constructor.name : 'Error';
+    }
+    getValue(err) {
+        if ('name' in err && 'string' == typeof err.name) {
+            let message = `'${err.name}' captured as exception`;
+            if ('message' in err && 'string' == typeof err.message) message += ` with message: '${err.message}'`;
+            return message;
+        }
+        if ('message' in err && 'string' == typeof err.message) return err.message;
+        const className = this.getObjectClassName(err);
+        const keys = (0, external_utils_js_namespaceObject.extractExceptionKeysForMessage)(err);
+        return `${className && 'Object' !== className ? `'${className}'` : 'Object'} captured as exception with keys: ${keys}`;
+    }
+    isSeverityLevel(x) {
+        return (0, index_js_namespaceObject.isString)(x) && !(0, index_js_namespaceObject.isEmptyString)(x) && external_types_js_namespaceObject.severityLevels.indexOf(x) >= 0;
+    }
+    getErrorPropertyFromObject(obj) {
+        for(const prop in obj)if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+            const value = obj[prop];
+            if ((0, index_js_namespaceObject.isError)(value)) return value;
+        }
+    }
+    getObjectClassName(obj) {
+        try {
+            const prototype = Object.getPrototypeOf(obj);
+            return prototype ? prototype.constructor.name : void 0;
+        } catch (e) {
+            return;
+        }
+    }
+}
+exports.ObjectCoercer = __webpack_exports__.ObjectCoercer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ObjectCoercer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/error-tracking/coercers/object-coercer.mjs

@@ -0,0 +1,51 @@
+import { isEmptyString, isError, isEvent, isString } from "../../utils/index.mjs";
+import { severityLevels } from "../types.mjs";
+import { extractExceptionKeysForMessage } from "./utils.mjs";
+class ObjectCoercer {
+    match(candidate) {
+        return 'object' == typeof candidate && null !== candidate;
+    }
+    coerce(candidate, ctx) {
+        const errorProperty = this.getErrorPropertyFromObject(candidate);
+        if (errorProperty) return ctx.apply(errorProperty);
+        return {
+            type: this.getType(candidate),
+            value: this.getValue(candidate),
+            stack: ctx.syntheticException?.stack,
+            level: this.isSeverityLevel(candidate.level) ? candidate.level : 'error',
+            synthetic: true
+        };
+    }
+    getType(err) {
+        return isEvent(err) ? err.constructor.name : 'Error';
+    }
+    getValue(err) {
+        if ('name' in err && 'string' == typeof err.name) {
+            let message = `'${err.name}' captured as exception`;
+            if ('message' in err && 'string' == typeof err.message) message += ` with message: '${err.message}'`;
+            return message;
+        }
+        if ('message' in err && 'string' == typeof err.message) return err.message;
+        const className = this.getObjectClassName(err);
+        const keys = extractExceptionKeysForMessage(err);
+        return `${className && 'Object' !== className ? `'${className}'` : 'Object'} captured as exception with keys: ${keys}`;
+    }
+    isSeverityLevel(x) {
+        return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x) >= 0;
+    }
+    getErrorPropertyFromObject(obj) {
+        for(const prop in obj)if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+            const value = obj[prop];
+            if (isError(value)) return value;
+        }
+    }
+    getObjectClassName(obj) {
+        try {
+            const prototype = Object.getPrototypeOf(obj);
+            return prototype ? prototype.constructor.name : void 0;
+        } catch (e) {
+            return;
+        }
+    }
+}
+export { ObjectCoercer };

package/dist/error-tracking/coercers/primitive-coercer.d.ts

@@ -0,0 +1,7 @@
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types';
+export type PrimitiveType = null | undefined | boolean | number | string | symbol | bigint;
+export declare class PrimitiveCoercer implements ErrorTrackingCoercer<PrimitiveType> {
+    match(candidate: unknown): candidate is PrimitiveType;
+    coerce(value: PrimitiveType, ctx: CoercingContext): ExceptionLike | undefined;
+}
+//# sourceMappingURL=primitive-coercer.d.ts.map

package/dist/error-tracking/coercers/primitive-coercer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-coercer.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/primitive-coercer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE/E,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;AAE1F,qBAAa,gBAAiB,YAAW,oBAAoB,CAAC,aAAa,CAAC;IAC1E,KAAK,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,aAAa;IAIrD,MAAM,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,GAAG,SAAS;CAQ9E"}

package/dist/error-tracking/coercers/primitive-coercer.js

@@ -0,0 +1,49 @@
+"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__, {
+    PrimitiveCoercer: ()=>PrimitiveCoercer
+});
+const index_js_namespaceObject = require("../../utils/index.js");
+class PrimitiveCoercer {
+    match(candidate) {
+        return (0, index_js_namespaceObject.isPrimitive)(candidate);
+    }
+    coerce(value, ctx) {
+        return {
+            type: 'Error',
+            value: `Primitive value captured as exception: ${String(value)}`,
+            stack: ctx.syntheticException?.stack,
+            synthetic: true
+        };
+    }
+}
+exports.PrimitiveCoercer = __webpack_exports__.PrimitiveCoercer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "PrimitiveCoercer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/error-tracking/coercers/primitive-coercer.mjs

@@ -0,0 +1,15 @@
+import { isPrimitive } from "../../utils/index.mjs";
+class PrimitiveCoercer {
+    match(candidate) {
+        return isPrimitive(candidate);
+    }
+    coerce(value, ctx) {
+        return {
+            type: 'Error',
+            value: `Primitive value captured as exception: ${String(value)}`,
+            stack: ctx.syntheticException?.stack,
+            synthetic: true
+        };
+    }
+}
+export { PrimitiveCoercer };

package/dist/error-tracking/coercers/promise-rejection-event.d.ts

@@ -0,0 +1,7 @@
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types';
+export declare class PromiseRejectionEventCoercer implements ErrorTrackingCoercer<PromiseRejectionEvent> {
+    match(err: unknown): err is PromiseRejectionEvent;
+    coerce(err: PromiseRejectionEvent, ctx: CoercingContext): ExceptionLike | undefined;
+    private getUnhandledRejectionReason;
+}
+//# sourceMappingURL=promise-rejection-event.d.ts.map

package/dist/error-tracking/coercers/promise-rejection-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-rejection-event.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/promise-rejection-event.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAG/E,qBAAa,4BAA6B,YAAW,oBAAoB,CAAC,qBAAqB,CAAC;IAC9F,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,qBAAqB;IAIjD,MAAM,CAAC,GAAG,EAAE,qBAAqB,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,GAAG,SAAS;IAcnF,OAAO,CAAC,2BAA2B;CA6BpC"}

package/dist/error-tracking/coercers/promise-rejection-event.js

@@ -0,0 +1,59 @@
+"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__, {
+    PromiseRejectionEventCoercer: ()=>PromiseRejectionEventCoercer
+});
+const index_js_namespaceObject = require("../../utils/index.js");
+class PromiseRejectionEventCoercer {
+    match(err) {
+        return (0, index_js_namespaceObject.isBuiltin)(err, 'PromiseRejectionEvent');
+    }
+    coerce(err, ctx) {
+        const reason = this.getUnhandledRejectionReason(err);
+        if ((0, index_js_namespaceObject.isPrimitive)(reason)) return {
+            type: 'UnhandledRejection',
+            value: `Non-Error promise rejection captured with value: ${String(reason)}`,
+            stack: ctx.syntheticException?.stack,
+            synthetic: true
+        };
+        return ctx.apply(reason);
+    }
+    getUnhandledRejectionReason(error) {
+        if ((0, index_js_namespaceObject.isPrimitive)(error)) return error;
+        try {
+            if ('reason' in error) return error.reason;
+            if ('detail' in error && 'reason' in error.detail) return error.detail.reason;
+        } catch  {}
+        return error;
+    }
+}
+exports.PromiseRejectionEventCoercer = __webpack_exports__.PromiseRejectionEventCoercer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "PromiseRejectionEventCoercer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/error-tracking/coercers/promise-rejection-event.mjs

@@ -0,0 +1,25 @@
+import { isBuiltin, isPrimitive } from "../../utils/index.mjs";
+class PromiseRejectionEventCoercer {
+    match(err) {
+        return isBuiltin(err, 'PromiseRejectionEvent');
+    }
+    coerce(err, ctx) {
+        const reason = this.getUnhandledRejectionReason(err);
+        if (isPrimitive(reason)) return {
+            type: 'UnhandledRejection',
+            value: `Non-Error promise rejection captured with value: ${String(reason)}`,
+            stack: ctx.syntheticException?.stack,
+            synthetic: true
+        };
+        return ctx.apply(reason);
+    }
+    getUnhandledRejectionReason(error) {
+        if (isPrimitive(error)) return error;
+        try {
+            if ('reason' in error) return error.reason;
+            if ('detail' in error && 'reason' in error.detail) return error.detail.reason;
+        } catch  {}
+        return error;
+    }
+}
+export { PromiseRejectionEventCoercer };

package/dist/error-tracking/coercers/string-coercer.d.ts

@@ -0,0 +1,7 @@
+import { ExceptionLike, ErrorTrackingCoercer, CoercingContext } from '../types';
+export declare class StringCoercer implements ErrorTrackingCoercer<string> {
+    match(input: unknown): input is string;
+    coerce(input: string, ctx: CoercingContext): ExceptionLike;
+    getInfos(candidate: string): [string, string];
+}
+//# sourceMappingURL=string-coercer.d.ts.map

package/dist/error-tracking/coercers/string-coercer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-coercer.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/string-coercer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAK/E,qBAAa,aAAc,YAAW,oBAAoB,CAAC,MAAM,CAAC;IAChE,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM;IAItC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa;IAU1D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAU9C"}

package/dist/error-tracking/coercers/string-coercer.js

@@ -0,0 +1,63 @@
+"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__, {
+    StringCoercer: ()=>StringCoercer
+});
+const ERROR_TYPES_PATTERN = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
+class StringCoercer {
+    match(input) {
+        return 'string' == typeof input;
+    }
+    coerce(input, ctx) {
+        const [type, value] = this.getInfos(input);
+        return {
+            type: type ?? 'Error',
+            value: value ?? input,
+            stack: ctx.syntheticException?.stack,
+            synthetic: true
+        };
+    }
+    getInfos(candidate) {
+        let type = 'Error';
+        let value = candidate;
+        const groups = candidate.match(ERROR_TYPES_PATTERN);
+        if (groups) {
+            type = groups[1];
+            value = groups[2];
+        }
+        return [
+            type,
+            value
+        ];
+    }
+}
+exports.StringCoercer = __webpack_exports__.StringCoercer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "StringCoercer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/error-tracking/coercers/string-coercer.mjs

@@ -0,0 +1,29 @@
+const ERROR_TYPES_PATTERN = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
+class StringCoercer {
+    match(input) {
+        return 'string' == typeof input;
+    }
+    coerce(input, ctx) {
+        const [type, value] = this.getInfos(input);
+        return {
+            type: type ?? 'Error',
+            value: value ?? input,
+            stack: ctx.syntheticException?.stack,
+            synthetic: true
+        };
+    }
+    getInfos(candidate) {
+        let type = 'Error';
+        let value = candidate;
+        const groups = candidate.match(ERROR_TYPES_PATTERN);
+        if (groups) {
+            type = groups[1];
+            value = groups[2];
+        }
+        return [
+            type,
+            value
+        ];
+    }
+}
+export { StringCoercer };

package/dist/error-tracking/coercers/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function truncate(str: string, max?: number): string;
+/**
+ * Given any captured exception, extract its keys and create a sorted
+ * and truncated list that will be used inside the event message.
+ * eg. `Non-error exception captured with keys: foo, bar, baz`
+ */
+export declare function extractExceptionKeysForMessage(err: object, maxLength?: number): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/error-tracking/coercers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/error-tracking/coercers/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAE,MAAU,GAAG,MAAM,CAK7D;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,SAAK,GAAG,MAAM,CAoBlF"}

package/dist/error-tracking/coercers/utils.js

@@ -0,0 +1,55 @@
+"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__, {
+    extractExceptionKeysForMessage: ()=>extractExceptionKeysForMessage,
+    truncate: ()=>truncate
+});
+function truncate(str, max = 0) {
+    if ('string' != typeof str || 0 === max) return str;
+    return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+function extractExceptionKeysForMessage(err, maxLength = 40) {
+    const keys = Object.keys(err);
+    keys.sort();
+    if (!keys.length) return '[object has no keys]';
+    for(let i = keys.length; i > 0; i--){
+        const serialized = keys.slice(0, i).join(', ');
+        if (!(serialized.length > maxLength)) {
+            if (i === keys.length) return serialized;
+            return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`;
+        }
+    }
+    return '';
+}
+exports.extractExceptionKeysForMessage = __webpack_exports__.extractExceptionKeysForMessage;
+exports.truncate = __webpack_exports__.truncate;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "extractExceptionKeysForMessage",
+    "truncate"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/error-tracking/coercers/utils.mjs

@@ -0,0 +1,18 @@
+function truncate(str, max = 0) {
+    if ('string' != typeof str || 0 === max) return str;
+    return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+function extractExceptionKeysForMessage(err, maxLength = 40) {
+    const keys = Object.keys(err);
+    keys.sort();
+    if (!keys.length) return '[object has no keys]';
+    for(let i = keys.length; i > 0; i--){
+        const serialized = keys.slice(0, i).join(', ');
+        if (!(serialized.length > maxLength)) {
+            if (i === keys.length) return serialized;
+            return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`;
+        }
+    }
+    return '';
+}
+export { extractExceptionKeysForMessage, truncate };

package/dist/error-tracking/error-properties-builder.d.ts

@@ -0,0 +1,18 @@
+import { ErrorProperties, ExceptionLike, CoercingContext, StackFrameModifierFn, StackParser, ErrorTrackingCoercer, EventHint, StackLineParser, ParsingContext, Mechanism, ParsedException } from './types';
+export declare class ErrorPropertiesBuilder {
+    private coercers;
+    private modifiers;
+    stackParser: StackParser;
+    constructor(coercers?: ErrorTrackingCoercer<any>[], parsers?: StackLineParser[], modifiers?: StackFrameModifierFn[]);
+    buildFromUnknown(input: unknown, hint?: EventHint): ErrorProperties;
+    coerceFallback(ctx: CoercingContext): ExceptionLike;
+    parseStacktrace(err: ExceptionLike, ctx: ParsingContext): ParsedException;
+    private applyChunkIds;
+    private applyCoercers;
+    private applyModifiers;
+    private modifyFrames;
+    private convertToExceptionList;
+    buildParsingContext(): ParsingContext;
+    buildCoercingContext(mechanism: Mechanism, hint: EventHint, depth?: number): CoercingContext;
+}
+//# sourceMappingURL=error-properties-builder.d.ts.map

package/dist/error-tracking/error-properties-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-properties-builder.d.ts","sourceRoot":"","sources":["../../src/error-tracking/error-properties-builder.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,aAAa,EAEb,eAAe,EAEf,oBAAoB,EACpB,WAAW,EACX,oBAAoB,EACpB,SAAS,EACT,eAAe,EACf,cAAc,EAEd,SAAS,EACT,eAAe,EAEhB,MAAM,SAAS,CAAA;AAIhB,qBAAa,sBAAsB;IAI/B,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,SAAS;IALnB,WAAW,EAAE,WAAW,CAAA;gBAGd,QAAQ,GAAE,oBAAoB,CAAC,GAAG,CAAC,EAAO,EAClD,OAAO,GAAE,eAAe,EAAO,EACvB,SAAS,GAAE,oBAAoB,EAAO;IAKhD,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,SAAc,GAAG,eAAe;IAiBvE,cAAc,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa;IASnD,eAAe,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,cAAc,GAAG,eAAe;IAYzE,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,aAAa;YASP,cAAc;YAQd,YAAY;IAY1B,OAAO,CAAC,sBAAsB;IA6B9B,mBAAmB,IAAI,cAAc;IAOrC,oBAAoB,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,GAAE,MAAU,GAAG,eAAe;CAuBhG"}