posthog-node 5.8.8 → 5.9.1

package/dist/entrypoints/index.node.mjs

@@ -0,0 +1,24 @@
+import { createModulerModifier } from "../extensions/error-tracking/modifiers/module.node.mjs";
+import { addSourceContext } from "../extensions/error-tracking/modifiers/context-lines.node.mjs";
+import error_tracking from "../extensions/error-tracking/index.mjs";
+import { PostHogBackendClient } from "../client.mjs";
+import { ErrorTracking } from "@posthog/core";
+export * from "../exports.mjs";
+error_tracking.errorPropertiesBuilder = new ErrorTracking.ErrorPropertiesBuilder([
+    new ErrorTracking.EventCoercer(),
+    new ErrorTracking.ErrorCoercer(),
+    new ErrorTracking.ObjectCoercer(),
+    new ErrorTracking.StringCoercer(),
+    new ErrorTracking.PrimitiveCoercer()
+], [
+    ErrorTracking.nodeStackLineParser
+], [
+    createModulerModifier(),
+    addSourceContext
+]);
+class PostHog extends PostHogBackendClient {
+    getLibraryId() {
+        return 'posthog-node';
+    }
+}
+export { PostHog };

package/dist/exports.d.ts

@@ -0,0 +1,4 @@
+export * from './extensions/sentry-integration';
+export * from './extensions/express';
+export * from './types';
+//# sourceMappingURL=exports.d.ts.map

package/dist/exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../src/exports.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sBAAsB,CAAA;AACpC,cAAc,SAAS,CAAA"}

package/dist/exports.js

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_modules__ = {
+    "./extensions/express": function(module) {
+        module.exports = require("./extensions/express.js");
+    },
+    "./extensions/sentry-integration": function(module) {
+        module.exports = require("./extensions/sentry-integration.js");
+    },
+    "./types": function(module) {
+        module.exports = require("./types.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var _extensions_sentry_integration__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./extensions/sentry-integration");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _extensions_sentry_integration__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _extensions_sentry_integration__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _extensions_express__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./extensions/express");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _extensions_express__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _extensions_express__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _types__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./types");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _types__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _types__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/exports.mjs

@@ -0,0 +1,3 @@
+export * from "./extensions/sentry-integration.mjs";
+export * from "./extensions/express.mjs";
+export * from "./types.mjs";

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

@@ -0,0 +1,4 @@
+import { ErrorTracking as CoreErrorTracking } from '@posthog/core';
+export declare function addUncaughtExceptionListener(captureFn: (exception: Error, hint: CoreErrorTracking.EventHint) => void, onFatalFn: (exception: Error) => void): void;
+export declare function addUnhandledRejectionListener(captureFn: (exception: unknown, hint: CoreErrorTracking.EventHint) => void): void;
+//# sourceMappingURL=autocapture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autocapture.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/autocapture.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAA;AA6ClE,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,iBAAiB,CAAC,SAAS,KAAK,IAAI,EACxE,SAAS,EAAE,CAAC,SAAS,EAAE,KAAK,KAAK,IAAI,GACpC,IAAI,CAEN;AAED,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,CAAC,SAAS,KAAK,IAAI,GACzE,IAAI,CASN"}

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

@@ -0,0 +1,68 @@
+"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__, {
+    addUncaughtExceptionListener: ()=>addUncaughtExceptionListener,
+    addUnhandledRejectionListener: ()=>addUnhandledRejectionListener
+});
+function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
+    let calledFatalError = false;
+    return Object.assign((error)=>{
+        const userProvidedListenersCount = global.process.listeners('uncaughtException').filter((listener)=>'domainUncaughtExceptionClear' !== listener.name && true !== listener._posthogErrorHandler).length;
+        const processWouldExit = 0 === userProvidedListenersCount;
+        captureFn(error, {
+            mechanism: {
+                type: 'onuncaughtexception',
+                handled: false
+            }
+        });
+        if (!calledFatalError && processWouldExit) {
+            calledFatalError = true;
+            onFatalFn(error);
+        }
+    }, {
+        _posthogErrorHandler: true
+    });
+}
+function addUncaughtExceptionListener(captureFn, onFatalFn) {
+    global.process.on('uncaughtException', makeUncaughtExceptionHandler(captureFn, onFatalFn));
+}
+function addUnhandledRejectionListener(captureFn) {
+    global.process.on('unhandledRejection', (reason)=>captureFn(reason, {
+            mechanism: {
+                type: 'onunhandledrejection',
+                handled: false
+            }
+        }));
+}
+exports.addUncaughtExceptionListener = __webpack_exports__.addUncaughtExceptionListener;
+exports.addUnhandledRejectionListener = __webpack_exports__.addUnhandledRejectionListener;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "addUncaughtExceptionListener",
+    "addUnhandledRejectionListener"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,31 @@
+function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
+    let calledFatalError = false;
+    return Object.assign((error)=>{
+        const userProvidedListenersCount = global.process.listeners('uncaughtException').filter((listener)=>'domainUncaughtExceptionClear' !== listener.name && true !== listener._posthogErrorHandler).length;
+        const processWouldExit = 0 === userProvidedListenersCount;
+        captureFn(error, {
+            mechanism: {
+                type: 'onuncaughtexception',
+                handled: false
+            }
+        });
+        if (!calledFatalError && processWouldExit) {
+            calledFatalError = true;
+            onFatalFn(error);
+        }
+    }, {
+        _posthogErrorHandler: true
+    });
+}
+function addUncaughtExceptionListener(captureFn, onFatalFn) {
+    global.process.on('uncaughtException', makeUncaughtExceptionHandler(captureFn, onFatalFn));
+}
+function addUnhandledRejectionListener(captureFn) {
+    global.process.on('unhandledRejection', (reason)=>captureFn(reason, {
+            mechanism: {
+                type: 'onunhandledrejection',
+                handled: false
+            }
+        }));
+}
+export { addUncaughtExceptionListener, addUnhandledRejectionListener };

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

