@futpib/parser 1.0.0 → 1.0.2

package/build/listParser.js

@@ -1,8 +1,8 @@
-import { createNegativeLookaheadParser } from "./negativeLookahead.js";
-import { createParserAccessorParser } from "./parserAccessorParser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createTupleParser } from "./tupleParser.js";
-import { createUnionParser } from "./unionParser.js";
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createUnionParser } from './unionParser.js';
 class Nil {
 }
 class Cons {

package/build/lookaheadParser.d.ts

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

package/build/lookaheadParser.js

@@ -0,0 +1,14 @@
+import { getParserName, setParserName } from './parser.js';
+export const createLookaheadParser = (childParser) => {
+    const lookaheadParser = async (parserContext) => {
+        const childParserContext = parserContext.lookahead();
+        try {
+            return await childParser(childParserContext);
+        }
+        finally {
+            childParserContext.dispose();
+        }
+    };
+    setParserName(lookaheadParser, `(?=${getParserName(childParser)})`);
+    return lookaheadParser;
+};

package/build/{negativeLookahead.d.ts → negativeLookaheadParser.d.ts}

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

package/build/negativeLookaheadParser.js

@@ -0,0 +1,24 @@
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+export const createNegativeLookaheadParser = (childParser) => {
+    const negativeLookaheadParser = async (parserContext) => {
+        const childParserContext = parserContext.lookahead();
+        let childParserSuccess;
+        try {
+            await childParser(childParserContext);
+            childParserSuccess = true;
+        }
+        catch (error) {
+            if (!(error instanceof ParserParsingFailedError)) {
+                throw error;
+            }
+            childParserSuccess = false;
+        }
+        finally {
+            childParserContext.dispose();
+        }
+        parserContext.invariant(!childParserSuccess, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
+    };
+    setParserName(negativeLookaheadParser, `(?!${getParserName(childParser)})`);
+    return negativeLookaheadParser;
+};

package/build/negativeLookaheadParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/negativeLookaheadParser.test.js

@@ -0,0 +1,30 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createTupleParser } from './tupleParser.js';
+import { ParserParsingFailedError } from './parserError.js';
+testProp('negativeLookaheadParser', [
+    fc.tuple(fc.string({
+        minLength: 1,
+    }), fc.string({
+        minLength: 1,
+    })).filter(([a, b]) => !a.startsWith(b))
+], async (t, [stringA, stringB]) => {
+    const result = await runParser(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(stringB)),
+        createExactSequenceParser(stringA + stringB),
+    ]), stringA + stringB, stringParserInputCompanion);
+    t.deepEqual(result, [undefined, stringA + stringB]);
+    await t.throwsAsync(() => runParser(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(stringA)),
+        createExactSequenceParser(stringA + stringB),
+    ]), stringA + stringB, stringParserInputCompanion), {
+        instanceOf: ParserParsingFailedError,
+        message: /lookahead/,
+    });
+}, {
+    verbose: true,
+});

package/build/nonEmptyArrayParser.d.ts

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

package/build/nonEmptyArrayParser.js

@@ -0,0 +1,32 @@
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+export const createNonEmptyArrayParser = (elementParser) => {
+    const nonEmptyArrayParser = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const elementParserContext = parserContext.lookahead();
+            const initialPosition = elementParserContext.position;
+            try {
+                const element = await elementParser(elementParserContext);
+                if (elementParserContext.position === initialPosition) {
+                    break;
+                }
+                elements.push(element);
+                elementParserContext.unlookahead();
+            }
+            catch (error) {
+                if (error instanceof ParserParsingFailedError) {
+                    break;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+        }
+        parserContext.invariant(elements.length > 0, 'Expected elementParser (%s) to match at least once', getParserName(elementParser, 'anonymousNonEmptyArrayChild'));
+        return elements;
+    };
+    setParserName(nonEmptyArrayParser, getParserName(elementParser, 'anonymousNonEmptyArrayChild') + '+');
+    return nonEmptyArrayParser;
+};

package/build/nonEmptyArrayParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/nonEmptyArrayParser.test.js

@@ -0,0 +1,16 @@
+import test from 'ava';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { runParser } from './parser.js';
+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), {
+        message: /Expected .* to match at least once/,
+    });
+});
+test('non-empty array matches', async (t) => {
+    const parser = createNonEmptyArrayParser(createExactElementParser('0'));
+    const result = await runParser(parser, '0', stringParserInputCompanion);
+    t.deepEqual(result, ['0']);
+});

package/build/optionalParser.d.ts

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

package/build/optionalParser.js

