posthog-node 5.8.8 → 5.9.0

package/dist/extensions/error-tracking/context-lines.node.mjs

@@ -0,0 +1,187 @@
+import { ReduceableCache } from "./reduceable-cache.mjs";
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+const LRU_FILE_CONTENTS_CACHE = new ReduceableCache(25);
+const LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache(20);
+const DEFAULT_LINES_OF_CONTEXT = 7;
+const MAX_CONTEXTLINES_COLNO = 1000;
+const MAX_CONTEXTLINES_LINENO = 10000;
+async function addSourceContext(frames) {
+    const filesToLines = {};
+    for(let i = frames.length - 1; i >= 0; i--){
+        const frame = frames[i];
+        const filename = frame?.filename;
+        if (!frame || 'string' != typeof filename || 'number' != typeof frame.lineno || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame)) continue;
+        const filesToLinesOutput = filesToLines[filename];
+        if (!filesToLinesOutput) filesToLines[filename] = [];
+        filesToLines[filename].push(frame.lineno);
+    }
+    const files = Object.keys(filesToLines);
+    if (0 == files.length) return frames;
+    const readlinePromises = [];
+    for (const file of files){
+        if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) continue;
+        const filesToLineRanges = filesToLines[file];
+        if (!filesToLineRanges) continue;
+        filesToLineRanges.sort((a, b)=>a - b);
+        const ranges = makeLineReaderRanges(filesToLineRanges);
+        if (ranges.every((r)=>rangeExistsInContentCache(file, r))) continue;
+        const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
+        readlinePromises.push(getContextLinesFromFile(file, ranges, cache));
+    }
+    await Promise.all(readlinePromises).catch(()=>{});
+    if (frames && frames.length > 0) addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE);
+    LRU_FILE_CONTENTS_CACHE.reduce();
+    return frames;
+}
+function getContextLinesFromFile(path, ranges, output) {
+    return new Promise((resolve)=>{
+        const stream = createReadStream(path);
+        const lineReaded = createInterface({
+            input: stream
+        });
+        function destroyStreamAndResolve() {
+            stream.destroy();
+            resolve();
+        }
+        let lineNumber = 0;
+        let currentRangeIndex = 0;
+        const range = ranges[currentRangeIndex];
+        if (void 0 === range) return void destroyStreamAndResolve();
+        let rangeStart = range[0];
+        let rangeEnd = range[1];
+        function onStreamError() {
+            LRU_FILE_CONTENTS_FS_READ_FAILED.set(path, 1);
+            lineReaded.close();
+            lineReaded.removeAllListeners();
+            destroyStreamAndResolve();
+        }
+        stream.on('error', onStreamError);
+        lineReaded.on('error', onStreamError);
+        lineReaded.on('close', destroyStreamAndResolve);
+        lineReaded.on('line', (line)=>{
+            lineNumber++;
+            if (lineNumber < rangeStart) return;
+            output[lineNumber] = snipLine(line, 0);
+            if (lineNumber >= rangeEnd) {
+                if (currentRangeIndex === ranges.length - 1) {
+                    lineReaded.close();
+                    lineReaded.removeAllListeners();
+                    return;
+                }
+                currentRangeIndex++;
+                const range = ranges[currentRangeIndex];
+                if (void 0 === range) {
+                    lineReaded.close();
+                    lineReaded.removeAllListeners();
+                    return;
+                }
+                rangeStart = range[0];
+                rangeEnd = range[1];
+            }
+        });
+    });
+}
+function addSourceContextToFrames(frames, cache) {
+    for (const frame of frames)if (frame.filename && void 0 === frame.context_line && 'number' == typeof frame.lineno) {
+        const contents = cache.get(frame.filename);
+        if (void 0 === contents) continue;
+        addContextToFrame(frame.lineno, frame, contents);
+    }
+}
+function addContextToFrame(lineno, frame, contents) {
+    if (void 0 === frame.lineno || void 0 === contents) return;
+    frame.pre_context = [];
+    for(let i = makeRangeStart(lineno); i < lineno; i++){
+        const line = contents[i];
+        if (void 0 === line) return void clearLineContext(frame);
+        frame.pre_context.push(line);
+    }
+    if (void 0 === contents[lineno]) return void clearLineContext(frame);
+    frame.context_line = contents[lineno];
+    const end = makeRangeEnd(lineno);
+    frame.post_context = [];
+    for(let i = lineno + 1; i <= end; i++){
+        const line = contents[i];
+        if (void 0 === line) break;
+        frame.post_context.push(line);
+    }
+}
+function clearLineContext(frame) {
+    delete frame.pre_context;
+    delete frame.context_line;
+    delete frame.post_context;
+}
+function shouldSkipContextLinesForFile(path) {
+    return path.startsWith('node:') || path.endsWith('.min.js') || path.endsWith('.min.cjs') || path.endsWith('.min.mjs') || path.startsWith('data:');
+}
+function shouldSkipContextLinesForFrame(frame) {
+    if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
+    if (void 0 !== frame.colno && frame.colno > MAX_CONTEXTLINES_COLNO) return true;
+    return false;
+}
+function rangeExistsInContentCache(file, range) {
+    const contents = LRU_FILE_CONTENTS_CACHE.get(file);
+    if (void 0 === contents) return false;
+    for(let i = range[0]; i <= range[1]; i++)if (void 0 === contents[i]) return false;
+    return true;
+}
+function makeLineReaderRanges(lines) {
+    if (!lines.length) return [];
+    let i = 0;
+    const line = lines[0];
+    if ('number' != typeof line) return [];
+    let current = makeContextRange(line);
+    const out = [];
+    while(true){
+        if (i === lines.length - 1) {
+            out.push(current);
+            break;
+        }
+        const next = lines[i + 1];
+        if ('number' != typeof next) break;
+        if (next <= current[1]) current[1] = next + DEFAULT_LINES_OF_CONTEXT;
+        else {
+            out.push(current);
+            current = makeContextRange(next);
+        }
+        i++;
+    }
+    return out;
+}
+function makeContextRange(line) {
+    return [
+        makeRangeStart(line),
+        makeRangeEnd(line)
+    ];
+}
+function makeRangeStart(line) {
+    return Math.max(1, line - DEFAULT_LINES_OF_CONTEXT);
+}
+function makeRangeEnd(line) {
+    return line + DEFAULT_LINES_OF_CONTEXT;
+}
+function emplace(map, key, contents) {
+    const value = map.get(key);
+    if (void 0 === value) {
+        map.set(key, contents);
+        return contents;
+    }
+    return value;
+}
+function snipLine(line, colno) {
+    let newLine = line;
+    const lineLength = newLine.length;
+    if (lineLength <= 150) return newLine;
+    if (colno > lineLength) colno = lineLength;
+    let start = Math.max(colno - 60, 0);
+    if (start < 5) start = 0;
+    let end = Math.min(start + 140, lineLength);
+    if (end > lineLength - 5) end = lineLength;
+    if (end === lineLength) start = Math.max(end - 140, 0);
+    newLine = newLine.slice(start, end);
+    if (start > 0) newLine = `...${newLine}`;
+    if (end < lineLength) newLine += '...';
+    return newLine;
+}
+export { MAX_CONTEXTLINES_COLNO, MAX_CONTEXTLINES_LINENO, addSourceContext };

