posthog-node 5.8.8 → 5.9.0

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 { EventHint } from './types';
+export declare function addUncaughtExceptionListener(captureFn: (exception: Error, hint: EventHint) => void, onFatalFn: (exception: Error) => void): void;
+export declare function addUnhandledRejectionListener(captureFn: (exception: unknown, hint: 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,SAAS,EAAE,MAAM,SAAS,CAAA;AA6CnC,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,EACtD,SAAS,EAAE,CAAC,SAAS,EAAE,KAAK,KAAK,IAAI,GACpC,IAAI,CAEN;AAED,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,GAAG,IAAI,CAS5G"}

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/chunk-ids.d.ts

@@ -0,0 +1,5 @@
+import type { StackParser } from './types';
+type ChunkIdMapType = Record<string, string>;
+export declare function getFilenameToChunkIdMap(stackParser: StackParser): ChunkIdMapType | null;
+export {};
+//# sourceMappingURL=chunk-ids.d.ts.map

package/dist/extensions/error-tracking/chunk-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-ids.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/chunk-ids.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAK1C,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAM5C,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,cAAc,GAAG,IAAI,CA2CvF"}

package/dist/extensions/error-tracking/chunk-ids.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__, {
+    getFilenameToChunkIdMap: ()=>getFilenameToChunkIdMap
+});
+let parsedStackResults;
+let lastKeysCount;
+let cachedFilenameChunkIds;
+function getFilenameToChunkIdMap(stackParser) {
+    const chunkIdMap = globalThis._posthogChunkIds;
+    if (!chunkIdMap) return null;
+    const chunkIdKeys = Object.keys(chunkIdMap);
+    if (cachedFilenameChunkIds && chunkIdKeys.length === lastKeysCount) return cachedFilenameChunkIds;
+    lastKeysCount = chunkIdKeys.length;
+    cachedFilenameChunkIds = chunkIdKeys.reduce((acc, stackKey)=>{
+        if (!parsedStackResults) parsedStackResults = {};
+        const result = parsedStackResults[stackKey];
+        if (result) acc[result[0]] = result[1];
+        else {
+            const parsedStack = stackParser(stackKey);
+            for(let i = parsedStack.length - 1; i >= 0; i--){
+                const stackFrame = parsedStack[i];
+                const filename = stackFrame?.filename;
+                const chunkId = chunkIdMap[stackKey];
+                if (filename && chunkId) {
+                    acc[filename] = chunkId;
+                    parsedStackResults[stackKey] = [
+                        filename,
+                        chunkId
+                    ];
+                    break;
+                }
+            }
+        }
+        return acc;
+    }, {});
+    return cachedFilenameChunkIds;
+}
+exports.getFilenameToChunkIdMap = __webpack_exports__.getFilenameToChunkIdMap;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getFilenameToChunkIdMap"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/error-tracking/chunk-ids.mjs

@@ -0,0 +1,34 @@
+let parsedStackResults;
+let lastKeysCount;
+let cachedFilenameChunkIds;
+function getFilenameToChunkIdMap(stackParser) {
+    const chunkIdMap = globalThis._posthogChunkIds;
+    if (!chunkIdMap) return null;
+    const chunkIdKeys = Object.keys(chunkIdMap);
+    if (cachedFilenameChunkIds && chunkIdKeys.length === lastKeysCount) return cachedFilenameChunkIds;
+    lastKeysCount = chunkIdKeys.length;
+    cachedFilenameChunkIds = chunkIdKeys.reduce((acc, stackKey)=>{
+        if (!parsedStackResults) parsedStackResults = {};
+        const result = parsedStackResults[stackKey];
+        if (result) acc[result[0]] = result[1];
+        else {
+            const parsedStack = stackParser(stackKey);
+            for(let i = parsedStack.length - 1; i >= 0; i--){
+                const stackFrame = parsedStack[i];
+                const filename = stackFrame?.filename;
+                const chunkId = chunkIdMap[stackKey];
+                if (filename && chunkId) {
+                    acc[filename] = chunkId;
+                    parsedStackResults[stackKey] = [
+                        filename,
+                        chunkId
+                    ];
+                    break;
+                }
+            }
+        }
+        return acc;
+    }, {});
+    return cachedFilenameChunkIds;
+}
+export { getFilenameToChunkIdMap };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-lines.node.d.ts","sourceRoot":"","sources":["../../../src/extensions/error-tracking/context-lines.node.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAWpC,eAAO,MAAM,sBAAsB,EAAE,MAAa,CAAA;AAClD,eAAO,MAAM,uBAAuB,EAAE,MAAc,CAAA;AAIpD,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAuElF"}

package/dist/extensions/error-tracking/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 external_reduceable_cache_js_namespaceObject = require("./reduceable-cache.js");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_readline_namespaceObject = require("node:readline");
+const LRU_FILE_CONTENTS_CACHE = new external_reduceable_cache_js_namespaceObject.ReduceableCache(25);
+const LRU_FILE_CONTENTS_FS_READ_FAILED = new external_reduceable_cache_js_namespaceObject.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
+});