@@ -1,5 +1,5 @@
-import { getParserName, setParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
 export const createOptionalParser = (childParser) => {
     const optionalParser = async (parserContext) => {
         const childParserContext = parserContext.lookahead();

package/build/parser.d.ts

@@ -1,10 +1,19 @@
-import { type InputCompanion } from './inputCompanion.js';
+import { Class } from 'type-fest';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type ParserContext } from './parserContext.js';
-import { DeriveSequenceElement } from './sequence.js';
-export type Parser<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = (parserContext: ParserContext<Sequence, Element>) => Promise<Output>;
+import { type DeriveSequenceElement } from './sequence.js';
+export type Parser<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = (parserContext: ParserContext<Sequence, Element>) => Output | Promise<Output>;
 export declare function getParserName(parser: Parser<any, any, any>, default_?: string): string;
 export declare function setParserName<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, name: string): Parser<Output, Sequence, Element>;
+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';
+    parserContextClass?: Class<ParserContext<Sequence, Element>>;
 };
-export declare function runParser<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence, inputCompanion: InputCompanion<Sequence, Element>, options?: RunParserOptions<Output, Sequence, Element>): Promise<Output>;
+export type RunParserWithRemainingInputResult<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = {
+    output: Output;
+    position: number;
+    remainingInput: undefined | AsyncIterable<Sequence>;
+};
+export declare function runParserWithRemainingInput<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence, parserInputCompanion: ParserInputCompanion<Sequence, Element>, options?: RunParserOptions<Output, Sequence, Element>): Promise<RunParserWithRemainingInputResult<Output, Sequence, Element>>;
+export declare function runParser<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence, parserInputCompanion: ParserInputCompanion<Sequence, Element>, options?: RunParserOptions<Output, Sequence, Element>): Promise<Output>;

package/build/parser.js

@@ -1,6 +1,8 @@
-import invariant from 'invariant';
 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';
 export function getParserName(parser, default_ = 'anonymous') {
     return parser.name || default_;
 }
@@ -10,44 +12,77 @@ export function setParserName(parser, name) {
     });
     return parser;
 }
