@futpib/parser 1.0.1 → 1.0.2

package/build/parser.test.js

@@ -1,31 +1,32 @@
 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 { ParserError, ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError, ParserUnexpectedRemainingInputError, } 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';
 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,
@@ -35,6 +36,13 @@ 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) {
@@ -124,3 +132,62 @@ 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), {
+        instanceOf: ParserError,
+    });
+    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(() => runParser(parser, 'foobar', stringParserInputCompanion), {
+        instanceOf: 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.deepEqual(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(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(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.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 { 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

@@ -10,12 +10,19 @@ type LookaheadOptions = {
 type ParserContextOptions<Sequence, Element> = RunParserOptions<unknown, Sequence, Element> & LookaheadOptions;
 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;
@@ -33,12 +40,19 @@ 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;

package/build/parserContext.js

@@ -1,7 +1,7 @@
 /* eslint-disable prefer-arrow-callback */
-import invariant from 'invariant';
 import { ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError, } from './parserError.js';
 import { customInvariant } from './customInvariant.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 let parserContextId = 0;
 export class ParserContextImplementation {
     _parserInputCompanion;
@@ -33,12 +33,27 @@ export class ParserContextImplementation {
     from(elements) {
         return this._parserInputCompanion.from(elements);
     }
+    concat(sequences) {
+        return this._parserInputCompanion.concat(sequences);
+    }
     length(sequence) {
         return this._parserInputCompanion.length(sequence);
     }
     at(sequence, index) {
         return this._parserInputCompanion.at(sequence, index);
     }
+    subsequence(sequence, start, end) {
+        return this._parserInputCompanion.subsequence(sequence, start, end);
+    }
+    indexOf(sequence, element, fromIndex) {
+        return this._parserInputCompanion.indexOf(sequence, element, fromIndex);
+    }
+    indexOfSubsequence(sequence, subsequence, fromIndex) {
+        return this._parserInputCompanion.indexOfSubsequence(sequence, subsequence, fromIndex);
+    }
+    equals(sequenceA, sequenceB) {
+        return this._parserInputCompanion.equals(sequenceA, sequenceB);
+    }
     get position() {
         return this._inputReader.position;
     }
@@ -49,6 +64,17 @@ export class ParserContextImplementation {
         }
         return this._inputReader.peek(offset);
     }
+    async peekSequence(start, end) {
+        if (this._options.sliceEnd !== undefined
+            && (this.position + end - 1) >= this._options.sliceEnd) {
+            return undefined;
+        }
+        parserImplementationInvariant(start >= 0, 'start (%s) >= 0', start);
+        parserImplementationInvariant(end >= start, 'end (%s) >= start (%s)', start, end);
+        parserImplementationInvariant(Number.isSafeInteger(start), 'start (%d) is not a safe integer', start);
+        parserImplementationInvariant(Number.isSafeInteger(end), 'end (%d) is not a safe integer', end);
+        return this._inputReader.peekSequence(start, end);
+    }
     skip(offset) {
         this._inputReader.skip(offset);
     }
@@ -60,13 +86,19 @@ export class ParserContextImplementation {
         this.skip(offset + 1);
         return element;
     }
+    async readSequence(start, end) {
+        const sequence = await this.peekSequence(start, end);
+        if (sequence === undefined) {
+            throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
+        }
+        this.skip(end);
+        return sequence;
+    }
     lookahead(options = {}) {
         const lookaheadInputReader = this._inputReader.lookahead();
-        if (this.position !== lookaheadInputReader.position) {
-            debugger;
-        }
-        invariant(this.position === lookaheadInputReader.position, 'lookahead this.position (%s) === lookaheadInputReader.position (%s)', this.position, lookaheadInputReader.position);
-        const lookaheadParserContext = new ParserContextImplementation(this._parserInputCompanion, lookaheadInputReader, this, {
+        parserImplementationInvariant(this.position === lookaheadInputReader.position, 'lookahead this.position (%s) === lookaheadInputReader.position (%s)', this.position, lookaheadInputReader.position);
+        const ParserContext = this._options.parserContextClass ?? ParserContextImplementation;
+        const lookaheadParserContext = new ParserContext(this._parserInputCompanion, lookaheadInputReader, this, {
             ...this._options,
             ...options,
             debugName: [
@@ -78,41 +110,38 @@ export class ParserContextImplementation {
                 options.debugName,
             ].join(''),
         });
-        if (this.position !== lookaheadParserContext.position) {
-            debugger;
-        }
-        invariant(this.position === lookaheadParserContext.position, 'lookahead this.position (%s) === lookaheadParserContext.position (%s)', this.position, lookaheadParserContext.position);
+        parserImplementationInvariant(this.position === lookaheadParserContext.position, 'lookahead this.position (%s) === lookaheadParserContext.position (%s)', this.position, lookaheadParserContext.position);
         return lookaheadParserContext;
     }
     unlookahead() {
-        invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-        invariant((this._parentParserContext._exclusiveChildParserContext === undefined
-            || this._parentParserContext._exclusiveChildParserContext === this), [
+        const parentParserContext = parserImplementationInvariant(this._parentParserContext, 'this._parentParserContext !== undefined');
+        parserImplementationInvariant((parentParserContext._exclusiveChildParserContext === undefined
+            || parentParserContext._exclusiveChildParserContext === this), [
             'Parent\'s exclusive child must be undefined or this',
             'this: %s',
             'parent: %s',
             'parent.exclusiveChild: %s',
-        ].join('\n'), this.toString(), this._parentParserContext.toString(), this._parentParserContext._exclusiveChildParserContext?.toString());
-        invariant(this._parentParserContext.position <= this.position, 'unlookahead this._parentParserContext.position (%s) <= this.position (%s)', this._parentParserContext.position, this.position);
-        const offset = this._inputReader.position - this._parentParserContext._inputReader.position;
-        this._parentParserContext.skip(offset);
-        invariant(this._parentParserContext.position === this.position, 'unlookahead this._parentParserContext.position (%s) === this.position (%s)', this._parentParserContext.position, this.position);
-        this._inputReader = this._parentParserContext._inputReader;
-        this._parentParserContext._exclusiveChildParserContext = this;
+        ].join('\n'), 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);
+        parserImplementationInvariant(parentParserContext.position === this.position, 'unlookahead this._parentParserContext.position (%s) === this.position (%s)', parentParserContext.position, this.position);
+        this._inputReader = parentParserContext._inputReader;
+        parentParserContext._exclusiveChildParserContext = this;
         if (this._exclusiveChildParserContext) {
             this._exclusiveChildParserContext.unlookahead();
         }
     }
     dispose() {
-        invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-        invariant((this._parentParserContext._exclusiveChildParserContext === undefined
-            || this._parentParserContext._exclusiveChildParserContext === this), [
+        const parentParserContext = parserImplementationInvariant(this._parentParserContext, 'this._parentParserContext !== undefined');
+        parserImplementationInvariant((parentParserContext._exclusiveChildParserContext === undefined
+            || parentParserContext._exclusiveChildParserContext === this), [
             'Parent\'s exclusive child must be undefined or this',
             'this: %s',
             'parent: %s',
             'parent.exclusiveChild: %s',
-        ].join('\n'), this.toString(), this._parentParserContext.toString(), this._parentParserContext._exclusiveChildParserContext?.toString());
-        this._parentParserContext._exclusiveChildParserContext = undefined;
+        ].join('\n'), this.toString(), parentParserContext.toString(), parentParserContext._exclusiveChildParserContext?.toString());
+        parentParserContext._exclusiveChildParserContext = undefined;
         this._parentParserContext = undefined;
     }
     invariant(value, format, ...formatArguments) {
@@ -122,7 +151,7 @@ export class ParserContextImplementation {
         }, value, format, ...formatArguments);
     }
     invariantJoin(value, childErrors, format, ...formatArguments) {
-        invariant(childErrors.length > 0, 'childErrors.length > 0');
+        parserImplementationInvariant(childErrors.length > 0, 'childErrors.length > 0');
         const errorJoinMode = this._options.errorJoinMode ?? 'none';
         const parserContext = this;
         if (errorJoinMode === 'none') {
@@ -189,6 +218,6 @@ export class ParserContextImplementation {
                 return new ParserParsingJoinAllError(message, parserContext._depth, parserContext.position, childErrors);
             }, value, format, ...formatArguments);
         }
-        invariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
+        return parserImplementationInvariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
     }
 }

package/build/parserContext.test.js

@@ -25,6 +25,26 @@ test('parserContext.read', async (t) => {
         instanceOf: ParserUnexpectedEndOfInputError,
     });
 });
+test('parserContext.readSequence', async (t) => {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
+        yield '';
+        yield 'abc';
+        yield 'def';
+        yield '';
+        yield 'gh';
+    })()), ...commonParserContextArguments);
+    t.is(await parserContext.readSequence(0, 0), '');
+    t.is(await parserContext.readSequence(0, 1), 'a');
+    t.is(await parserContext.readSequence(1, 4), 'cde');
+    t.is(await parserContext.readSequence(0, 1), 'f');
+    t.is(await parserContext.readSequence(0, 0), '');
+    t.is(await parserContext.readSequence(0, 1), 'g');
+    t.is(await parserContext.readSequence(1, 1), '');
+    t.is(await parserContext.readSequence(0, 0), '');
+    await t.throwsAsync(async () => parserContext.readSequence(0, 1), {
+        instanceOf: ParserUnexpectedEndOfInputError,
+    });
+});
 test('parserContext.lookahead', async (t) => {
     const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
@@ -35,11 +55,15 @@ test('parserContext.lookahead', async (t) => {
         sliceEnd: 3,
     });
     t.is(await lookaheadContext3.peek(2), 'c');
+    t.is(await lookaheadContext3.peekSequence(2, 3), 'c');
     t.is(await lookaheadContext3.peek(3), undefined);
+    t.is(await lookaheadContext3.peekSequence(3, 4), undefined);
     t.is(await lookaheadContext3.read(0), 'a');
     t.is(await lookaheadContext3.read(0), 'b');
     t.is(await lookaheadContext3.read(0), 'c');
     t.is(await lookaheadContext3.peek(0), undefined);
+    t.is(await lookaheadContext3.peekSequence(0, 1), undefined);
+    t.is(await lookaheadContext3.peekSequence(0, 0), '');
     t.is(await parserContext.peek(0), 'a');
     t.is(await lookaheadContext1.peek(0), 'a');
     t.is(await lookaheadContext2.peek(0), 'a');
@@ -52,6 +76,9 @@ test('parserContext.lookahead', async (t) => {
     t.is(lookaheadContext1.position, 1);
     t.is(lookaheadContext2.position, 0);
     t.is(lookaheadContext3.position, 3);
+    lookaheadContext3.skip(1);
+    t.is(await lookaheadContext3.peekSequence(0, 0), undefined);
+    t.is(lookaheadContext3.position, 4);
 });
 test('parserContext.unlookahead', async (t) => {
     const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {

package/build/parserCreatorCompose.d.ts

@@ -1,3 +1,4 @@
 import { type Parser } from './parser.js';
 import { type DeriveSequenceElement } from './sequence.js';
 export declare function parserCreatorCompose<Arguments extends unknown[], OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element>;
+export declare function parserCreatorComposeMem<Arguments extends unknown[], OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element>;

package/build/parserCreatorCompose.js

@@ -1,10 +1,16 @@
+import mem from 'mem';
 export function parserCreatorCompose(f1, f2) {
-    return (...arguments_) => {
+    const parserCreatorComposedOuter = (...arguments_) => {
         const parserA = f1(...arguments_);
-        return async (parserContext) => {
+        const parserCreatorComposedInner = async (parserContext) => {
             const outputA = await parserA(parserContext);
             const parserB = f2(outputA);
             return parserB(parserContext);
         };
+        return parserCreatorComposedInner;
     };
+    return parserCreatorComposedOuter;
+}
+export function parserCreatorComposeMem(f1, f2) {
+    return parserCreatorCompose(mem(f1), mem(f2));
 }

package/build/parserError.d.ts

@@ -1,5 +1,8 @@
+import { InputReaderState } from "./inputReaderState.js";
 export declare class ParserError extends Error {
     name: string;
+    position: undefined | number;
+    inputReaderSate: undefined | InputReaderState<unknown>;
 }
 export declare class ParserImplementationError extends ParserError {
     name: string;
@@ -41,3 +44,6 @@ export declare class ParserParsingInvariantError extends ParserParsingFailedErro
 export declare class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
     name: string;
 }
+export declare class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+    name: string;
+}

package/build/parserError.js

@@ -1,5 +1,7 @@
 export class ParserError extends Error {
     name = 'ParserError';
+    position = undefined;
+    inputReaderSate = undefined;
 }
 export class ParserImplementationError extends ParserError {
     name = 'ParserImplementationError';
@@ -12,12 +14,7 @@ export class ParserParsingFailedError extends ParserError {
     position;
     name = 'ParserParsingFailedError';
     constructor(message, depth, position) {
-        super([
-            '(position: ',
-            position,
-            ') ',
-            message,
-        ].join(''));
+        super(message);
         this.depth = depth;
         this.position = position;
     }
@@ -59,3 +56,6 @@ export class ParserParsingInvariantError extends ParserParsingFailedError {
 export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
     name = 'ParserUnexpectedEndOfInputError';
 }
+export class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+    name = 'ParserUnexpectedRemainingInputError';
+}

package/build/parserInputCompanion.d.ts

@@ -1,20 +1,35 @@
 export type ParserInputCompanion<Sequence, Element> = {
     is(value: unknown): value is Sequence;
     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;
 };
 export declare class StringParserInputCompanion implements ParserInputCompanion<string, string> {
     is(value: unknown): value is string;
     from(elements: string[]): string;
+    concat(sequences: string[]): string;
     length(sequence: string): number;
     at(sequence: string, index: number): string | undefined;
+    subsequence(sequence: string, start: number, end: number): string;
+    indexOf(sequence: string, element: string, fromIndex?: number): number;
+    indexOfSubsequence(sequence: string, subsequence: string, fromIndex?: number): number;
+    equals(sequenceA: string, sequenceB: string): boolean;
 }
 export declare const stringParserInputCompanion: StringParserInputCompanion;
 export declare class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint8Array, number> {
     is(value: unknown): value is Uint8Array;
     from(elements: number[]): Uint8Array;
+    concat(sequences: Uint8Array[]): Uint8Array;
     length(sequence: Uint8Array): number;
     at(sequence: Uint8Array, index: number): number | undefined;
+    subsequence(sequence: Uint8Array, start: number, end: number): Uint8Array;
+    indexOf(sequence: Uint8Array, element: number, fromIndex?: number): number;
+    indexOfSubsequence(sequence: Uint8Array, subsequence: Uint8Array, fromIndex?: number): number;
+    equals(sequenceA: Uint8Array, sequenceB: Uint8Array): boolean;
 }
 export declare const uint8ArrayParserInputCompanion: Uint8ArrayParserInputCompanion;

package/build/parserInputCompanion.js

@@ -5,12 +5,27 @@ export class StringParserInputCompanion {
     from(elements) {
         return elements.join('');
     }
+    concat(sequences) {
+        return sequences.join('');
+    }
     length(sequence) {
         return sequence.length;
     }
     at(sequence, index) {
         return sequence.at(index);
     }
+    subsequence(sequence, start, end) {
+        return sequence.slice(start, end);
+    }
+    indexOf(sequence, element, fromIndex) {
+        return sequence.indexOf(element, fromIndex);
+    }
+    indexOfSubsequence(sequence, subsequence, fromIndex) {
+        return sequence.indexOf(subsequence, fromIndex);
+    }
+    equals(sequenceA, sequenceB) {
+        return sequenceA === sequenceB;
+    }
 }
 export const stringParserInputCompanion = new StringParserInputCompanion();
 export class Uint8ArrayParserInputCompanion {
@@ -20,11 +35,34 @@ export class Uint8ArrayParserInputCompanion {
     from(elements) {
         return new Uint8Array(elements);
     }
+    concat(sequences) {
+        return new Uint8Array(Buffer.concat(sequences));
+    }
     length(sequence) {
         return sequence.length;
     }
     at(sequence, index) {
         return sequence.at(index);
     }
+    subsequence(sequence, start, end) {
+        return sequence.subarray(start, end);
+    }
+    indexOf(sequence, element, fromIndex) {
+        return sequence.indexOf(element, fromIndex);
+    }
+    indexOfSubsequence(sequence, subsequence, fromIndex) {
+        return Buffer.from(sequence).indexOf(Buffer.from(subsequence), fromIndex);
+    }
+    equals(sequenceA, sequenceB) {
+        if (sequenceA.length !== sequenceB.length) {
+            return false;
+        }
+        for (let index = 0; index < sequenceA.length; index++) {
+            if (sequenceA[index] !== sequenceB[index]) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 export const uint8ArrayParserInputCompanion = new Uint8ArrayParserInputCompanion();

package/build/promiseCompose.d.ts

@@ -1 +1 @@
-export declare function promiseCompose<A, B, C>(f1: (a: A) => Promise<B>, f2: (b: B) => C | Promise<C>): (a: A) => Promise<C>;
+export declare function promiseCompose<A, B, C>(f1: (a: A) => B | Promise<B>, f2: (b: B) => C | Promise<C>): (a: A) => C | Promise<C>;

package/build/promiseCompose.js

@@ -1,3 +1,14 @@
 export function promiseCompose(f1, f2) {
-    return async (a) => f1(a).then(f2);
+    function promiseComposed(a) {
+        const bOrBPromise = f1(a);
+        if (bOrBPromise instanceof Promise) {
+            return bOrBPromise.then(f2);
+        }
+        return f2(bOrBPromise);
+    }
+    ;
+    Object.defineProperty(promiseComposed, 'name', {
+        value: `promiseCompose(${f1.name}, ${f2.name})`,
+    });
+    return promiseComposed;
 }

package/build/promiseSettled.d.ts

@@ -0,0 +1 @@
+export declare function promiseSettled<T>(promise: Promise<T>): Promise<PromiseSettledResult<T>>;

package/build/promiseSettled.js

@@ -0,0 +1,4 @@
+export async function promiseSettled(promise) {
+    const [promiseSettledResult] = await Promise.allSettled([promise]);
+    return promiseSettledResult;
+}

package/build/separatedArrayParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createSeparatedArrayParser: <ElementOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, separatorParser: Parser<unknown, Sequence>) => Parser<ElementOutput[], Sequence>;