@futpib/parser 1.0.1 → 1.0.3

package/build/parser.test.js

@@ -1,31 +1,33 @@
 import test from 'ava';
 import invariant from 'invariant';
 import { createUnionParser } from './unionParser.js';
-import { runParser } from './parser.js';
+import { runParser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
-import { ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError, } from './parserError.js';
+import { isParserParsingJoinError, normalParserErrorModule, } from './parserError.js';
 import { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
-import { createExactSequenceParser } from './exactSequenceParser.js';
+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([
-    createExactSequenceParser('1'),
-    createExactSequenceParser('aa'),
-    createExactSequenceParser('AAA'),
+    createExactSequenceNaiveParser('1'),
+    createExactSequenceNaiveParser('aa'),
+    createExactSequenceNaiveParser('AAA'),
 ]);
 const abDisjunctionParser = createDisjunctionParser([
     aUnionParser,
-    createExactSequenceParser('2'),
-    createExactSequenceParser('bb'),
-    createExactSequenceParser('BBB'),
+    createExactSequenceNaiveParser('2'),
+    createExactSequenceNaiveParser('bb'),
+    createExactSequenceNaiveParser('BBB'),
 ]);
 const abcUnionParser = createUnionParser([
     abDisjunctionParser,
-    createExactSequenceParser('final_3'),
-    createExactSequenceParser('final_cc'),
-    createExactSequenceParser('final_CCC'),
+    createExactSequenceNaiveParser('final_3'),
+    createExactSequenceNaiveParser('final_cc'),
+    createExactSequenceNaiveParser('final_CCC'),
 ]);
 const sampleParser = promiseCompose(createTupleParser([
     aUnionParser,
@@ -38,19 +40,20 @@ async function* asyncIteratorFromString(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, []);
@@ -59,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);
@@ -124,3 +178,65 @@ test('throws on parserInputCompanion type mismatch', async (t) => {
         message: /input companion/,
     });
 });
+test('thrown error has input reader state', async (t) => {
+    const error = await t.throwsAsync(runParser(createTupleParser([
+        createExactSequenceNaiveParser('foo'),
+        createExactSequenceNaiveParser('bar'),
+    ]), (async function* () {
+        yield 'foo';
+        yield 'qux';
+        yield 'bar';
+    })(), stringParserInputCompanion, {
+        errorStack: true,
+    }), {
+        instanceOf: normalParserErrorModule.ParserParsingInvariantError,
+    });
+    t.is(error.position, 4);
+    invariant(error.inputReaderSate, 'error.inputReaderSate');
+    const { consumedBufferedSequences, unconsumedBufferedSequences, unbufferedSequences, position, ...inputReaderStateRest } = error.inputReaderSate;
+    t.is(position, 4);
+    t.deepEqual(inputReaderStateRest, {});
+    const unbufferedSequencesArray = [];
+    if (unbufferedSequences) {
+        for await (const sequence of toAsyncIterable(unbufferedSequences)) {
+            unbufferedSequencesArray.push(sequence);
+        }
+    }
+    t.deepEqual(consumedBufferedSequences, ['q']);
+    t.deepEqual(unconsumedBufferedSequences, ['ux']);
+    t.deepEqual(unbufferedSequencesArray, ['bar']);
+});
+test('runParser throws with remaining input', async (t) => {
+    const parser = createExactSequenceNaiveParser('foo');
+    const error = await t.throwsAsync(async () => runParser(parser, 'foobar', stringParserInputCompanion), {
+        any: true,
+        name: 'ParserUnexpectedRemainingInputError',
+        message: /remaining input/,
+    });
+    t.is(error.position, 3);
+    const { position, consumedBufferedSequences, unconsumedBufferedSequences, unbufferedSequences, ...inputReaderStateRest } = error.inputReaderSate;
+    t.deepEqual(inputReaderStateRest, {});
+    t.is(position, 3);
+    t.deepEqual(consumedBufferedSequences, ['foo']);
+    t.deepEqual(unconsumedBufferedSequences, ['bar']);
+    t.truthy(unbufferedSequences);
+});
+test('runParser does not throw without remaining input', async (t) => {
+    const parser = createExactSequenceNaiveParser('foo');
+    const output = await runParser(parser, 'foo', stringParserInputCompanion);
+    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.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.is(output, 'foo');
+    t.is(remainingInput, undefined);
+});

package/build/parserAccessorParser.js

@@ -1 +1,9 @@
-export const createParserAccessorParser = (parserAccessor) => async (parserContext) => parserAccessor()(parserContext);
+import { getParserName, setParserName } from './parser.js';
+export const createParserAccessorParser = (parserAccessor) => {
+    const parserAccessorParser = async (parserContext) => {
+        const parser = parserAccessor();
+        setParserName(parserAccessorParser, `parserAccessorParser(${getParserName(parser, 'anonymousParserAccessor')})`);
+        return parser(parserContext);
+    };
+    return parserAccessorParser;
+};

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,17 +1,22 @@
-import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
-export const createParserConsumedSequenceParser = (childParser) => async (parserContext) => {
-    const initialPosition = parserContext.position;
-    const childParserContext = parserContext.lookahead();
-    let value;
-    let consumedLength;
-    try {
-        value = await childParser(childParserContext);
-        consumedLength = childParserContext.position - initialPosition;
-    }
-    finally {
-        childParserContext.dispose();
-    }
-    const consumedSequenceParser = createFixedLengthSequenceParser(consumedLength);
-    const consumedSequence = await consumedSequenceParser(parserContext);
-    return [value, consumedSequence];
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { getParserName, setParserName } from './parser.js';
+export const createParserConsumedSequenceParser = (childParser) => {
+    const parserConsumedSequenceParser = async (parserContext) => {
+        const initialPosition = parserContext.position;
+        const childParserContext = parserContext.lookahead();
+        let value;
+        let consumedLength;
+        try {
+            value = await childParser(childParserContext);
+            consumedLength = childParserContext.position - initialPosition;
+        }
+        finally {
+            childParserContext.dispose();
+        }
+        const consumedSequenceParser = createFixedLengthSequenceParser(consumedLength);
+        const consumedSequence = await consumedSequenceParser(parserContext);
+        return [value, consumedSequence];
+    };
+    setParserName(parserConsumedSequenceParser, `parserConsumedSequenceParser(${getParserName(childParser, 'anonymousParserConsumedSequenceParserChild')})`);
+    return parserConsumedSequenceParser;
 };

package/build/parserContext.d.ts

@@ -1,26 +1,35 @@
 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;
     length(sequence: Sequence): number;
     at(sequence: Sequence, index: number): Element | undefined;
+    subsequence(sequence: Sequence, start: number, end: number): Sequence;
+    indexOf(sequence: Sequence, element: Element, fromIndex?: number): number;
+    indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number;
+    equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
     get position(): number;
     peek(offset: number): Promise<Element | undefined>;
+    peekSequence(start: number, end: number): Promise<Sequence | undefined>;
     skip(offset: number): void;
     read(offset: number): Promise<Element>;
+    readSequence(start: number, end: number): Promise<Sequence>;
     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;
@@ -33,16 +42,23 @@ export declare class ParserContextImplementation<Sequence, Element> implements P
     constructor(_parserInputCompanion: ParserInputCompanion<Sequence, Element>, _inputReader: InputReader<Sequence, Element>, _parentParserContext: ParserContextImplementation<Sequence, Element> | undefined, _options: ParserContextOptions<Sequence, Element>);
     get [Symbol.toStringTag](): string;
     from(elements: Element[]): Sequence;
+    concat(sequences: Sequence[]): Sequence;
     length(sequence: Sequence): number;
     at(sequence: Sequence, index: number): Element | undefined;
+    subsequence(sequence: Sequence, start: number, end: number): Sequence;
+    indexOf(sequence: Sequence, element: Element, fromIndex?: number): number;
+    indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number;
+    equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
     get position(): number;
     peek(offset: number): Promise<Element | undefined>;
+    peekSequence(start: number, end: number): Promise<Sequence | undefined>;
     skip(offset: number): void;
     read(offset: number): Promise<Element>;
+    readSequence(start: number, end: number): Promise<Sequence>;
     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 {};