@visulima/error 5.0.3 → 5.0.5

package/CHANGELOG.md

@@ -1,3 +1,34 @@
+## @visulima/error [5.0.5](https://github.com/visulima/visulima/compare/@visulima/error@5.0.4...@visulima/error@5.0.5) (2025-11-12)
+
+### Bug Fixes
+
+* update package configurations and TypeScript definitions ([b59aa59](https://github.com/visulima/visulima/commit/b59aa59dac1508216b944f4b917fb4a7ab1f70a4))
+
+### Miscellaneous Chores
+
+* Add jsr file to all packages for release ([#565](https://github.com/visulima/visulima/issues/565)) ([ec91652](https://github.com/visulima/visulima/commit/ec91652b4e4112adf14ba152c1239a7703ba425a))
+* update license files and clean up TypeScript definitions ([fe668cc](https://github.com/visulima/visulima/commit/fe668cc26de23591d4df54a0954455ebbe31b22d))
+
+
+### Dependencies
+
+* **@visulima/path:** upgraded to 2.0.4
+
+## @visulima/error [5.0.4](https://github.com/visulima/visulima/compare/@visulima/error@5.0.3...@visulima/error@5.0.4) (2025-11-07)
+
+### Bug Fixes
+
+* update TypeScript configurations and improve linting across multiple packages ([6f25ec7](https://github.com/visulima/visulima/commit/6f25ec7841da7246f8f9166efc5292a7089d37ee))
+
+### Miscellaneous Chores
+
+* update npm and pnpm configurations for monorepo optimization ([#564](https://github.com/visulima/visulima/issues/564)) ([5512b42](https://github.com/visulima/visulima/commit/5512b42f672c216b6a3c9e39035199a4ebd9a4b8))
+
+
+### Dependencies
+
+* **@visulima/path:** upgraded to 2.0.3
+
 ## @visulima/error [5.0.3](https://github.com/visulima/visulima/compare/@visulima/error@5.0.2...@visulima/error@5.0.3) (2025-11-05)
 
 ### Bug Fixes

package/dist/code-frame/get-marker-lines.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This is a copy of the codeFrame function from Babel
+ * @see https://github.com/babel/babel/blob/85e649203b61b7c908eb04c05511a0d35f893e8e/packages/babel-code-frame/src/index.ts#L68-L143
+ *
+ * MIT License
+ *
+ * Copyright (c) 2014-present Sebastian McKenzie and other contributors
+ */
+/**
+ * Extract what lines should be marked and highlighted.
+ */
+import type { CodeFrameNodeLocation } from "./types.d.ts";
+type MarkerLines = Record<number, true | [number | undefined, number | undefined]>;
+declare const getMarkerLines: (loc: CodeFrameNodeLocation, source: string[], linesAbove: number, linesBelow: number) => {
+    end: number;
+    markerLines: MarkerLines;
+    start: number;
+};
+export default getMarkerLines;

package/dist/code-frame/index-to-line-column.d.ts

@@ -0,0 +1,7 @@
+declare const indexToLineColumn: (input: number[] | string, index: number, options?: {
+    skipChecks: boolean;
+}) => {
+    column: number;
+    line: number;
+};
+export default indexToLineColumn;

package/dist/code-frame/index.d.ts

@@ -1,7 +1,15 @@
-import { a as CodeFrameNodeLocation, b as CodeFrameOptions } from '../packem_shared/types-CrVmNoPV.js';
-export { C as CodeFrameLocation, c as ColorizeMethod } from '../packem_shared/types-CrVmNoPV.js';
-
-declare const CODE_FRAME_POINTER: string;
-declare const codeFrame: (source: string, loc: CodeFrameNodeLocation, options?: CodeFrameOptions) => string;
-
-export { CODE_FRAME_POINTER, CodeFrameNodeLocation, CodeFrameOptions, codeFrame };
+/**
+ * This is a modified copy of the codeFrameColumns function from Babel
+ * @see https://github.com/babel/babel/blob/85e649203b61b7c908eb04c05511a0d35f893e8e/packages/babel-code-frame/src/index.ts#L145-L217
+ *
+ * MIT License
+ *
+ * Copyright (c) 2014-present Sebastian McKenzie and other contributors
+ */
+import type { CodeFrameNodeLocation, CodeFrameOptions } from "./types.d.ts";
+export declare const CODE_FRAME_POINTER: string;
+/**
+ * Generate a code frame from string and an error location.
+ */
+export declare const codeFrame: (source: string, loc: CodeFrameNodeLocation, options?: CodeFrameOptions) => string;
+export type { CodeFrameLocation, CodeFrameNodeLocation, CodeFrameOptions, ColorizeMethod } from "./types.d.ts";

package/dist/code-frame/index.js

@@ -1,6 +1,125 @@
-var M=Object.defineProperty;var v=(t,e)=>M(t,"name",{value:e,configurable:!0});var F=Object.defineProperty,P=v((t,e)=>F(t,"name",{value:e,configurable:!0}),"r$1");const E=P(t=>t.replaceAll(/\r\n|\r(?!\n)|\n/gu,`
-`),"normalizeLF"),S=globalThis.process||Object.create(null),y={versions:{}},k=new Proxy(S,{get(t,e){if(e in t)return t[e];if(e in y)return y[e]}});var W=Object.defineProperty,T=v((t,e)=>W(t,"name",{value:e,configurable:!0}),"b");const _=T((t,e,h,n)=>{const f={column:0,line:-1,...t.start},i={...f,...t.end},o=f.line,l=f.column,u=i.line,m=i.column;let g=Math.max(o-(h+1),0),p=Math.min(e.length,u+n);o===-1&&(g=0),u===-1&&(p=e.length);const b=u-o,a={};if(b)for(let r=0;r<=b;r++){const s=r+o;if(!l)a[s]=!0;else if(r===0){const c=e[s-1]?.length;a[s]=[l,(c??0)-l+1]}else if(r===b)a[s]=[0,m];else{const c=e[s-r]?.length;a[s]=[0,c]}}else l===m?a[o]=l?[l,0]:!0:a[o]=[l,(m??0)-(l??0)];return{end:p,markerLines:a,start:g}},"getMarkerLines");var B=Object.defineProperty,$=v((t,e)=>B(t,"name",{value:e,configurable:!0}),"o");const C=k.platform==="win32"&&!k.env?.WT_SESSION?">":"❯",I=$((t,e,h)=>{const n={linesAbove:2,linesBelow:3,prefix:"",showGutter:!0,tabWidth:4,...h,color:{gutter:$(r=>r,"gutter"),marker:$(r=>r,"marker"),message:$(r=>r,"message"),...h?.color}},f=e.start&&typeof e.start.column=="number";let i=E(t).split(`
-`);typeof n?.tabWidth=="number"&&(i=i.map(r=>r.replaceAll("	"," ".repeat(n.tabWidth))));const{end:o,markerLines:l,start:u}=_(e,i,n.linesAbove,n.linesBelow),m=String(o).length,{gutter:g,marker:p,message:b}=n.color;let a=i.slice(u,o).map((r,s)=>{const c=u+1+s,d=l[c],j=` ${c}`.slice(-m),O=!l[c+1],x=` ${j}${n.showGutter?" |":""}`;if(d){let A="";if(Array.isArray(d)){const w=r.replaceAll(/[^\t]/g," ").slice(0,Math.max(d[0]-1,0)),L=d[1]||1;A=[`
- `,n.prefix+g(x.replaceAll(/\d/g," "))," ",w,p("^").repeat(L)].join(""),O&&n.message&&(A+=` ${b(n.message)}`)}return[n.prefix+p(C),g(x),r.length>0?` ${r}`:"",A].join("")}return`${n.prefix} ${g(x)}${r.length>0?` ${r}`:""}`}).join(`
-`);return n.message&&!f&&(a=`${n.prefix+" ".repeat(m+1)+n.message}
-${a}`),a},"codeFrame");export{C as CODE_FRAME_POINTER,I as codeFrame};
+const normalizeLF = (code) => code.replaceAll(/\r\n|\r(?!\n)|\n/gu, "\n");
+
+const _process = globalThis.process || /* @__PURE__ */ Object.create(null);
+const processShims = {
+  versions: {}
+};
+const process = new Proxy(_process, {
+  get(target, property) {
+    if (property in target) {
+      return target[property];
+    }
+    if (property in processShims) {
+      return processShims[property];
+    }
+    return void 0;
+  }
+});
+
+const getMarkerLines = (loc, source, linesAbove, linesBelow) => {
+  const startLoc = {
+    column: 0,
+    // @ts-expect-error Can be overwritten
+    line: -1,
+    ...loc.start
+  };
+  const endLoc = {
+    ...startLoc,
+    ...loc.end
+  };
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let index = 0; index <= lineDiff; index++) {
+      const lineNumber = index + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (index === 0) {
+        const sourceLength = source[lineNumber - 1]?.length;
+        markerLines[lineNumber] = [startColumn, (sourceLength ?? 0) - startColumn + 1];
+      } else if (index === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - index]?.length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else if (startColumn === endColumn) {
+    markerLines[startLine] = startColumn ? [startColumn, 0] : true;
+  } else {
+    markerLines[startLine] = [startColumn, (endColumn ?? 0) - (startColumn ?? 0)];
+  }
+  return { end, markerLines, start };
+};
+
+const CODE_FRAME_POINTER = process.platform === "win32" && !process.env?.WT_SESSION ? ">" : "❯";
+const codeFrame = (source, loc, options) => {
+  const config = {
+    // grab 2 lines before, and 3 lines after focused line
+    linesAbove: 2,
+    linesBelow: 3,
+    prefix: "",
+    showGutter: true,
+    tabWidth: 4,
+    ...options,
+    color: {
+      gutter: (value) => value,
+      marker: (value) => value,
+      message: (value) => value,
+      ...options?.color
+    }
+  };
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  let lines = normalizeLF(source).split("\n");
+  if (typeof config?.tabWidth === "number") {
+    lines = lines.map((ln) => ln.replaceAll("	", " ".repeat(config.tabWidth)));
+  }
+  const { end, markerLines, start } = getMarkerLines(loc, lines, config.linesAbove, config.linesBelow);
+  const numberMaxWidth = String(end).length;
+  const { gutter: colorizeGutter, marker: colorizeMarker, message: colorizeMessage } = config.color;
+  let frame = lines.slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const hasMarker = markerLines[number];
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const lastMarkerLine = !markerLines[number + 1];
+    const gutter = ` ${paddedNumber}${config.showGutter ? " |" : ""}`;
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.replaceAll(/[^\t]/g, " ").slice(0, Math.max(hasMarker[0] - 1, 0));
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = [
+          "\n ",
+          config.prefix + colorizeGutter(gutter.replaceAll(/\d/g, " ")),
+          " ",
+          markerSpacing,
+          colorizeMarker("^").repeat(numberOfMarkers)
+        ].join("");
+        if (lastMarkerLine && config.message) {
+          markerLine += ` ${colorizeMessage(config.message)}`;
+        }
+      }
+      return [config.prefix + colorizeMarker(CODE_FRAME_POINTER), colorizeGutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    }
+    return `${config.prefix} ${colorizeGutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+  }).join("\n");
+  if (config.message && !hasColumns) {
+    frame = `${config.prefix + " ".repeat(numberMaxWidth + 1) + config.message}
+${frame}`;
+  }
+  return frame;
+};
+
+export { CODE_FRAME_POINTER, codeFrame };

package/dist/{packem_shared/types-CrVmNoPV.d.ts → code-frame/types.d.ts}

@@ -1,13 +1,13 @@
-type CodeFrameLocation = {
+export type CodeFrameLocation = {
     column?: number;
     line: number;
 };
-type CodeFrameNodeLocation = {
+export type CodeFrameNodeLocation = {
     end?: CodeFrameLocation;
     start: CodeFrameLocation;
 };
-type ColorizeMethod = (value: string) => string;
-type CodeFrameOptions = {
+export type ColorizeMethod = (value: string) => string;
+export type CodeFrameOptions = {
     color?: {
         gutter?: ColorizeMethod;
         marker?: ColorizeMethod;
@@ -21,5 +21,3 @@ type CodeFrameOptions = {
     showLineNumbers?: boolean;
     tabWidth?: number | false;
 };
-
-export type { CodeFrameLocation as C, CodeFrameNodeLocation as a, CodeFrameOptions as b, ColorizeMethod as c };

package/dist/error/capture-raw-stack-trace.d.ts

@@ -0,0 +1,2 @@
+declare const captureRawStackTrace: () => string | undefined;
+export default captureRawStackTrace;

package/dist/error/get-error-causes.d.ts

@@ -0,0 +1,6 @@
+import type { VisulimaError } from "./visulima-error.d.ts";
+/**
+ * Will return an array of all causes in the error in the order they occurred.
+ */
+declare const getErrorCauses: <E = Error | VisulimaError | unknown>(error: E) => E[];
+export default getErrorCauses;

package/dist/error/index.d.ts

@@ -1,96 +1,12 @@
-import { b as CodeFrameOptions, c as ColorizeMethod } from '../packem_shared/types-CrVmNoPV.js';
-
-declare const captureRawStackTrace: () => string | undefined;
-
-interface ErrorProperties {
-    cause?: Error | unknown;
-    hint?: ErrorHint;
-    location?: ErrorLocation;
-    message?: string;
-    name: string;
-    stack?: string;
-    title?: string;
-}
-interface ErrorLocation {
-    column?: number;
-    file?: string;
-    line?: number;
-}
-type ErrorHint = string[] | string;
-
-declare const isVisulimaError: (error: unknown) => error is VisulimaError;
-declare class VisulimaError extends Error {
-    loc: ErrorLocation | undefined;
-    title: string | undefined;
-    hint: ErrorHint | undefined;
-    type: string;
-    constructor({ cause, hint, location, message, name, stack, title }: ErrorProperties);
-    setLocation(location: ErrorLocation): void;
-    setName(name: string): void;
-    setMessage(message: string): void;
-    setHint(hint: ErrorHint): void;
-}
-
-declare const getErrorCauses: <E = Error | VisulimaError | unknown>(error: E) => E[];
-
-type Options$1 = Omit<CodeFrameOptions, "message | prefix"> & {
-    color: CodeFrameOptions["color"] & {
-        fileLine: ColorizeMethod;
-        hint: ColorizeMethod;
-        method: ColorizeMethod;
-        title: ColorizeMethod;
-    };
-    cwd: string;
-    displayShortPath: boolean;
-    filterStacktrace: ((line: string) => boolean) | undefined;
-    framesMaxLimit: number;
-    hideErrorCauseCodeView: boolean;
-    hideErrorCodeView: boolean;
-    hideErrorErrorsCodeView: boolean;
-    hideErrorTitle: boolean;
-    hideMessage: boolean;
-    indentation: number | "\t";
-    prefix: string;
-};
-declare const renderError: (error: AggregateError | Error | VisulimaError, options?: Partial<Options$1>) => string;
-
-interface DeserializeOptions {
-    maxDepth?: number;
-}
-type DeserializeOptionsType = DeserializeOptions;
-declare const deserialize: (value: unknown, options?: DeserializeOptionsType) => Error;
-
-type ErrorConstructor = new (...arguments_: any[]) => Error;
-declare const addKnownErrorConstructor: (constructor: ErrorConstructor, name?: string) => void;
-declare const isErrorLike: (value: unknown) => value is {
-    message?: string;
-    name?: string;
-    stack?: string;
-};
-
-type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
-    aggregateErrors?: SerializedError<ErrorType>[];
-    cause?: unknown;
-    code?: string;
-    message: string;
-    name: string;
-    raw?: ErrorType;
-    stack?: string;
-};
-
-declare class NonError extends Error {
-    constructor(message: string);
-}
-
-interface JsonError extends Error {
-    toJSON: () => SerializedError;
-}
-type Options = {
-    exclude?: string[];
-    maxDepth?: number;
-    useToJSON?: boolean;
-};
-declare const serialize: (error: AggregateError | Error | JsonError, options?: Options) => SerializedError;
-
-export { NonError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserialize as deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serialize as serializeError };
-export type { ErrorHint, ErrorLocation, ErrorProperties, Options as ErrorWithCauseSerializerOptions, Options$1 as RenderErrorOptions, SerializedError };
+export { default as captureRawStackTrace } from "./capture-raw-stack-trace.d.ts";
+export { default as getErrorCauses } from "./get-error-causes.d.ts";
+export type { Options as RenderErrorOptions } from "./render/error.d.ts";
+export { renderError } from "./render/error.d.ts";
+export { default as deserializeError } from "./serialize/deserialize.d.ts";
+export { addKnownErrorConstructor, isErrorLike } from "./serialize/error-constructors.d.ts";
+export type { SerializedError } from "./serialize/error-proto.d.ts";
+export { default as NonError } from "./serialize/non-error.d.ts";
+export type { Options as ErrorWithCauseSerializerOptions } from "./serialize/serialize.d.ts";
+export { serialize as serializeError } from "./serialize/serialize.d.ts";
+export type { ErrorHint, ErrorLocation, ErrorProperties } from "./types.d.ts";
+export { isVisulimaError, VisulimaError } from "./visulima-error.d.ts";

package/dist/error/index.js

@@ -1 +1,8 @@
-import{default as e}from"../packem_shared/captureRawStackTrace-CQPNHvBG.js";import{default as t}from"../packem_shared/getErrorCauses-geeK5cwE.js";import{renderError as i}from"../packem_shared/renderError-ZMlMvw1N.js";import{default as m}from"../packem_shared/deserializeError-BJM8Kd6G.js";import{addKnownErrorConstructor as p,isErrorLike as u}from"../packem_shared/addKnownErrorConstructor-BqqnTSZp.js";import{default as d}from"../packem_shared/NonError-CS10kwil.js";import{serialize as n}from"../packem_shared/serializeError-CTpDr3CL.js";import{VisulimaError as z,isVisulimaError as k}from"../packem_shared/isVisulimaError-jVZgumOU.js";export{d as NonError,z as VisulimaError,p as addKnownErrorConstructor,e as captureRawStackTrace,m as deserializeError,t as getErrorCauses,u as isErrorLike,k as isVisulimaError,i as renderError,n as serializeError};
+export { default as captureRawStackTrace } from '../packem_shared/captureRawStackTrace-ySw7cU0U.js';
+export { default as getErrorCauses } from '../packem_shared/getErrorCauses-DpUsmuqw.js';
+export { renderError } from '../packem_shared/renderError-C30PRFtU.js';
+export { default as deserializeError } from '../packem_shared/deserializeError-E0VQnnm0.js';
+export { addKnownErrorConstructor, isErrorLike } from '../packem_shared/addKnownErrorConstructor-s_3SsXtQ.js';
+export { default as NonError } from '../packem_shared/NonError-D5FGLYKY.js';
+export { serialize as serializeError } from '../packem_shared/serializeError-BZ62KiYZ.js';
+export { VisulimaError, isVisulimaError } from '../packem_shared/isVisulimaError-DA7QsCxH.js';

package/dist/error/render/error.d.ts

@@ -0,0 +1,22 @@
+import type { CodeFrameOptions, ColorizeMethod } from "../../index.d.ts";
+import type { VisulimaError } from "../visulima-error.d.ts";
+export type Options = Omit<CodeFrameOptions, "message | prefix"> & {
+    color: CodeFrameOptions["color"] & {
+        fileLine: ColorizeMethod;
+        hint: ColorizeMethod;
+        method: ColorizeMethod;
+        title: ColorizeMethod;
+    };
+    cwd: string;
+    displayShortPath: boolean;
+    filterStacktrace: ((line: string) => boolean) | undefined;
+    framesMaxLimit: number;
+    hideErrorCauseCodeView: boolean;
+    hideErrorCodeView: boolean;
+    hideErrorErrorsCodeView: boolean;
+    hideErrorTitle: boolean;
+    hideMessage: boolean;
+    indentation: number | "\t";
+    prefix: string;
+};
+export declare const renderError: (error: AggregateError | Error | VisulimaError, options?: Partial<Options>) => string;

package/dist/error/serialize/deserialize.d.ts

@@ -0,0 +1,14 @@
+interface DeserializeOptions {
+    maxDepth?: number;
+}
+/**
+ * Options for deserializing error objects.
+ */
+type DeserializeOptionsType = DeserializeOptions;
+/**
+ * Deserialize a value back to its original form.
+ * If the value looks like a serialized error, it will be reconstructed as an Error instance.
+ * Otherwise, it will be wrapped in a NonError.
+ */
+declare const deserialize: (value: unknown, options?: DeserializeOptionsType) => Error;
+export default deserialize;

package/dist/error/serialize/error-constructors.d.ts

@@ -0,0 +1,25 @@
+type ErrorConstructor = new (...arguments_: any[]) => Error;
+/**
+ * Add a known error constructor to the registry.
+ * @param constructor The error constructor to add
+ * @param name Optional custom name to use instead of instance.name
+ * @throws {Error} If the constructor is already known or incompatible
+ */
+export declare const addKnownErrorConstructor: (constructor: ErrorConstructor, name?: string) => void;
+/**
+ * Get all known error constructors.
+ */
+export declare const getKnownErrorConstructors: () => Map<string, new (...arguments_: any[]) => Error>;
+/**
+ * Get a specific error constructor by name.
+ */
+export declare const getErrorConstructor: (name: string) => (new (...arguments_: any[]) => Error) | undefined;
+/**
+ * Check if an object looks like a serialized error.
+ */
+export declare const isErrorLike: (value: unknown) => value is {
+    message?: string;
+    name?: string;
+    stack?: string;
+};
+export {};

package/dist/error/serialize/error-proto.d.ts

@@ -0,0 +1,10 @@
+export declare const ErrorProto: SerializedError;
+export type SerializedError<ErrorType = Error> = Record<PropertyKey, unknown> & {
+    aggregateErrors?: SerializedError<ErrorType>[];
+    cause?: unknown;
+    code?: string;
+    message: string;
+    name: string;
+    raw?: ErrorType;
+    stack?: string;
+};

package/dist/error/serialize/non-error.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NonError class for deserializing non-error-like objects
+ */
+declare class NonError extends Error {
+    constructor(message: string);
+}
+export default NonError;

package/dist/error/serialize/serialize.d.ts

@@ -0,0 +1,14 @@
+import type { SerializedError } from "./error-proto.d.ts";
+interface JsonError extends Error {
+    toJSON: () => SerializedError;
+}
+export type Options = {
+    exclude?: string[];
+    maxDepth?: number;
+    useToJSON?: boolean;
+};
+/**
+ * Serialize an `Error` object into a plain object.
+ */
+export declare const serialize: (error: AggregateError | Error | JsonError, options?: Options) => SerializedError;
+export {};

package/dist/error/types.d.ts

@@ -0,0 +1,33 @@
+export interface ErrorProperties {
+    cause?: Error | unknown;
+    hint?: ErrorHint;
+    location?: ErrorLocation;
+    message?: string;
+    name: string;
+    stack?: string;
+    title?: string;
+}
+export interface ErrorLocation {
+    column?: number;
+    file?: string;
+    line?: number;
+}
+/**
+ * A message that explains to the user how they can fix the error.
+ * @example
+ * ```ts
+ * const error = new VisulimaError({
+ *    hint: "Try running `npm install` to install missing dependencies.",
+ *    location: {
+ *    file: "src/index.ts",
+ *    line: 1,
+ *    column: 1,
+ *    },
+ *    message: "Cannot find module 'react'",
+ *    name: "ModuleNotFoundError",
+ * });
+ * ```
+ *
+ * For more complex hints, you can pass an array of strings or a single string in markdown format.
+ */
+export type ErrorHint = string[] | string;

package/dist/error/visulima-error.d.ts

@@ -0,0 +1,16 @@
+import type { ErrorHint, ErrorLocation, ErrorProperties } from "./types.d.ts";
+export declare const isVisulimaError: (error: unknown) => error is VisulimaError;
+export declare class VisulimaError extends Error {
+    loc: ErrorLocation | undefined;
+    title: string | undefined;
+    /**
+     * A message that explains to the user how they can fix the error.
+     */
+    hint: ErrorHint | undefined;
+    type: string;
+    constructor({ cause, hint, location, message, name, stack, title }: ErrorProperties);
+    setLocation(location: ErrorLocation): void;
+    setName(name: string): void;
+    setMessage(message: string): void;
+    setHint(hint: ErrorHint): void;
+}

package/dist/index.d.ts

@@ -1,17 +1,12 @@
-export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.js';
-export { default as aiPrompt } from './solution/ai/ai-prompt.js';
-export { a as aiSolutionResponse } from './packem_shared/ai-solution-response-BuaDQAEU.js';
-export { errorHintFinder, ruleBasedFinder } from './solution/index.js';
-export { S as Solution, a as SolutionError, b as SolutionFinder, c as SolutionFinderFile } from './packem_shared/types-BtQS7FHG.js';
-export { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, NonError, RenderErrorOptions, SerializedError, VisulimaError, addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, renderError, serializeError } from './error/index.js';
-export { Trace, TraceType, formatStackFrameLine, formatStacktrace, parseStacktrace } from './stacktrace/index.js';
-export { C as CodeFrameLocation, a as CodeFrameNodeLocation, b as CodeFrameOptions, c as ColorizeMethod } from './packem_shared/types-CrVmNoPV.js';
-
-declare const indexToLineColumn: (input: number[] | string, index: number, options?: {
-    skipChecks: boolean;
-}) => {
-    column: number;
-    line: number;
-};
-
-export { indexToLineColumn };
+export type { CodeFrameLocation, CodeFrameNodeLocation, CodeFrameOptions, ColorizeMethod } from "./code-frame/index.d.ts";
+export { CODE_FRAME_POINTER, codeFrame } from "./code-frame/index.d.ts";
+export { default as indexToLineColumn } from "./code-frame/index-to-line-column.d.ts";
+export type { ErrorHint, ErrorLocation, ErrorProperties, ErrorWithCauseSerializerOptions, RenderErrorOptions, SerializedError } from "./error/index.d.ts";
+export { addKnownErrorConstructor, captureRawStackTrace, deserializeError, getErrorCauses, isErrorLike, isVisulimaError, NonError, renderError, serializeError, VisulimaError, } from "./error/index.d.ts";
+export { default as aiPrompt } from "./solution/ai/ai-prompt.d.ts";
+export { default as aiSolutionResponse } from "./solution/ai/ai-solution-response.d.ts";
+export { default as errorHintFinder } from "./solution/error-hint-finder.d.ts";
+export { default as ruleBasedFinder } from "./solution/rule-based-finder.d.ts";
+export type { Solution, SolutionError, SolutionFinder, SolutionFinderFile } from "./solution/types.d.ts";
+export type { Trace, TraceType } from "./stacktrace/index.d.ts";
+export { formatStackFrameLine, formatStacktrace, parseStacktrace } from "./stacktrace/index.d.ts";

package/dist/index.js

@@ -1 +1,16 @@
-import{CODE_FRAME_POINTER as o,codeFrame as a}from"./code-frame/index.js";import{default as f}from"./packem_shared/indexToLineColumn-B1F7aNZh.js";import{default as m}from"./solution/ai/ai-prompt.js";import{default as p}from"./packem_shared/aiSolutionResponse-RD0AK1jh.js";import{default as l}from"./packem_shared/errorHintFinder-C_g0nvml.js";import{default as x}from"./packem_shared/ruleBasedFinder-P88d0gpK.js";import{default as E}from"./packem_shared/captureRawStackTrace-CQPNHvBG.js";import{default as k}from"./packem_shared/deserializeError-BJM8Kd6G.js";import{default as S}from"./packem_shared/getErrorCauses-geeK5cwE.js";import{default as R}from"./packem_shared/NonError-CS10kwil.js";import{default as L}from"./packem_shared/parseStacktrace-Dnxnc4PL.js";import{addKnownErrorConstructor as w,isErrorLike as N}from"./packem_shared/addKnownErrorConstructor-BqqnTSZp.js";import{VisulimaError as P,isVisulimaError as V}from"./packem_shared/isVisulimaError-jVZgumOU.js";import{renderError as g}from"./packem_shared/renderError-ZMlMvw1N.js";import{serialize as B}from"./packem_shared/serializeError-CTpDr3CL.js";import{formatStackFrameLine as H,formatStacktrace as I}from"./packem_shared/formatStackFrameLine-iU54KA81.js";export{o as CODE_FRAME_POINTER,R as NonError,P as VisulimaError,w as addKnownErrorConstructor,m as aiPrompt,p as aiSolutionResponse,E as captureRawStackTrace,a as codeFrame,k as deserializeError,l as errorHintFinder,H as formatStackFrameLine,I as formatStacktrace,S as getErrorCauses,f as indexToLineColumn,N as isErrorLike,V as isVisulimaError,L as parseStacktrace,g as renderError,x as ruleBasedFinder,B as serializeError};
+export { CODE_FRAME_POINTER, codeFrame } from './code-frame/index.js';
+export { default as indexToLineColumn } from './packem_shared/indexToLineColumn-Bg8UW1bU.js';
+export { default as aiPrompt } from './solution/ai/ai-prompt.js';
+export { default as aiSolutionResponse } from './packem_shared/aiSolutionResponse-CJBMLS9t.js';
+export { default as errorHintFinder } from './packem_shared/errorHintFinder-DEaeRnRW.js';
+export { default as ruleBasedFinder } from './packem_shared/ruleBasedFinder-C2F8rQ30.js';
+export { default as captureRawStackTrace } from './packem_shared/captureRawStackTrace-ySw7cU0U.js';
+export { default as deserializeError } from './packem_shared/deserializeError-E0VQnnm0.js';
+export { default as getErrorCauses } from './packem_shared/getErrorCauses-DpUsmuqw.js';
+export { default as NonError } from './packem_shared/NonError-D5FGLYKY.js';
+export { default as parseStacktrace } from './packem_shared/parseStacktrace-oQvk7wYp.js';
+export { addKnownErrorConstructor, isErrorLike } from './packem_shared/addKnownErrorConstructor-s_3SsXtQ.js';
+export { VisulimaError, isVisulimaError } from './packem_shared/isVisulimaError-DA7QsCxH.js';
+export { renderError } from './packem_shared/renderError-C30PRFtU.js';
+export { serialize as serializeError } from './packem_shared/serializeError-BZ62KiYZ.js';
+export { formatStackFrameLine, formatStacktrace } from './packem_shared/formatStackFrameLine-D3_6oSWZ.js';

package/dist/packem_shared/NonError-D5FGLYKY.js

@@ -0,0 +1,8 @@
+class NonError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NonError";
+  }
+}
+
+export { NonError as default };

package/dist/packem_shared/addKnownErrorConstructor-s_3SsXtQ.js

@@ -0,0 +1,30 @@
+const defaultErrorConstructors = /* @__PURE__ */ new Map([
+  ["Error", Error],
+  ["EvalError", EvalError],
+  ["RangeError", RangeError],
+  ["ReferenceError", ReferenceError],
+  ["SyntaxError", SyntaxError],
+  ["TypeError", TypeError],
+  ["URIError", URIError]
+]);
+if (typeof AggregateError !== "undefined") {
+  defaultErrorConstructors.set("AggregateError", AggregateError);
+}
+const addKnownErrorConstructor = (constructor, name) => {
+  let instance;
+  try {
+    instance = new constructor();
+  } catch (error) {
+    throw new Error(`The error constructor "${constructor.name}" is not compatible`, { cause: error });
+  }
+  const resolvedName = name ?? instance.name;
+  if (defaultErrorConstructors.has(resolvedName)) {
+    throw new Error(`The error constructor "${resolvedName}" is already known.`);
+  }
+  defaultErrorConstructors.set(resolvedName, constructor);
+};
+const getKnownErrorConstructors = () => new Map(defaultErrorConstructors);
+const getErrorConstructor = (name) => defaultErrorConstructors.get(name);
+const isErrorLike = (value) => value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && (getErrorConstructor(value.name) !== void 0 || value.name === "Error");
+
+export { addKnownErrorConstructor, getErrorConstructor, getKnownErrorConstructors, isErrorLike };