package/dist/extensions/error-tracking/error-conversion.d.ts

@@ -0,0 +1,4 @@
+import { ErrorProperties, EventHint, StackFrame, StackFrameModifierFn, StackParser } from './types';
+export declare function propertiesFromUnknownInput(stackParser: StackParser, frameModifiers: StackFrameModifierFn[], input: unknown, hint?: EventHint): Promise<ErrorProperties>;
+export declare function applyChunkIds(frames: StackFrame[], parser: StackParser): StackFrame[];
+//# sourceMappingURL=error-conversion.d.ts.map

package/dist/extensions/error-tracking/error-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-conversion.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/error-conversion.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,eAAe,EACf,SAAS,EAGT,UAAU,EACV,oBAAoB,EACpB,WAAW,EACZ,MAAM,SAAS,CAAA;AAEhB,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,oBAAoB,EAAE,EACtC,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,SAAS,GACf,OAAO,CAAC,eAAe,CAAC,CAoB1B;AAiPD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,EAAE,CASrF"}

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

@@ -0,0 +1,183 @@
+"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__, {
+    propertiesFromUnknownInput: ()=>propertiesFromUnknownInput,
+    applyChunkIds: ()=>applyChunkIds
+});
+const external_chunk_ids_js_namespaceObject = require("./chunk-ids.js");
+const external_type_checking_js_namespaceObject = require("./type-checking.js");
+async function propertiesFromUnknownInput(stackParser, frameModifiers, input, hint) {
+    const providedMechanism = hint && hint.mechanism;
+    const mechanism = providedMechanism || {
+        handled: true,
+        type: 'generic'
+    };
+    const errorList = getErrorList(mechanism, input, hint);
+    const exceptionList = await Promise.all(errorList.map(async (error)=>{
+        const exception = await exceptionFromError(stackParser, frameModifiers, error);
+        exception.value = exception.value || '';
+        exception.type = exception.type || 'Error';
+        exception.mechanism = mechanism;
+        return exception;
+    }));
+    const properties = {
+        $exception_list: exceptionList
+    };
+    return properties;
+}
+function getErrorList(mechanism, input, hint) {
+    const error = getError(mechanism, input, hint);
+    if (error.cause) return [
+        error,
+        ...getErrorList(mechanism, error.cause, hint)
+    ];
+    return [
+        error
+    ];
+}
+function getError(mechanism, exception, hint) {
+    if ((0, external_type_checking_js_namespaceObject.isError)(exception)) return exception;
+    mechanism.synthetic = true;
+    if ((0, external_type_checking_js_namespaceObject.isPlainObject)(exception)) {
+        const errorFromProp = getErrorPropertyFromObject(exception);
+        if (errorFromProp) return errorFromProp;
+        const message = getMessageForObject(exception);
+        const ex = hint?.syntheticException || new Error(message);
+        ex.message = message;
+        return ex;
+    }
+    const ex = hint?.syntheticException || new Error(exception);
+    ex.message = `${exception}`;
+    return ex;
+}
+function getErrorPropertyFromObject(obj) {
+    for(const prop in obj)if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+        const value = obj[prop];
+        if ((0, external_type_checking_js_namespaceObject.isError)(value)) return value;
+    }
+}
+function getMessageForObject(exception) {
+    if ('name' in exception && 'string' == typeof exception.name) {
+        let message = `'${exception.name}' captured as exception`;
+        if ('message' in exception && 'string' == typeof exception.message) message += ` with message '${exception.message}'`;
+        return message;
+    }
+    if ('message' in exception && 'string' == typeof exception.message) return exception.message;
+    const keys = extractExceptionKeysForMessage(exception);
+    if ((0, external_type_checking_js_namespaceObject.isErrorEvent)(exception)) return `Event \`ErrorEvent\` captured as exception with message \`${exception.message}\``;
+    const className = getObjectClassName(exception);
+    return `${className && 'Object' !== className ? `'${className}'` : 'Object'} captured as exception with keys: ${keys}`;
+}
+function getObjectClassName(obj) {
+    try {
+        const prototype = Object.getPrototypeOf(obj);
+        return prototype ? prototype.constructor.name : void 0;
+    } catch (e) {}
+}
+function extractExceptionKeysForMessage(exception, maxLength = 40) {
+    const keys = Object.keys(convertToPlainObject(exception));
+    keys.sort();
+    const firstKey = keys[0];
+    if (!firstKey) return '[object has no keys]';
+    if (firstKey.length >= maxLength) return truncate(firstKey, maxLength);
+    for(let includedKeys = keys.length; includedKeys > 0; includedKeys--){
+        const serialized = keys.slice(0, includedKeys).join(', ');
+        if (!(serialized.length > maxLength)) {
+            if (includedKeys === keys.length) return serialized;
+            return truncate(serialized, maxLength);
+        }
+    }
+    return '';
+}
+function truncate(str, max = 0) {
+    if ('string' != typeof str || 0 === max) return str;
+    return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+function convertToPlainObject(value) {
+    if ((0, external_type_checking_js_namespaceObject.isError)(value)) return {
+        message: value.message,
+        name: value.name,
+        stack: value.stack,
+        ...getOwnProperties(value)
+    };
+    if (!(0, external_type_checking_js_namespaceObject.isEvent)(value)) return value;
+    {
+        const newObj = {
+            type: value.type,
+            target: serializeEventTarget(value.target),
+            currentTarget: serializeEventTarget(value.currentTarget),
+            ...getOwnProperties(value)
+        };
+        return newObj;
+    }
+}
+function getOwnProperties(obj) {
+    if ('object' != typeof obj || null === obj) return {};
+    {
+        const extractedProps = {};
+        for(const property in obj)if (Object.prototype.hasOwnProperty.call(obj, property)) extractedProps[property] = obj[property];
+        return extractedProps;
+    }
+}
+function serializeEventTarget(target) {
+    try {
+        return Object.prototype.toString.call(target);
+    } catch (_oO) {
+        return '<unknown>';
+    }
+}
+async function exceptionFromError(stackParser, frameModifiers, error) {
+    const exception = {
+        type: error.name || error.constructor.name,
+        value: error.message
+    };
+    let frames = parseStackFrames(stackParser, error);
+    for (const modifier of frameModifiers)frames = await modifier(frames);
+    if (frames.length) exception.stacktrace = {
+        frames,
+        type: 'raw'
+    };
+    return exception;
+}
+function parseStackFrames(stackParser, error) {
+    return applyChunkIds(stackParser(error.stack || '', 1), stackParser);
+}
+function applyChunkIds(frames, parser) {
+    const filenameChunkIdMap = (0, external_chunk_ids_js_namespaceObject.getFilenameToChunkIdMap)(parser);
+    frames.forEach((frame)=>{
+        if (frame.filename && filenameChunkIdMap) frame.chunk_id = filenameChunkIdMap[frame.filename];
+    });
+    return frames;
+}
+exports.applyChunkIds = __webpack_exports__.applyChunkIds;
+exports.propertiesFromUnknownInput = __webpack_exports__.propertiesFromUnknownInput;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "applyChunkIds",
+    "propertiesFromUnknownInput"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,146 @@
+import { getFilenameToChunkIdMap } from "./chunk-ids.mjs";
+import { isError, isErrorEvent, isEvent, isPlainObject } from "./type-checking.mjs";
+async function propertiesFromUnknownInput(stackParser, frameModifiers, input, hint) {
+    const providedMechanism = hint && hint.mechanism;
+    const mechanism = providedMechanism || {
+        handled: true,
+        type: 'generic'
+    };
+    const errorList = getErrorList(mechanism, input, hint);
+    const exceptionList = await Promise.all(errorList.map(async (error)=>{
+        const exception = await exceptionFromError(stackParser, frameModifiers, error);
+        exception.value = exception.value || '';
+        exception.type = exception.type || 'Error';
+        exception.mechanism = mechanism;
+        return exception;
+    }));
+    const properties = {
+        $exception_list: exceptionList
+    };
+    return properties;
+}
+function getErrorList(mechanism, input, hint) {
+    const error = getError(mechanism, input, hint);
+    if (error.cause) return [
+        error,
+        ...getErrorList(mechanism, error.cause, hint)
+    ];
+    return [
+        error
+    ];
+}
+function getError(mechanism, exception, hint) {
+    if (isError(exception)) return exception;
+    mechanism.synthetic = true;
+    if (isPlainObject(exception)) {
+        const errorFromProp = getErrorPropertyFromObject(exception);
+        if (errorFromProp) return errorFromProp;
+        const message = getMessageForObject(exception);
+        const ex = hint?.syntheticException || new Error(message);
+        ex.message = message;
+        return ex;
+    }
+    const ex = hint?.syntheticException || new Error(exception);
+    ex.message = `${exception}`;
+    return ex;
+}
+function getErrorPropertyFromObject(obj) {
+    for(const prop in obj)if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+        const value = obj[prop];
+        if (isError(value)) return value;
+    }
+}
+function getMessageForObject(exception) {
+    if ('name' in exception && 'string' == typeof exception.name) {
+        let message = `'${exception.name}' captured as exception`;
+        if ('message' in exception && 'string' == typeof exception.message) message += ` with message '${exception.message}'`;
+        return message;
+    }
+    if ('message' in exception && 'string' == typeof exception.message) return exception.message;
+    const keys = extractExceptionKeysForMessage(exception);
+    if (isErrorEvent(exception)) return `Event \`ErrorEvent\` captured as exception with message \`${exception.message}\``;
+    const className = getObjectClassName(exception);
+    return `${className && 'Object' !== className ? `'${className}'` : 'Object'} captured as exception with keys: ${keys}`;
+}
+function getObjectClassName(obj) {
+    try {
+        const prototype = Object.getPrototypeOf(obj);
+        return prototype ? prototype.constructor.name : void 0;
+    } catch (e) {}
+}
+function extractExceptionKeysForMessage(exception, maxLength = 40) {
+    const keys = Object.keys(convertToPlainObject(exception));
+    keys.sort();
+    const firstKey = keys[0];
+    if (!firstKey) return '[object has no keys]';
+    if (firstKey.length >= maxLength) return truncate(firstKey, maxLength);
+    for(let includedKeys = keys.length; includedKeys > 0; includedKeys--){
+        const serialized = keys.slice(0, includedKeys).join(', ');
+        if (!(serialized.length > maxLength)) {
+            if (includedKeys === keys.length) return serialized;
+            return truncate(serialized, maxLength);
+        }
+    }
+    return '';
+}
+function truncate(str, max = 0) {
+    if ('string' != typeof str || 0 === max) return str;
+    return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+function convertToPlainObject(value) {
+    if (isError(value)) return {
+        message: value.message,
+        name: value.name,
+        stack: value.stack,
+        ...getOwnProperties(value)
+    };
+    if (!isEvent(value)) return value;
+    {
+        const newObj = {
+            type: value.type,
+            target: serializeEventTarget(value.target),
+            currentTarget: serializeEventTarget(value.currentTarget),
+            ...getOwnProperties(value)
+        };
+        return newObj;
+    }
+}
+function getOwnProperties(obj) {
+    if ('object' != typeof obj || null === obj) return {};
+    {
+        const extractedProps = {};
+        for(const property in obj)if (Object.prototype.hasOwnProperty.call(obj, property)) extractedProps[property] = obj[property];
+        return extractedProps;
+    }
+}
+function serializeEventTarget(target) {
+    try {
+        return Object.prototype.toString.call(target);
+    } catch (_oO) {
+        return '<unknown>';
+    }
+}
+async function exceptionFromError(stackParser, frameModifiers, error) {
+    const exception = {
+        type: error.name || error.constructor.name,
+        value: error.message
+    };
+    let frames = parseStackFrames(stackParser, error);
+    for (const modifier of frameModifiers)frames = await modifier(frames);
+    if (frames.length) exception.stacktrace = {
+        frames,
+        type: 'raw'
+    };
+    return exception;
+}
+function parseStackFrames(stackParser, error) {
+    return applyChunkIds(stackParser(error.stack || '', 1), stackParser);
+}
+function applyChunkIds(frames, parser) {
+    const filenameChunkIdMap = getFilenameToChunkIdMap(parser);
+    frames.forEach((frame)=>{
+        if (frame.filename && filenameChunkIdMap) frame.chunk_id = filenameChunkIdMap[frame.filename];
+    });
+    return frames;
+}
+export { applyChunkIds, propertiesFromUnknownInput };

package/dist/extensions/error-tracking/get-module.node.d.ts

@@ -0,0 +1,3 @@
+/** Creates a function that gets the module name from a filename */
+export declare function createGetModuleFromFilename(basePath?: string, isWindows?: boolean): (filename: string | undefined) => string | undefined;
+//# sourceMappingURL=get-module.node.d.ts.map

package/dist/extensions/error-tracking/get-module.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-module.node.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/get-module.node.ts"],"names":[],"mappings":"AAKA,mEAAmE;AACnE,wBAAgB,2BAA2B,CACzC,QAAQ,GAAE,MAAmE,EAC7E,SAAS,GAAE,OAAsB,GAChC,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,GAAG,SAAS,CAwCtD"}

package/dist/extensions/error-tracking/get-module.node.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__, {
+    createGetModuleFromFilename: ()=>createGetModuleFromFilename
+});
+const external_path_namespaceObject = require("path");
+function createGetModuleFromFilename(basePath = process.argv[1] ? (0, external_path_namespaceObject.dirname)(process.argv[1]) : process.cwd(), isWindows = '\\' === external_path_namespaceObject.sep) {
+    const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
+    return (filename)=>{
+        if (!filename) return;
+        const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
+        let { dir, base: file, ext } = external_path_namespaceObject.posix.parse(normalizedFilename);
+        if ('.js' === ext || '.mjs' === ext || '.cjs' === ext) file = file.slice(0, -1 * ext.length);
+        const decodedFile = decodeURIComponent(file);
+        if (!dir) dir = '.';
+        const n = dir.lastIndexOf('/node_modules');
+        if (n > -1) return `${dir.slice(n + 14).replace(/\//g, '.')}:${decodedFile}`;
+        if (dir.startsWith(normalizedBase)) {
+            const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, '.');
+            return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
+        }
+        return decodedFile;
+    };
+}
+function normalizeWindowsPath(path) {
+    return path.replace(/^[A-Z]:/, '').replace(/\\/g, '/');
+}
+exports.createGetModuleFromFilename = __webpack_exports__.createGetModuleFromFilename;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createGetModuleFromFilename"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/error-tracking/get-module.node.mjs

