error-less 1.0.0

package/dist/index.js

@@ -0,0 +1,854 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+var fs2 = require('fs');
+var pc = require('picocolors');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var pc__default = /*#__PURE__*/_interopDefault(pc);
+
+// src/types.ts
+var defaultConfig = {
+  contextLinesBefore: 2,
+  contextLinesAfter: 2,
+  enableSourceMaps: true,
+  filterNodeModules: true,
+  frameFilter: () => true,
+  showFullStack: false,
+  colors: true
+};
+var INTERNAL_PATTERNS = [
+  /^node:/,
+  /^internal\//,
+  /^events\.js$/,
+  /^_stream_/,
+  /^stream\.js$/,
+  /^module\.js$/,
+  /^loader\.js$/,
+  /^vm\.js$/
+];
+function isInternalPath(filePath) {
+  if (!filePath) return true;
+  if (filePath === "native") return true;
+  for (const pattern of INTERNAL_PATTERNS) {
+    if (pattern.test(filePath)) return true;
+  }
+  if (filePath.includes("internal/") || filePath.includes("internal\\")) {
+    return true;
+  }
+  return false;
+}
+function isNodeModulesPath(filePath) {
+  if (!filePath) return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.includes("/node_modules/") || normalized.includes("\\node_modules\\");
+}
+function getDisplayFunctionName(callSite) {
+  const functionName = callSite.getFunctionName();
+  const methodName = callSite.getMethodName();
+  const typeName = callSite.getTypeName();
+  if (functionName) {
+    if (typeName && functionName !== typeName) {
+      return `${typeName}.${functionName}`;
+    }
+    return functionName;
+  }
+  if (methodName) {
+    if (typeName) {
+      return `${typeName}.${methodName}`;
+    }
+    return methodName;
+  }
+  if (typeName) {
+    return `${typeName}.<anonymous>`;
+  }
+  return null;
+}
+function parseCallSite(callSite) {
+  try {
+    let fileName = callSite.getFileName() ?? callSite.getScriptNameOrSourceURL();
+    const lineNumber = callSite.getLineNumber();
+    const columnNumber = callSite.getColumnNumber();
+    const isNative = callSite.isNative();
+    if (!fileName && !isNative) {
+      return null;
+    }
+    if (fileName == null ? void 0 : fileName.startsWith("file:")) {
+      try {
+        fileName = new URL(fileName).pathname;
+        if (process.platform === "win32" && /^\/[A-Z]:/.test(fileName)) {
+          fileName = fileName.slice(1);
+        }
+      } catch {
+      }
+    }
+    let filePath = fileName ?? "native";
+    if (fileName && !path__namespace.isAbsolute(fileName) && !fileName.startsWith("node:")) {
+      try {
+        filePath = path__namespace.resolve(process.cwd(), fileName);
+      } catch {
+        filePath = fileName;
+      }
+    }
+    const isInternal = isInternalPath(filePath);
+    const isNodeModules = isNodeModulesPath(filePath);
+    const isUserCode = !isInternal && !isNodeModules && !isNative;
+    return {
+      filePath,
+      lineNumber: lineNumber ?? 0,
+      columnNumber: columnNumber ?? 0,
+      functionName: callSite.getFunctionName(),
+      methodName: callSite.getMethodName(),
+      typeName: callSite.getTypeName(),
+      isNative,
+      isNodeModules,
+      isInternal,
+      isUserCode,
+      callSite
+    };
+  } catch {
+    return null;
+  }
+}
+function parseStackTrace(structuredStack) {
+  const frames = [];
+  for (const callSite of structuredStack) {
+    const parsed = parseCallSite(callSite);
+    if (parsed) {
+      frames.push(parsed);
+    }
+  }
+  return frames;
+}
+function findUserCodeFrame(frames) {
+  for (const frame of frames) {
+    if (frame.isUserCode && frame.lineNumber > 0) {
+      return frame;
+    }
+  }
+  for (const frame of frames) {
+    if (!frame.isInternal && !frame.isNative && frame.lineNumber > 0) {
+      return frame;
+    }
+  }
+  for (const frame of frames) {
+    if (frame.lineNumber > 0) {
+      return frame;
+    }
+  }
+  return null;
+}
+function formatFrameAsStackLine(frame) {
+  const funcName = getDisplayFunctionName(frame.callSite) ?? "<anonymous>";
+  const location = frame.isNative ? "native" : `${frame.filePath}:${frame.lineNumber}:${frame.columnNumber}`;
+  return `    at ${funcName} (${location})`;
+}
+function getRelativePath(absolutePath) {
+  try {
+    const cwd = process.cwd();
+    if (absolutePath.startsWith(cwd)) {
+      const relative2 = path__namespace.relative(cwd, absolutePath);
+      if (!relative2.startsWith(".")) {
+        return "./" + relative2.replace(/\\/g, "/");
+      }
+      return relative2.replace(/\\/g, "/");
+    }
+  } catch {
+  }
+  return absolutePath.replace(/\\/g, "/");
+}
+var fileCache = /* @__PURE__ */ new Map();
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var MAX_CACHED_FILES = 50;
+function clearFileCache() {
+  fileCache.clear();
+}
+function readFileLines(filePath) {
+  const cached = fileCache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const stats = fs2__namespace.statSync(filePath);
+    if (stats.size > MAX_FILE_SIZE) {
+      return null;
+    }
+    const content = fs2__namespace.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    if (fileCache.size >= MAX_CACHED_FILES) {
+      const firstKey = fileCache.keys().next().value;
+      if (firstKey) {
+        fileCache.delete(firstKey);
+      }
+    }
+    fileCache.set(filePath, lines);
+    return lines;
+  } catch {
+    return null;
+  }
+}
+function getCodeContext(filePath, lineNumber, columnNumber, linesBefore = 2, linesAfter = 2) {
+  const lines = readFileLines(filePath);
+  if (!lines || lines.length === 0) {
+    return null;
+  }
+  const errorLineIndex = lineNumber - 1;
+  if (errorLineIndex < 0 || errorLineIndex >= lines.length) {
+    return null;
+  }
+  const startIndex = Math.max(0, errorLineIndex - linesBefore);
+  const endIndex = Math.min(lines.length - 1, errorLineIndex + linesAfter);
+  const contextLines = [];
+  for (let i = startIndex; i <= endIndex; i++) {
+    contextLines.push({
+      lineNumber: i + 1,
+      // Convert back to 1-indexed
+      content: lines[i] ?? "",
+      isErrorLine: i === errorLineIndex
+    });
+  }
+  const errorLineContent = lines[errorLineIndex] ?? "";
+  return {
+    lines: contextLines,
+    errorColumn: columnNumber,
+    errorLineContent
+  };
+}
+function getSourceContentFromMap(sourceContent, lineNumber, columnNumber, linesBefore = 2, linesAfter = 2) {
+  if (!sourceContent) {
+    return null;
+  }
+  const lines = sourceContent.split(/\r?\n/);
+  const errorLineIndex = lineNumber - 1;
+  if (errorLineIndex < 0 || errorLineIndex >= lines.length) {
+    return null;
+  }
+  const startIndex = Math.max(0, errorLineIndex - linesBefore);
+  const endIndex = Math.min(lines.length - 1, errorLineIndex + linesAfter);
+  const contextLines = [];
+  for (let i = startIndex; i <= endIndex; i++) {
+    contextLines.push({
+      lineNumber: i + 1,
+      content: lines[i] ?? "",
+      isErrorLine: i === errorLineIndex
+    });
+  }
+  return {
+    lines: contextLines,
+    errorColumn: columnNumber,
+    errorLineContent: lines[errorLineIndex] ?? ""
+  };
+}
+function getContextForFrame(frame, sourceMapResult, linesBefore = 2, linesAfter = 2) {
+  if (sourceMapResult == null ? void 0 : sourceMapResult.sourceContent) {
+    const context = getSourceContentFromMap(
+      sourceMapResult.sourceContent,
+      sourceMapResult.line,
+      sourceMapResult.column,
+      linesBefore,
+      linesAfter
+    );
+    if (context) {
+      return context;
+    }
+  }
+  if (sourceMapResult == null ? void 0 : sourceMapResult.source) {
+    const compiledDir = path__namespace.dirname(frame.filePath);
+    const sourcePath = path__namespace.resolve(compiledDir, sourceMapResult.source);
+    const context = getCodeContext(
+      sourcePath,
+      sourceMapResult.line,
+      sourceMapResult.column,
+      linesBefore,
+      linesAfter
+    );
+    if (context) {
+      return context;
+    }
+    if (path__namespace.isAbsolute(sourceMapResult.source)) {
+      const absContext = getCodeContext(
+        sourceMapResult.source,
+        sourceMapResult.line,
+        sourceMapResult.column,
+        linesBefore,
+        linesAfter
+      );
+      if (absContext) {
+        return absContext;
+      }
+    }
+  }
+  return getCodeContext(
+    frame.filePath,
+    frame.lineNumber,
+    frame.columnNumber,
+    linesBefore,
+    linesAfter
+  );
+}
+function fileExists(filePath) {
+  try {
+    fs2__namespace.accessSync(filePath, fs2__namespace.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VLQ_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var VLQ_BASE64_DECODE = {};
+for (let i = 0; i < VLQ_BASE64.length; i++) {
+  VLQ_BASE64_DECODE[VLQ_BASE64[i]] = i;
+}
+var sourceMapCache = /* @__PURE__ */ new Map();
+function decodeVLQ(encoded) {
+  const result = [];
+  let shift = 0;
+  let value = 0;
+  for (const char of encoded) {
+    const digit = VLQ_BASE64_DECODE[char];
+    if (digit === void 0) continue;
+    const cont = (digit & 32) !== 0;
+    const digitValue = digit & 31;
+    value += digitValue << shift;
+    if (cont) {
+      shift += 5;
+    } else {
+      const shouldNegate = (value & 1) !== 0;
+      value >>= 1;
+      result.push(shouldNegate ? -value : value);
+      value = 0;
+      shift = 0;
+    }
+  }
+  return result;
+}
+function findOriginalPosition(map, generatedLine, generatedColumn) {
+  const mappingLines = map.mappings.split(";");
+  let sourceIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let bestMatch = null;
+  let bestColumn = -1;
+  for (let lineIndex = 0; lineIndex < mappingLines.length; lineIndex++) {
+    const line = mappingLines[lineIndex];
+    if (!line) continue;
+    const segments = line.split(",");
+    let generatedCol = 0;
+    for (const segment of segments) {
+      const decoded = decodeVLQ(segment);
+      if (decoded.length === 0) continue;
+      generatedCol += decoded[0] ?? 0;
+      if (decoded.length >= 4) {
+        sourceIndex += decoded[1] ?? 0;
+        sourceLine += decoded[2] ?? 0;
+        sourceColumn += decoded[3] ?? 0;
+      }
+      if (lineIndex + 1 === generatedLine) {
+        if (generatedCol <= generatedColumn && generatedCol > bestColumn) {
+          bestMatch = {
+            sourceIndex,
+            line: sourceLine + 1,
+            // Convert to 1-indexed
+            column: sourceColumn + 1
+            // Convert to 1-indexed
+          };
+          bestColumn = generatedCol;
+        }
+      }
+    }
+  }
+  return bestMatch;
+}
+function readSourceMap(mapPath) {
+  try {
+    const content = fs2__namespace.readFileSync(mapPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function extractInlineSourceMap(filePath) {
+  try {
+    const content = fs2__namespace.readFileSync(filePath, "utf-8");
+    const inlineMatch = content.match(
+      /\/\/[#@]\s*sourceMappingURL=data:application\/json;(?:charset=utf-8;)?base64,([A-Za-z0-9+/=]+)\s*$/m
+    );
+    if (inlineMatch == null ? void 0 : inlineMatch[1]) {
+      const decoded = Buffer.from(inlineMatch[1], "base64").toString("utf-8");
+      return JSON.parse(decoded);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function findExternalSourceMap(filePath) {
+  try {
+    const content = fs2__namespace.readFileSync(filePath, "utf-8");
+    const externalMatch = content.match(
+      /\/\/[#@]\s*sourceMappingURL=(?!data:)([^\s'"]+)\s*$/m
+    );
+    if (externalMatch == null ? void 0 : externalMatch[1]) {
+      const mapPath = path__namespace.resolve(path__namespace.dirname(filePath), externalMatch[1]);
+      if (fs2__namespace.existsSync(mapPath)) {
+        return mapPath;
+      }
+    }
+    const conventions = [
+      `${filePath}.map`,
+      filePath.replace(/\.js$/, ".js.map"),
+      filePath.replace(/\.mjs$/, ".mjs.map"),
+      filePath.replace(/\.cjs$/, ".cjs.map")
+    ];
+    for (const mapPath of conventions) {
+      if (fs2__namespace.existsSync(mapPath)) {
+        return mapPath;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getSourceMapData(filePath) {
+  if (sourceMapCache.has(filePath)) {
+    return sourceMapCache.get(filePath) ?? null;
+  }
+  let sourceMapData = extractInlineSourceMap(filePath);
+  if (!sourceMapData) {
+    const mapPath = findExternalSourceMap(filePath);
+    if (mapPath) {
+      sourceMapData = readSourceMap(mapPath);
+    }
+  }
+  sourceMapCache.set(filePath, sourceMapData);
+  return sourceMapData;
+}
+function resolveSourceMap(frame) {
+  var _a;
+  try {
+    const map = getSourceMapData(frame.filePath);
+    if (!map) {
+      return null;
+    }
+    const position = findOriginalPosition(
+      map,
+      frame.lineNumber,
+      frame.columnNumber - 1
+      // Convert to 0-indexed for mapping
+    );
+    if (!position) {
+      return null;
+    }
+    const source = map.sources[position.sourceIndex];
+    if (!source) {
+      return null;
+    }
+    let sourceContent;
+    if ((_a = map.sourcesContent) == null ? void 0 : _a[position.sourceIndex]) {
+      sourceContent = map.sourcesContent[position.sourceIndex] ?? void 0;
+    }
+    return {
+      source,
+      line: position.line,
+      column: position.column,
+      sourceContent
+    };
+  } catch {
+    return null;
+  }
+}
+function clearSourceMapCache() {
+  sourceMapCache.clear();
+}
+async function preloadSourceMapModule() {
+  return true;
+}
+var BOX = {
+  vertical: "\u2502",
+  arrow: "\u2192",
+  pointer: "^",
+  lineMarker: ">"
+};
+var ERROR_COLORS = {
+  ReferenceError: pc__default.default.red,
+  TypeError: pc__default.default.red,
+  SyntaxError: pc__default.default.magenta,
+  RangeError: pc__default.default.yellow,
+  EvalError: pc__default.default.red,
+  URIError: pc__default.default.cyan,
+  Error: pc__default.default.red,
+  default: pc__default.default.red
+};
+function getErrorColor(errorName) {
+  return ERROR_COLORS[errorName] ?? ERROR_COLORS["default"] ?? pc__default.default.red;
+}
+function padNumber(num, width) {
+  return String(num).padStart(width, " ");
+}
+function visualWidth(str, tabWidth = 4) {
+  let width = 0;
+  for (const char of str) {
+    if (char === "	") {
+      width += tabWidth - width % tabWidth;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function expandTabs(str, tabWidth = 4) {
+  let result = "";
+  let column = 0;
+  for (const char of str) {
+    if (char === "	") {
+      const spaces = tabWidth - column % tabWidth;
+      result += " ".repeat(spaces);
+      column += spaces;
+    } else {
+      result += char;
+      column += 1;
+    }
+  }
+  return result;
+}
+function highlightSyntax(line, _isErrorLine) {
+  if (!line.trim()) {
+    return line;
+  }
+  let result = line;
+  result = result.replace(
+    /(["'`])(?:(?!\1)[^\\]|\\.)*\1/g,
+    (match) => pc__default.default.green(match)
+  );
+  result = result.replace(
+    /\b(\d+(?:\.\d+)?)\b/g,
+    (match) => pc__default.default.yellow(match)
+  );
+  const keywords = /\b(const|let|var|function|class|if|else|for|while|return|throw|new|async|await|import|export|from|try|catch|finally|default|switch|case|break|continue|typeof|instanceof|in|of|null|undefined|true|false|this|super)\b/g;
+  result = result.replace(keywords, (match) => pc__default.default.blue(match));
+  result = result.replace(
+    /(\/\/.*$|\/\*[\s\S]*?\*\/)/gm,
+    (match) => pc__default.default.dim(match)
+  );
+  return result;
+}
+function renderCodeFrame(context, _config) {
+  const lines = [];
+  const { lines: codeLines, errorColumn } = context;
+  const maxLineNumber = Math.max(...codeLines.map((l) => l.lineNumber));
+  const lineNumWidth = String(maxLineNumber).length;
+  const gutterWidth = lineNumWidth + 3;
+  for (const codeLine of codeLines) {
+    const expandedContent = expandTabs(codeLine.content);
+    const lineNumStr = padNumber(codeLine.lineNumber, lineNumWidth);
+    if (codeLine.isErrorLine) {
+      const marker = pc__default.default.red(pc__default.default.bold(BOX.lineMarker));
+      const lineNum = pc__default.default.red(pc__default.default.bold(lineNumStr));
+      const separator = pc__default.default.red(pc__default.default.bold(BOX.vertical));
+      const highlighted = highlightSyntax(expandedContent);
+      lines.push(` ${marker} ${lineNum} ${separator} ${highlighted}`);
+      if (errorColumn > 0) {
+        const beforeColumn = codeLine.content.slice(0, errorColumn - 1);
+        const visualColumn = visualWidth(beforeColumn);
+        const padding = " ".repeat(gutterWidth + visualColumn + 1);
+        const pointer = pc__default.default.red(pc__default.default.bold(BOX.pointer.repeat(Math.min(3, Math.max(1, codeLine.content.length - errorColumn + 1)))));
+        lines.push(`${padding}${pointer}`);
+      }
+    } else {
+      const lineNum = pc__default.default.dim(lineNumStr);
+      const separator = pc__default.default.dim(BOX.vertical);
+      const highlighted = highlightSyntax(expandedContent);
+      lines.push(`   ${lineNum} ${separator} ${highlighted}`);
+    }
+  }
+  return lines;
+}
+function renderStackTrace(frames, topFrame, maxFrames = 5) {
+  const lines = [];
+  let shown = 0;
+  let hidden = 0;
+  for (const frame of frames) {
+    if (frame === topFrame) {
+      continue;
+    }
+    if (shown >= maxFrames) {
+      hidden++;
+      continue;
+    }
+    lines.push(pc__default.default.dim(formatFrameAsStackLine(frame)));
+    shown++;
+  }
+  if (hidden > 0) {
+    lines.push(pc__default.default.dim(`    ... ${hidden} more frame${hidden > 1 ? "s" : ""}`));
+  }
+  return lines;
+}
+function renderHeader(error, filePath, lineNumber, columnNumber, sourceMapResult) {
+  const lines = [];
+  const errorColor = getErrorColor(error.name);
+  const errorType = pc__default.default.bold(errorColor(error.name));
+  const errorMessage = pc__default.default.white(error.message);
+  lines.push("");
+  lines.push(`${errorType}: ${errorMessage}`);
+  if (filePath) {
+    const displayPath = (sourceMapResult == null ? void 0 : sourceMapResult.source) ? getRelativePath(path__namespace.resolve(path__namespace.dirname(filePath), sourceMapResult.source)) : getRelativePath(filePath);
+    const line = (sourceMapResult == null ? void 0 : sourceMapResult.line) ?? lineNumber ?? 0;
+    const column = (sourceMapResult == null ? void 0 : sourceMapResult.column) ?? columnNumber ?? 0;
+    const location = `${displayPath}:${line}:${column}`;
+    lines.push(`   ${pc__default.default.dim(BOX.arrow)} ${pc__default.default.cyan(location)}`);
+  }
+  lines.push("");
+  return lines;
+}
+function renderTip(error) {
+  const tips = {
+    ReferenceError: "Check that the variable is defined and in scope",
+    TypeError: "Verify the value type matches what the operation expects",
+    SyntaxError: "Look for missing brackets, commas, or typos",
+    RangeError: "Check array indices and numeric boundaries"
+  };
+  const tip = tips[error.name];
+  if (tip) {
+    return [
+      "",
+      pc__default.default.dim(`  ${pc__default.default.yellow("tip")}: ${tip}`)
+    ];
+  }
+  return [];
+}
+function renderError(error, topFrame, codeContext, allFrames, sourceMapResult, config = defaultConfig) {
+  const output = [];
+  output.push(...renderHeader(
+    error,
+    (topFrame == null ? void 0 : topFrame.filePath) ?? null,
+    (topFrame == null ? void 0 : topFrame.lineNumber) ?? null,
+    (topFrame == null ? void 0 : topFrame.columnNumber) ?? null,
+    sourceMapResult
+  ));
+  if (codeContext && codeContext.lines.length > 0) {
+    output.push(...renderCodeFrame(codeContext));
+  }
+  output.push(...renderTip(error));
+  if (config.showFullStack && allFrames.length > 0) {
+    output.push("");
+    output.push(pc__default.default.dim("  Stack trace:"));
+    output.push(...renderStackTrace(allFrames, topFrame));
+  }
+  output.push("");
+  return output.join("\n");
+}
+function renderMinimalError(error, frames) {
+  const output = [];
+  const errorColor = getErrorColor(error.name);
+  output.push("");
+  output.push(`${pc__default.default.bold(errorColor(error.name))}: ${pc__default.default.white(error.message)}`);
+  output.push("");
+  const framesToShow = frames.slice(0, 5);
+  for (const frame of framesToShow) {
+    output.push(pc__default.default.dim(formatFrameAsStackLine(frame)));
+  }
+  if (frames.length > 5) {
+    output.push(pc__default.default.dim(`    ... ${frames.length - 5} more frames`));
+  }
+  output.push("");
+  return output.join("\n");
+}
+function formatErrorString(error) {
+  return error.stack ?? String(error);
+}
+
+// src/interceptor.ts
+var originalPrepareStackTrace;
+var isInstalled = false;
+var currentConfig = { ...defaultConfig };
+var isProcessing = false;
+function customPrepareStackTrace(error, structuredStack) {
+  if (isProcessing) {
+    return formatFallbackStack(error, structuredStack);
+  }
+  isProcessing = true;
+  try {
+    return generateBeautifulStack(error, structuredStack);
+  } catch {
+    return formatFallbackStack(error, structuredStack);
+  } finally {
+    isProcessing = false;
+  }
+}
+function generateBeautifulStack(error, structuredStack) {
+  const allFrames = parseStackTrace(structuredStack);
+  if (allFrames.length === 0) {
+    return formatFallbackStack(error, structuredStack);
+  }
+  let frames = allFrames;
+  if (currentConfig.filterNodeModules) {
+    const userFrames = frames.filter((f) => f.isUserCode);
+    if (userFrames.length > 0) {
+      frames = allFrames.filter((f) => f.isUserCode || !f.isNodeModules);
+    }
+  }
+  frames = frames.filter(currentConfig.frameFilter);
+  const topFrame = findUserCodeFrame(frames.length > 0 ? frames : allFrames);
+  if (!topFrame) {
+    return renderMinimalError(error, allFrames);
+  }
+  let sourceMapResult = null;
+  if (currentConfig.enableSourceMaps) {
+    sourceMapResult = resolveSourceMap(topFrame);
+  }
+  const codeContext = getContextForFrame(
+    topFrame,
+    sourceMapResult,
+    currentConfig.contextLinesBefore,
+    currentConfig.contextLinesAfter
+  );
+  if (!codeContext) {
+    return renderMinimalError(error, allFrames);
+  }
+  return renderError(
+    error,
+    topFrame,
+    codeContext,
+    allFrames,
+    sourceMapResult,
+    currentConfig
+  );
+}
+function formatFallbackStack(error, structuredStack) {
+  const lines = [];
+  lines.push(`${error.name}: ${error.message}`);
+  for (const callSite of structuredStack) {
+    try {
+      const fileName = callSite.getFileName() ?? callSite.getScriptNameOrSourceURL() ?? "<anonymous>";
+      const lineNumber = callSite.getLineNumber() ?? 0;
+      const columnNumber = callSite.getColumnNumber() ?? 0;
+      const functionName = callSite.getFunctionName() ?? "<anonymous>";
+      if (callSite.isNative()) {
+        lines.push(`    at ${functionName} (native)`);
+      } else {
+        lines.push(`    at ${functionName} (${fileName}:${lineNumber}:${columnNumber})`);
+      }
+    } catch {
+      lines.push("    at <unknown>");
+    }
+  }
+  return lines.join("\n");
+}
+function install(config = {}) {
+  if (isInstalled) {
+    currentConfig = { ...defaultConfig, ...config };
+    return;
+  }
+  originalPrepareStackTrace = Error.prepareStackTrace;
+  Error.prepareStackTrace = customPrepareStackTrace;
+  currentConfig = { ...defaultConfig, ...config };
+  isInstalled = true;
+}
+function uninstall() {
+  if (!isInstalled) {
+    return;
+  }
+  Error.prepareStackTrace = originalPrepareStackTrace;
+  originalPrepareStackTrace = void 0;
+  isInstalled = false;
+}
+function isEnabled() {
+  return isInstalled;
+}
+function configure(config) {
+  currentConfig = { ...currentConfig, ...config };
+}
+function getConfig() {
+  return { ...currentConfig };
+}
+function formatError(error) {
+  if (!isInstalled) {
+    const wasInstalled = isInstalled;
+    if (!wasInstalled) {
+      install();
+    }
+    try {
+      return error.stack ?? String(error);
+    } finally {
+      if (!wasInstalled) {
+        uninstall();
+      }
+    }
+  }
+  return error.stack ?? String(error);
+}
+function formatThrown(thrown) {
+  if (thrown instanceof Error) {
+    return formatError(thrown);
+  }
+  const wrapped = new Error(String(thrown));
+  wrapped.name = "UnknownError";
+  return formatError(wrapped);
+}
+function getErrorFrames(error) {
+  const tempStack = [];
+  const originalPST = Error.prepareStackTrace;
+  Error.prepareStackTrace = (_, stack) => {
+    tempStack.push(...stack);
+    return "";
+  };
+  Error.captureStackTrace(error);
+  error.stack;
+  Error.prepareStackTrace = originalPST;
+  return parseStackTrace(tempStack);
+}
+
+// src/index.ts
+var src_default = install;
+
+exports.clearFileCache = clearFileCache;
+exports.clearSourceMapCache = clearSourceMapCache;
+exports.configure = configure;
+exports.default = src_default;
+exports.defaultConfig = defaultConfig;
+exports.fileExists = fileExists;
+exports.findUserCodeFrame = findUserCodeFrame;
+exports.formatError = formatError;
+exports.formatErrorString = formatErrorString;
+exports.formatFrameAsStackLine = formatFrameAsStackLine;
+exports.formatThrown = formatThrown;
+exports.getCodeContext = getCodeContext;
+exports.getConfig = getConfig;
+exports.getContextForFrame = getContextForFrame;
+exports.getErrorFrames = getErrorFrames;
+exports.getRelativePath = getRelativePath;
+exports.install = install;
+exports.isEnabled = isEnabled;
+exports.parseCallSite = parseCallSite;
+exports.parseStackTrace = parseStackTrace;
+exports.preloadSourceMapModule = preloadSourceMapModule;
+exports.renderError = renderError;
+exports.renderMinimalError = renderMinimalError;
+exports.resolveSourceMap = resolveSourceMap;
+exports.uninstall = uninstall;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map