@@ -0,0 +1,19 @@
+import { PostHogBackendClient } from '../../client';
+import { EventMessage, PostHogOptions } from '../../types';
+import type { Logger } from '@posthog/core';
+import { ErrorTracking as CoreErrorTracking } from '@posthog/core';
+export default class ErrorTracking {
+    private client;
+    private _exceptionAutocaptureEnabled;
+    private _rateLimiter;
+    private _logger;
+    static errorPropertiesBuilder: CoreErrorTracking.ErrorPropertiesBuilder;
+    constructor(client: PostHogBackendClient, options: PostHogOptions, _logger: Logger);
+    static buildEventMessage(error: unknown, hint: CoreErrorTracking.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":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE/C,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAIlE,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,sBAAsB,EAAE,iBAAiB,CAAC,sBAAsB,CAAA;gBAE3D,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM;WAkBrE,iBAAiB,CAC5B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,CAAC,SAAS,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,GAClD,OAAO,CAAC,YAAY,CAAC;IAwBxB,OAAO,CAAC,yBAAyB;IAOjC,OAAO,CAAC,WAAW;YAkBL,YAAY;IAM1B,SAAS,IAAI,OAAO;IAIpB,QAAQ,IAAI,IAAI;CAGjB"}

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 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 = this.errorPropertiesBuilder.buildFromUnknown(error, hint);
+        exceptionProperties.$exception_list = await this.errorPropertiesBuilder.modifyFrames(exceptionProperties.$exception_list);
+        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));
+        }
+    }
+    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";
+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 = this.errorPropertiesBuilder.buildFromUnknown(error, hint);
+        exceptionProperties.$exception_list = await this.errorPropertiesBuilder.modifyFrames(exceptionProperties.$exception_list);
+        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));
+        }
+    }
+    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/modifiers/context-lines.node.d.ts

@@ -0,0 +1,5 @@
+import { ErrorTracking as CoreErrorTracking } from '@posthog/core';
+export declare const MAX_CONTEXTLINES_COLNO: number;
+export declare const MAX_CONTEXTLINES_LINENO: number;
+export declare function addSourceContext(frames: CoreErrorTracking.StackFrame[]): Promise<CoreErrorTracking.StackFrame[]>;
+//# sourceMappingURL=context-lines.node.d.ts.map

package/dist/extensions/error-tracking/modifiers/context-lines.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-lines.node.d.ts","sourceRoot":"","sources":["../../../../src/extensions/error-tracking/modifiers/context-lines.node.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAUlE,eAAO,MAAM,sBAAsB,EAAE,MAAa,CAAA;AAClD,eAAO,MAAM,uBAAuB,EAAE,MAAc,CAAA;AAIpD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,iBAAiB,CAAC,UAAU,EAAE,GACrC,OAAO,CAAC,iBAAiB,CAAC,UAAU,EAAE,CAAC,CAuEzC"}

package/dist/extensions/error-tracking/modifiers/context-lines.node.js

@@ -0,0 +1,227 @@
+"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__, {
+    MAX_CONTEXTLINES_LINENO: ()=>MAX_CONTEXTLINES_LINENO,
+    MAX_CONTEXTLINES_COLNO: ()=>MAX_CONTEXTLINES_COLNO,
+    addSourceContext: ()=>addSourceContext
+});
+const core_namespaceObject = require("@posthog/core");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_readline_namespaceObject = require("node:readline");
+const LRU_FILE_CONTENTS_CACHE = new core_namespaceObject.ErrorTracking.ReduceableCache(25);
+const LRU_FILE_CONTENTS_FS_READ_FAILED = new core_namespaceObject.ErrorTracking.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 = (0, external_node_fs_namespaceObject.createReadStream)(path);
+        const lineReaded = (0, external_node_readline_namespaceObject.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;
+}
+exports.MAX_CONTEXTLINES_COLNO = __webpack_exports__.MAX_CONTEXTLINES_COLNO;
+exports.MAX_CONTEXTLINES_LINENO = __webpack_exports__.MAX_CONTEXTLINES_LINENO;
+exports.addSourceContext = __webpack_exports__.addSourceContext;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "MAX_CONTEXTLINES_COLNO",
+    "MAX_CONTEXTLINES_LINENO",
+    "addSourceContext"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});