@futpib/parser 1.0.2 → 1.0.4

package/build/nonEmptyArrayParser.test.js

@@ -5,7 +5,8 @@ import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createExactElementParser } from './exactElementParser.js';
 test('empty array does not match', async (t) => {
     const parser = createNonEmptyArrayParser(createExactElementParser('0'));
-    await t.throwsAsync(() => runParser(parser, '', stringParserInputCompanion), {
+    await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+        any: true,
         message: /Expected .* to match at least once/,
     });
 });

package/build/optionalParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 export const createOptionalParser = (childParser) => {
     const optionalParser = async (parserContext) => {
         const childParserContext = parserContext.lookahead();
@@ -9,7 +9,7 @@ export const createOptionalParser = (childParser) => {
             return value;
         }
         catch (error) {
-            if (error instanceof ParserParsingFailedError) {
+            if (isParserParsingFailedError(error)) {
                 return undefined;
             }
             throw error;

package/build/parser.d.ts

@@ -1,4 +1,4 @@
-import { Class } from 'type-fest';
+import { type Class } from 'type-fest';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type ParserContext } from './parserContext.js';
 import { type DeriveSequenceElement } from './sequence.js';
@@ -8,6 +8,7 @@ export declare function setParserName<Output, Sequence, Element = DeriveSequence
 export declare function cloneParser<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>): Parser<Output, Sequence, Element>;
 export type RunParserOptions<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = {
     errorJoinMode?: 'none' | 'deepest' | 'furthest' | 'all';
+    errorStack?: boolean;
     parserContextClass?: Class<ParserContext<Sequence, Element>>;
 };
 export type RunParserWithRemainingInputResult<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = {

package/build/parser.js

@@ -1,8 +1,12 @@
 import { InputReaderImplementation } from './inputReader.js';
 import { ParserContextImplementation } from './parserContext.js';
-import { ParserError, ParserUnexpectedRemainingInputError } from './parserError.js';
 import { toAsyncIterator } from './toAsyncIterator.js';
 import { inputReaderStateCompanion } from './inputReaderState.js';
+import { isLazyMessageError } from './lazyMessageError.js';
+import { isParserError, normalParserErrorModule, noStackCaptureOverheadParserErrorModule } from './parserError.js';
+import { NoStackCaptureOverheadError } from './noStackCaptureOverheadError.js';
+import invariant from 'invariant';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function getParserName(parser, default_ = 'anonymous') {
     return parser.name || default_;
 }
@@ -12,12 +16,11 @@ export function setParserName(parser, name) {
     });
     return parser;
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const originalParserByClone = new WeakMap();
 export function cloneParser(parser) {
     const originalParser = originalParserByClone.get(parser) ?? parser;
-    const clone = (parserContext) => {
-        return originalParser(parserContext);
-    };
+    const clone = parserContext => originalParser(parserContext);
     setParserName(clone, getParserName(parser));
     originalParserByClone.set(clone, originalParser);
     return clone;
@@ -27,7 +30,18 @@ async function withEnrichedParserError(parserContext, inputReader, f) {
         return await f();
     }
     catch (error) {
-        if (error instanceof ParserError) {
+        if (error instanceof NoStackCaptureOverheadError) {
+            invariant(error.name in normalParserErrorModule, 'NoStackCaptureOverheadError with unknown name encountered during parser execution: %s', error.name);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const normalError = new (normalParserErrorModule[error.name])(error.message);
+            Object.assign(normalError, error);
+            normalError.stack = normalError.stack + '\nIf you need a useful stack trace, pass `errorStack: true` to `runParser`, trading off some performance.';
+            error = normalError;
+        }
+        if (isLazyMessageError(error)) {
+            error.computeMessage();
+        }
+        if (isParserError(error)) {
             if (error.position === undefined) {
                 error.position = parserContext.position;
             }
@@ -44,6 +58,7 @@ function runParserInternal(parser, input, parserInputCompanion, options = {}) {
     const ParserContext = options.parserContextClass ?? ParserContextImplementation;
     const parserContext = new ParserContext(parserInputCompanion, inputReader, undefined, {
         ...options,
+        errorsModule: options.errorStack ? normalParserErrorModule : noStackCaptureOverheadParserErrorModule,
         debugName: 'root',
     });
     const outputPromise = (async () => {
@@ -62,7 +77,7 @@ function runParserInternal(parser, input, parserInputCompanion, options = {}) {
 }
 export async function runParserWithRemainingInput(parser, input, parserInputCompanion, options = {}) {
     const { outputPromise, parserContext, inputReader, } = runParserInternal(parser, input, parserInputCompanion, options);
-    return await withEnrichedParserError(parserContext, inputReader, async () => {
+    return withEnrichedParserError(parserContext, inputReader, async () => {
         const output = await outputPromise;
         const inputReaderState = inputReader.toInputReaderState();
         const remainingInput = (inputReaderStateCompanion.isDone(inputReaderState)
@@ -77,11 +92,11 @@ export async function runParserWithRemainingInput(parser, input, parserInputComp
 }
 export async function runParser(parser, input, parserInputCompanion, options = {}) {
     const { outputPromise, parserContext, inputReader, } = runParserInternal(parser, input, parserInputCompanion, options);
-    return await withEnrichedParserError(parserContext, inputReader, async () => {
+    return withEnrichedParserError(parserContext, inputReader, async () => {
         const output = await outputPromise;
         const inputReaderState = inputReader.toInputReaderState();
         if (!inputReaderStateCompanion.isDone(inputReaderState)) {
-            throw new ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position);
+            throw new normalParserErrorModule.ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position);
         }
         return output;
     });

package/build/parser.test.js

@@ -3,7 +3,7 @@ import invariant from 'invariant';
 import { createUnionParser } from './unionParser.js';
 import { runParser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
-import { ParserError, ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError, ParserUnexpectedRemainingInputError, } from './parserError.js';
+import { isParserParsingJoinError, normalParserErrorModule, } from './parserError.js';
 import { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
@@ -11,6 +11,7 @@ import { createExactSequenceNaiveParser } from './exactSequenceParser.js';
 import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
 import { toAsyncIterable } from './toAsyncIterable.js';
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
 const aUnionParser = createUnionParser([
     createExactSequenceNaiveParser('1'),
     createExactSequenceNaiveParser('aa'),
@@ -36,29 +37,23 @@ const sampleParser = promiseCompose(createTupleParser([
 async function* asyncIteratorFromString(string) {
     yield string;
 }
-async function stringFromAsyncIterable(asyncIterable) {
-    let string = '';
-    for await (const chunk of asyncIterable) {
-        string += chunk;
-    }
-    return string;
-}
 function sortChildErrors(error) {
     error.childErrors.sort((a, b) => a.message.localeCompare(b.message));
     for (const childError of error.childErrors) {
-        if (childError instanceof ParserParsingJoinError) {
+        if (isParserParsingJoinError(childError)) {
             sortChildErrors(childError);
         }
     }
 }
 function removeStackLocations(errorStack) {
-    return errorStack.replaceAll(/((at [^\n]+)[\s\n]+)+(at [^\n]+)/g, 'at [LOCATIONS]');
+    return errorStack?.replaceAll(/((at [^\n]+)[\s\n]+)+(at [^\n]+)/g, 'at [LOCATIONS]');
 }
 test('errorJoinMode: none', async (t) => {
     const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'none',
+        errorStack: true,
     }), {
-        instanceOf: ParserParsingJoinNoneError,
+        instanceOf: normalParserErrorModule.ParserParsingJoinNoneError,
     });
     t.is(error.position, 12);
     t.deepEqual(error.childErrors, []);
@@ -67,61 +62,112 @@ test('errorJoinMode: none', async (t) => {
 test('errorJoinMode: all', async (t) => {
     const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'all',
+        errorStack: true,
     }), {
-        instanceOf: ParserParsingJoinAllError,
+        instanceOf: normalParserErrorModule.ParserParsingJoinAllError,
     });
     sortChildErrors(error);
     t.snapshot(removeStackLocations(error.stack));
     t.is(error.position, 12, 'error.position');
     t.is(error.childErrors.length, 4);
     const error1 = error.childErrors.at(-1);
-    invariant(error1 instanceof ParserParsingJoinAllError, 'error1 instanceof ParserParsingJoinAllError');
+    invariant(isParserParsingJoinError(error1), 'error1 instanceof ParserParsingJoinAllError');
     t.is(error1.position, 3, 'error1.position');
     t.is(error1.childErrors.length, 4);
     const error2 = error1.childErrors.at(-1);
-    invariant(error2 instanceof ParserParsingJoinAllError, 'error2 instanceof ParserParsingJoinAllError');
+    invariant(isParserParsingJoinError(error2), 'error2 instanceof ParserParsingJoinAllError');
     t.is(error2.position, 4, 'error2.position');
     t.is(error2.childErrors.length, 3);
     const error3 = error2.childErrors.at(-1);
-    invariant(error3 instanceof ParserParsingInvariantError, 'error3 instanceof ParserParsingInvariantError');
+    invariant(error3.name === 'ParserParsingInvariantError', 'error3 instanceof ParserParsingInvariantError');
     t.is(error3.position, 4, 'error3.position');
 });
 test('errorJoinMode: deepest', async (t) => {
     const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'deepest',
+        errorStack: true,
     }), {
-        instanceOf: ParserParsingJoinDeepestError,
+        instanceOf: normalParserErrorModule.ParserParsingJoinDeepestError,
     });
     sortChildErrors(error);
     t.snapshot(removeStackLocations(error.stack));
     t.is(error.position, 12);
     t.is(error.childErrors.length, 1);
     const error1 = error.childErrors.at(-1);
-    invariant(error1 instanceof ParserParsingJoinDeepestError, 'error1 instanceof ParserParsingJoinDeepestError');
+    invariant(isParserParsingJoinError(error1), 'error1 instanceof ParserParsingJoinDeepestError');
     t.is(error1.position, 3);
     t.is(error1.childErrors.length, 1);
     const error2 = error1.childErrors.at(-1);
-    invariant(error2 instanceof ParserParsingJoinDeepestError, 'error2 instanceof ParserParsingJoinDeepestError');
+    invariant(isParserParsingJoinError(error2), 'error2 instanceof ParserParsingJoinDeepestError');
     t.is(error2.position, 4);
     t.is(error2.childErrors.length, 3);
     const error3 = error2.childErrors.at(-1);
-    invariant(error3 instanceof ParserParsingInvariantError, 'error3 instanceof ParserParsingInvariantError');
+    invariant(error3.name === 'ParserParsingInvariantError', 'error3 instanceof ParserParsingInvariantError');
     t.is(error3.position, 4);
 });
 test('errorJoinMode: furthest', async (t) => {
     const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'furthest',
+        errorStack: true,
     }), {
-        instanceOf: ParserParsingJoinFurthestError,
+        instanceOf: normalParserErrorModule.ParserParsingJoinFurthestError,
     });
     sortChildErrors(error);
     t.snapshot(removeStackLocations(error.stack));
     t.is(error.position, 12);
     t.is(error.childErrors.length, 1);
     const error1 = error.childErrors.at(-1);
-    invariant(error1 instanceof ParserParsingInvariantError, 'error1 instanceof ParserParsingInvariantError');
+    invariant(error1.name === 'ParserParsingInvariantError', 'error1 instanceof ParserParsingInvariantError');
     t.is(error1.position, 12);
 });
+test('errorStack: false', async (t) => {
+    const error = await t.throwsAsync(runParser(sampleParser, 'nothing like what sampleParser expects', stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    }), {
+        instanceOf: normalParserErrorModule.ParserParsingJoinAllError,
+    });
+    t.regex(error.stack, /intentionally left blank/);
+    t.regex(error.stack, /errorStack: true/);
+});
+test('errorStack: true', async (t) => {
+    const error = await t.throwsAsync(runParser(sampleParser, 'nothing like what sampleParser expects', stringParserInputCompanion, {
+        errorJoinMode: 'all',
+        errorStack: true,
+    }), {
+        instanceOf: normalParserErrorModule.ParserParsingJoinAllError,
+    });
+    t.regex(error.stack, /exactSequenceParser/);
+});
+test('errorJoinMode: none, errorStack: false', async (t) => {
+    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
+        errorJoinMode: 'none',
+        errorStack: false,
+    }), {
+        instanceOf: normalParserErrorModule.ParserParsingJoinNoneError,
+    });
+    t.is(error.position, 12);
+    t.deepEqual(error.childErrors, []);
+    t.snapshot(removeStackLocations(error.stack));
+});
+test('retrows normal errors untouched', async (t) => {
+    class CustomError extends Error {
+    }
+    ;
+    const originalCustomError1 = new CustomError('This is a custom error');
+    const originalCustomError2 = new Error('This is a normal error');
+    const error1 = await t.throwsAsync(runParser(() => {
+        throw originalCustomError1;
+    }, 'foo', stringParserInputCompanion), {
+        instanceOf: CustomError,
+    });
+    t.is(error1, originalCustomError1);
+    const error2 = await t.throwsAsync(runParser(() => {
+        throw originalCustomError2;
+    }, 'foo', stringParserInputCompanion), {
+        instanceOf: Error,
+    });
+    t.is(error2, originalCustomError2);
+});
 test('throws on parserInputCompanion type mismatch', async (t) => {
     const anythingParser = createArrayParser(createElementParser());
     await runParser(anythingParser, asyncIteratorFromString('anything'), stringParserInputCompanion);
@@ -140,8 +186,10 @@ test('thrown error has input reader state', async (t) => {
         yield 'foo';
         yield 'qux';
         yield 'bar';
-    })(), stringParserInputCompanion), {
-        instanceOf: ParserError,
+    })(), stringParserInputCompanion, {
+        errorStack: true,
+    }), {
+        instanceOf: normalParserErrorModule.ParserParsingInvariantError,
     });
     t.is(error.position, 4);
     invariant(error.inputReaderSate, 'error.inputReaderSate');
@@ -160,8 +208,9 @@ test('thrown error has input reader state', async (t) => {
 });
 test('runParser throws with remaining input', async (t) => {
     const parser = createExactSequenceNaiveParser('foo');
-    const error = await t.throwsAsync(() => runParser(parser, 'foobar', stringParserInputCompanion), {
-        instanceOf: ParserUnexpectedRemainingInputError,
+    const error = await t.throwsAsync(async () => runParser(parser, 'foobar', stringParserInputCompanion), {
+        any: true,
+        name: 'ParserUnexpectedRemainingInputError',
         message: /remaining input/,
     });
     t.is(error.position, 3);
@@ -175,19 +224,19 @@ test('runParser throws with remaining input', async (t) => {
 test('runParser does not throw without remaining input', async (t) => {
     const parser = createExactSequenceNaiveParser('foo');
     const output = await runParser(parser, 'foo', stringParserInputCompanion);
-    t.deepEqual(output, 'foo');
+    t.is(output, 'foo');
 });
 test('runParserWithRemainingInput with remaining input', async (t) => {
     const parser = createExactSequenceNaiveParser('foo');
     const { output, remainingInput, position, ...resultRest } = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
     t.deepEqual(resultRest, {});
-    t.deepEqual(output, 'foo');
-    t.deepEqual(await stringFromAsyncIterable(remainingInput), 'bar');
+    t.is(output, 'foo');
+    t.is(await stringFromAsyncIterable(remainingInput), 'bar');
     t.is(position, 3);
 });
 test('runParserWithRemainingInput without remaining input', async (t) => {
     const parser = createExactSequenceNaiveParser('foo');
     const { output, remainingInput } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
-    t.deepEqual(output, 'foo');
+    t.is(output, 'foo');
     t.is(remainingInput, undefined);
 });

package/build/parserConsumedSequenceParser.d.ts

@@ -1,2 +1,2 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 export declare const createParserConsumedSequenceParser: <Output, Sequence>(childParser: Parser<Output, Sequence>) => Parser<[Output, Sequence], Sequence>;

package/build/parserConsumedSequenceParser.js

@@ -1,5 +1,5 @@
-import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
-import { getParserName, setParserName } from "./parser.js";
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { getParserName, setParserName } from './parser.js';
 export const createParserConsumedSequenceParser = (childParser) => {
     const parserConsumedSequenceParser = async (parserContext) => {
         const initialPosition = parserContext.position;

package/build/parserContext.d.ts

@@ -1,13 +1,15 @@
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type InputReader } from './inputReader.js';
-import { type ParserParsingFailedError } from './parserError.js';
+import { normalParserErrorModule, noStackCaptureOverheadParserErrorModule, ParserParsingFailedError } from './parserError.js';
 import { type RunParserOptions } from './parser.js';
 import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
 type LookaheadOptions = {
     debugName?: string;
     sliceEnd?: number;
 };
-type ParserContextOptions<Sequence, Element> = RunParserOptions<unknown, Sequence, Element> & LookaheadOptions;
+type ParserContextOptions<Sequence, Element> = RunParserOptions<unknown, Sequence, Element> & LookaheadOptions & {
+    errorsModule: typeof normalParserErrorModule | typeof noStackCaptureOverheadParserErrorModule;
+};
 export type ParserContext<Sequence, Element> = {
     from(elements: Element[]): Sequence;
     concat(sequences: Sequence[]): Sequence;
@@ -26,8 +28,8 @@ export type ParserContext<Sequence, Element> = {
     lookahead(options?: LookaheadOptions): ParserContext<Sequence, Element>;
     unlookahead(): void;
     dispose(): void;
-    invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
-    invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+    invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
+    invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
 };
 export declare class ParserContextImplementation<Sequence, Element> implements ParserContext<Sequence, Element> {
     private readonly _parserInputCompanion;
@@ -56,7 +58,7 @@ export declare class ParserContextImplementation<Sequence, Element> implements P
     lookahead(options?: LookaheadOptions): ParserContext<Sequence, Element>;
     unlookahead(): void;
     dispose(): void;
-    invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
-    invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+    invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
+    invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;
 }
 export {};

package/build/parserContext.js

@@ -1,7 +1,7 @@
 /* eslint-disable prefer-arrow-callback */
-import { ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError, } from './parserError.js';
 import { customInvariant } from './customInvariant.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { formatLazyMessage, isLazyMessageError } from './lazyMessageError.js';
 let parserContextId = 0;
 export class ParserContextImplementation {
     _parserInputCompanion;
@@ -81,7 +81,7 @@ export class ParserContextImplementation {
     async read(offset) {
         const element = await this.peek(offset);
         if (element === undefined) {
-            throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
+            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
         }
         this.skip(offset + 1);
         return element;
@@ -89,7 +89,7 @@ export class ParserContextImplementation {
     async readSequence(start, end) {
         const sequence = await this.peekSequence(start, end);
         if (sequence === undefined) {
-            throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
+            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
         }
         this.skip(end);
         return sequence;
@@ -121,7 +121,7 @@ export class ParserContextImplementation {
             'this: %s',
             'parent: %s',
             'parent.exclusiveChild: %s',
-        ].join('\n'), this.toString(), parentParserContext.toString(), parentParserContext._exclusiveChildParserContext?.toString());
+        ], () => this.toString(), () => parentParserContext.toString(), () => parentParserContext._exclusiveChildParserContext?.toString());
         parserImplementationInvariant(parentParserContext.position <= this.position, 'unlookahead this._parentParserContext.position (%s) <= this.position (%s)', parentParserContext.position, this.position);
         const offset = this._inputReader.position - parentParserContext._inputReader.position;
         parentParserContext.skip(offset);
@@ -140,14 +140,14 @@ export class ParserContextImplementation {
             'this: %s',
             'parent: %s',
             'parent.exclusiveChild: %s',
-        ].join('\n'), this.toString(), parentParserContext.toString(), parentParserContext._exclusiveChildParserContext?.toString());
+        ], () => this.toString(), () => parentParserContext.toString(), () => parentParserContext._exclusiveChildParserContext?.toString());
         parentParserContext._exclusiveChildParserContext = undefined;
         this._parentParserContext = undefined;
     }
     invariant(value, format, ...formatArguments) {
         const parserContext = this;
-        return customInvariant(function (message) {
-            return new ParserParsingInvariantError(message, parserContext._depth, parserContext.position);
+        return customInvariant(function (lazyMessage) {
+            return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position);
         }, value, format, ...formatArguments);
     }
     invariantJoin(value, childErrors, format, ...formatArguments) {
@@ -155,12 +155,12 @@ export class ParserContextImplementation {
         const errorJoinMode = this._options.errorJoinMode ?? 'none';
         const parserContext = this;
         if (errorJoinMode === 'none') {
-            return customInvariant(function (message) {
-                return new ParserParsingJoinNoneError(message, parserContext._depth, parserContext.position);
+            return customInvariant(function (lazyMessage) {
+                return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'furthest') {
-            return customInvariant(function (message) {
+            return customInvariant(function (userLazyMessage) {
                 let furthestPosition = 0;
                 let furthestChildErrors = [];
                 for (const childError of childErrors) {
@@ -174,20 +174,31 @@ export class ParserContextImplementation {
                     }
                     furthestChildErrors.push(childError);
                 }
-                message += [
-                    '',
-                    'Furthest child error stacks, indented:',
-                    ...furthestChildErrors.flatMap(furthestChildError => furthestChildError.stack?.split('\n').map(line => '  ' + line)),
-                    'End of furthest child error stacks',
-                ].join('\n');
-                return new ParserParsingJoinFurthestError(message, parserContext._depth, furthestPosition, furthestChildErrors);
+                return new parserContext._options.errorsModule.ParserParsingJoinFurthestError([
+                    [
+                        '%s',
+                        'Furthest child error stacks, indented:',
+                        '%s',
+                        'End of furthest child error stacks',
+                    ],
+                    () => formatLazyMessage(userLazyMessage),
+                    () => furthestChildErrors.flatMap(furthestChildError => {
+                        if (isLazyMessageError(furthestChildError)) {
+                            furthestChildError.computeMessage();
+                        }
+                        return furthestChildError.stack?.split('\n').map(line => '  ' + line);
+                    }).join('\n'),
+                ], parserContext._depth, furthestPosition, furthestChildErrors);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'deepest') {
-            return customInvariant(function (message) {
+            return customInvariant(function (userLazyMessage) {
                 let deepestDepth = 0;
                 let deepestChildErrors = [];
                 for (const childError of childErrors) {
+                    if (isLazyMessageError(childError)) {
+                        childError.computeMessage();
+                    }
                     if (childError.depth < deepestDepth) {
                         continue;
                     }
@@ -198,24 +209,40 @@ export class ParserContextImplementation {
                     }
                     deepestChildErrors.push(childError);
                 }
-                message += [
-                    '',
-                    'Deepest child error stacks, indented:',
-                    ...deepestChildErrors.flatMap(deepestChildError => deepestChildError.stack?.split('\n').map(line => '  ' + line)),
-                    'End of deepest child error stacks',
-                ].join('\n');
-                return new ParserParsingJoinDeepestError(message, deepestDepth, parserContext.position, deepestChildErrors);
+                return new parserContext._options.errorsModule.ParserParsingJoinDeepestError([
+                    [
+                        '%s',
+                        'Deepest child error stacks, indented:',
+                        '%s',
+                        'End of deepest child error stacks',
+                    ],
+                    () => formatLazyMessage(userLazyMessage),
+                    () => deepestChildErrors.flatMap(deepestChildError => {
+                        if (isLazyMessageError(deepestChildError)) {
+                            deepestChildError.computeMessage();
+                        }
+                        return deepestChildError.stack?.split('\n').map(line => '  ' + line);
+                    }).join('\n'),
+                ], deepestDepth, parserContext.position, deepestChildErrors);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'all') {
-            return customInvariant(function (message) {
-                message += [
-                    '',
-                    'Child error stacks, indented:',
-                    ...childErrors.flatMap(childError => childError.stack?.split('\n').map(line => '  ' + line)),
-                    'End of child error stacks',
-                ].join('\n');
-                return new ParserParsingJoinAllError(message, parserContext._depth, parserContext.position, childErrors);
+            return customInvariant(function (userLazyMessage) {
+                return new parserContext._options.errorsModule.ParserParsingJoinAllError([
+                    [
+                        '%s',
+                        'All child error stacks, indented:',
+                        '%s',
+                        'End of all child error stacks',
+                    ],
+                    () => formatLazyMessage(userLazyMessage),
+                    () => childErrors.flatMap(childError => {
+                        if (isLazyMessageError(childError)) {
+                            childError.computeMessage();
+                        }
+                        return childError.stack?.split('\n').map(line => '  ' + line);
+                    }).join('\n'),
+                ], parserContext._depth, parserContext.position, childErrors);
             }, value, format, ...formatArguments);
         }
         return parserImplementationInvariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);

package/build/parserContext.test.js

@@ -2,12 +2,14 @@ import test from 'ava';
 import { ParserContextImplementation } from './parserContext.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
-import { ParserUnexpectedEndOfInputError } from './parserError.js';
+import { noStackCaptureOverheadParserErrorModule } from './parserError.js';
 const commonParserContextArguments = [
     undefined,
     {
         debugName: 'root',
         errorJoinMode: 'all',
+        errorStack: false,
+        errorsModule: noStackCaptureOverheadParserErrorModule,
     },
 ];
 test('parserContext.read', async (t) => {
@@ -22,7 +24,8 @@ test('parserContext.read', async (t) => {
     t.is(await parserContext.read(0), 'b');
     t.is(await parserContext.read(5), 'h');
     await t.throwsAsync(async () => parserContext.read(0), {
-        instanceOf: ParserUnexpectedEndOfInputError,
+        any: true,
+        name: 'ParserUnexpectedEndOfInputError',
     });
 });
 test('parserContext.readSequence', async (t) => {
@@ -42,7 +45,8 @@ test('parserContext.readSequence', async (t) => {
     t.is(await parserContext.readSequence(1, 1), '');
     t.is(await parserContext.readSequence(0, 0), '');
     await t.throwsAsync(async () => parserContext.readSequence(0, 1), {
-        instanceOf: ParserUnexpectedEndOfInputError,
+        any: true,
+        name: 'ParserUnexpectedEndOfInputError',
     });
 });
 test('parserContext.lookahead', async (t) => {