@@ -0,0 +1,23 @@
+import { dirname, posix, sep } from "path";
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname(process.argv[1]) : process.cwd(), isWindows = '\\' === sep) {
+    const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
+    return (filename)=>{
+        if (!filename) return;
+        const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
+        let { dir, base: file, ext } = posix.parse(normalizedFilename);
+        if ('.js' === ext || '.mjs' === ext || '.cjs' === ext) file = file.slice(0, -1 * ext.length);
+        const decodedFile = decodeURIComponent(file);
+        if (!dir) dir = '.';
+        const n = dir.lastIndexOf('/node_modules');
+        if (n > -1) return `${dir.slice(n + 14).replace(/\//g, '.')}:${decodedFile}`;
+        if (dir.startsWith(normalizedBase)) {
+            const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, '.');
+            return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
+        }
+        return decodedFile;
+    };
+}
+function normalizeWindowsPath(path) {
+    return path.replace(/^[A-Z]:/, '').replace(/\\/g, '/');
+}
+export { createGetModuleFromFilename };

package/dist/extensions/error-tracking/index.d.ts

@@ -0,0 +1,20 @@
+import { EventHint, StackFrameModifierFn, StackParser } from './types';
+import { PostHogBackendClient } from '../../client';
+import { EventMessage, PostHogOptions } from '../../types';
+import type { Logger } from '@posthog/core';
+export default class ErrorTracking {
+    private client;
+    private _exceptionAutocaptureEnabled;
+    private _rateLimiter;
+    private _logger;
+    static stackParser: StackParser;
+    static frameModifiers: StackFrameModifierFn[];
+    constructor(client: PostHogBackendClient, options: PostHogOptions, _logger: Logger);
+    static buildEventMessage(error: unknown, hint: EventHint, distinctId?: string, additionalProperties?: Record<string | number, any>): Promise<EventMessage>;
+    private startAutocaptureIfEnabled;
+    private onException;
+    private onFatalError;
+    isEnabled(): boolean;
+    shutdown(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/error-tracking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAEtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAGnD,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAK3C,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,4BAA4B,CAAS;IAC7C,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,OAAO,CAAQ;IAEvB,MAAM,CAAC,WAAW,EAAE,WAAW,CAAA;IAC/B,MAAM,CAAC,cAAc,EAAE,oBAAoB,EAAE,CAAA;gBAEjC,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM;WAkBrE,iBAAiB,CAC5B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,GAClD,OAAO,CAAC,YAAY,CAAC;IAqBxB,OAAO,CAAC,yBAAyB;YAOnB,WAAW;YAkBX,YAAY;IAM1B,SAAS,IAAI,OAAO;IAIpB,QAAQ,IAAI,IAAI;CAGjB"}