-function isAsyncIterable(value) {
-    return value && typeof value[Symbol.asyncIterator] === 'function';
-}
-function isIterable(value) {
-    return value && typeof value[Symbol.iterator] === 'function';
-}
-function isIterator(value) {
-    return value && typeof value.next === 'function';
-}
-function iteratorToAsyncIterator(iterator) {
-    return {
-        next: async () => iterator.next(),
+const originalParserByClone = new WeakMap();
+export function cloneParser(parser) {
+    const originalParser = originalParserByClone.get(parser) ?? parser;
+    const clone = (parserContext) => {
+        return originalParser(parserContext);
     };
+    setParserName(clone, getParserName(parser));
+    originalParserByClone.set(clone, originalParser);
+    return clone;
 }
-function toAsyncIterator(value) {
-    if (typeof value === 'string'
-        || value instanceof Uint8Array) {
-        return (async function* () {
-            yield value;
-        })();
-    }
-    if (isAsyncIterable(value)) {
-        return value[Symbol.asyncIterator]();
-    }
-    if (isIterable(value)) {
-        return iteratorToAsyncIterator(value[Symbol.iterator]());
+async function withEnrichedParserError(parserContext, inputReader, f) {
+    try {
+        return await f();
     }
-    if (isIterator(value)) {
-        return iteratorToAsyncIterator(value);
+    catch (error) {
+        if (error instanceof ParserError) {
+            if (error.position === undefined) {
+                error.position = parserContext.position;
+            }
+            if (error.inputReaderSate === undefined) {
+                error.inputReaderSate = inputReader.toInputReaderState();
+            }
+        }
+        throw error;
     }
-    invariant(false, 'Value must be an async iterator, async iterable, iterable or iterator got %s.', value);
 }
-export async function runParser(parser, input, inputCompanion, options = {}) {
+function runParserInternal(parser, input, parserInputCompanion, options = {}) {
     const inputAsyncIterator = toAsyncIterator(input);
-    const inputReader = new InputReaderImplementation(inputCompanion, inputAsyncIterator);
-    const parserContext = new ParserContextImplementation(inputCompanion, inputReader, undefined, {
+    const inputReader = new InputReaderImplementation(parserInputCompanion, inputAsyncIterator);
+    const ParserContext = options.parserContextClass ?? ParserContextImplementation;
+    const parserContext = new ParserContext(parserInputCompanion, inputReader, undefined, {
         ...options,
         debugName: 'root',
     });
-    return parser(parserContext);
+    const outputPromise = (async () => {
+        try {
+            return await parser(parserContext);
+        }
+        finally {
+            await parserContext.peek(0);
+        }
+    })();
+    return {
+        outputPromise,
+        parserContext,
+        inputReader,
+    };
+}
+export async function runParserWithRemainingInput(parser, input, parserInputCompanion, options = {}) {
+    const { outputPromise, parserContext, inputReader, } = runParserInternal(parser, input, parserInputCompanion, options);
+    return await withEnrichedParserError(parserContext, inputReader, async () => {
+        const output = await outputPromise;
+        const inputReaderState = inputReader.toInputReaderState();
+        const remainingInput = (inputReaderStateCompanion.isDone(inputReaderState)
+            ? undefined
+            : inputReaderStateCompanion.toRemainingInputAsyncIterator(inputReaderState));
+        return {
+            output,
+            position: parserContext.position,
+            remainingInput,
+        };
+    });
+}
+export async function runParser(parser, input, parserInputCompanion, options = {}) {
+    const { outputPromise, parserContext, inputReader, } = runParserInternal(parser, input, parserInputCompanion, options);
+    return await 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);
+        }
+        return output;
+    });
 }

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 { stringInputCompanion, uint8ArrayInputCompanion } from './inputCompanion.js';
-import { ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError } from './parserError.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 { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
-import invariant from 'invariant';
-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) {
@@ -44,23 +52,23 @@ function sortChildErrors(error) {
     }
 }
 function removeStackLocations(errorStack) {
-    return errorStack.replace(/((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!'), stringInputCompanion, {
+    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'none',
     }), {
-        instanceOf: ParserParsingJoinNoneError
+        instanceOf: ParserParsingJoinNoneError,
     });
     t.is(error.position, 12);
     t.deepEqual(error.childErrors, []);
     t.snapshot(removeStackLocations(error.stack));
 });
 test('errorJoinMode: all', async (t) => {
-    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'all',
     }), {
-        instanceOf: ParserParsingJoinAllError
+        instanceOf: ParserParsingJoinAllError,
     });
     sortChildErrors(error);
     t.snapshot(removeStackLocations(error.stack));
@@ -79,7 +87,7 @@ test('errorJoinMode: all', async (t) => {
     t.is(error3.position, 4, 'error3.position');
 });
 test('errorJoinMode: deepest', async (t) => {
-    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'deepest',
     }), {
         instanceOf: ParserParsingJoinDeepestError,
@@ -101,7 +109,7 @@ test('errorJoinMode: deepest', async (t) => {
     t.is(error3.position, 4);
 });
 test('errorJoinMode: furthest', async (t) => {
-    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+    const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
         errorJoinMode: 'furthest',
     }), {
         instanceOf: ParserParsingJoinFurthestError,
@@ -114,13 +122,72 @@ test('errorJoinMode: furthest', async (t) => {
     invariant(error1 instanceof ParserParsingInvariantError, 'error1 instanceof ParserParsingInvariantError');
     t.is(error1.position, 12);
 });
-test('throws on inputCompanion type mismatch', async (t) => {
+test('throws on parserInputCompanion type mismatch', async (t) => {
     const anythingParser = createArrayParser(createElementParser());
-    await runParser(anythingParser, asyncIteratorFromString('anything'), stringInputCompanion);
-    await runParser(anythingParser, 'anything', stringInputCompanion);
-    await runParser(anythingParser, Buffer.from('anything'), uint8ArrayInputCompanion);
-    await runParser(anythingParser, new Uint8Array([1, 2, 3]), uint8ArrayInputCompanion);
-    await t.throwsAsync(runParser(anythingParser, asyncIteratorFromString('anything'), uint8ArrayInputCompanion), {
+    await runParser(anythingParser, asyncIteratorFromString('anything'), stringParserInputCompanion);
+    await runParser(anythingParser, 'anything', stringParserInputCompanion);
+    await runParser(anythingParser, Buffer.from('anything'), uint8ArrayParserInputCompanion);
+    await runParser(anythingParser, new Uint8Array([1, 2, 3]), uint8ArrayParserInputCompanion);
+    await t.throwsAsync(runParser(anythingParser, asyncIteratorFromString('anything'), uint8ArrayParserInputCompanion), {
         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.d.ts

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

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

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

package/build/parserConsumedSequenceParser.js

@@ -0,0 +1,22 @@
+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,8 +1,8 @@
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type InputReader } from './inputReader.js';
-import { ParserParsingFailedError } from './parserError.js';
-import { RunParserOptions } from './parser.js';
-import { Falsy, ValueOrAccessor } from './parserInvariant.js';
+import { type ParserParsingFailedError } from './parserError.js';
+import { type RunParserOptions } from './parser.js';
+import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
 type LookaheadOptions = {
     debugName?: string;
     sliceEnd?: number;
@@ -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;
@@ -23,22 +30,29 @@ export type ParserContext<Sequence, Element> = {
     invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
 };
 export declare class ParserContextImplementation<Sequence, Element> implements ParserContext<Sequence, Element> {
-    private readonly _inputCompanion;
+    private readonly _parserInputCompanion;
     private _inputReader;
     private _parentParserContext;
     private readonly _options;
     private readonly _id;
     private readonly _depth;
     private _exclusiveChildParserContext;
-    constructor(_inputCompanion: InputCompanion<Sequence, Element>, _inputReader: InputReader<Sequence, Element>, _parentParserContext: ParserContextImplementation<Sequence, Element> | undefined, _options: ParserContextOptions<Sequence, Element>);
+    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;