@futpib/parser 1.0.0 → 1.0.1

package/build/exactSequenceParser.js

@@ -1,4 +1,4 @@
-import { inspect } from 'util';
+import { inspect } from 'node:util';
 import { setParserName } from './parser.js';
 export const createExactSequenceParser = (sequence) => {
     const exactSequenceParser = async (parserContext) => {

package/build/index.d.ts

@@ -1,5 +1,5 @@
-export { Parser, runParser, setParserName, getParserName, } from './parser.js';
-export { ParserContext, } from './parserContext.js';
+export { type Parser, runParser, setParserName, getParserName, } from './parser.js';
+export type { ParserContext, } from './parserContext.js';
 export { createTupleParser, } from './tupleParser.js';
 export { createExactSequenceParser, } from './exactSequenceParser.js';
 export { createFixedLengthSequenceParser, } from './fixedLengthSequenceParser.js';
@@ -16,3 +16,6 @@ export { createSkipParser, } from './skipParser.js';
 export { createEndOfInputParser, } from './endOfInputParser.js';
 export { createListParser, } from './listParser.js';
 export { createDebugLogParser, } from './debugLogParser.js';
+export { type Unparser, runUnparser, } from './unparser.js';
+export { createArrayUnparser, } from './arrayUnparser.js';
+export { createSequenceUnparser, } from './sequenceUnparser.js';

package/build/index.js

@@ -15,3 +15,6 @@ export { createSkipParser, } from './skipParser.js';
 export { createEndOfInputParser, } from './endOfInputParser.js';
 export { createListParser, } from './listParser.js';
 export { createDebugLogParser, } from './debugLogParser.js';
+export { runUnparser, } from './unparser.js';
+export { createArrayUnparser, } from './arrayUnparser.js';
+export { createSequenceUnparser, } from './sequenceUnparser.js';

package/build/inputReader.d.ts

@@ -1,4 +1,4 @@
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 export type InputReader<Sequence, Element> = {
     get position(): number;
     peek(offset: number): Promise<Element | undefined>;
@@ -6,14 +6,14 @@ export type InputReader<Sequence, Element> = {
     lookahead(): InputReader<Sequence, Element>;
 };
 export declare class InputReaderImplementation<Sequence, Element> implements InputReader<Sequence, Element> {
-    private readonly _inputCompanion;
+    private readonly _parserInputCompanion;
     private readonly _inputAsyncIterator;
     private readonly _id;
     private _position;
     private _uncommitedSkipOffset;
     private readonly _promiseMutex;
     private readonly _sequenceBuffer;
-    constructor(_inputCompanion: InputCompanion<Sequence, Element>, _inputAsyncIterator: AsyncIterator<Sequence>);
+    constructor(_parserInputCompanion: ParserInputCompanion<Sequence, Element>, _inputAsyncIterator: AsyncIterator<Sequence>);
     get [Symbol.toStringTag](): string;
     get position(): number;
     peek(offset: number): Promise<Element | undefined>;

package/build/inputReader.js

@@ -4,17 +4,17 @@ import { SequenceBufferImplementation } from './sequenceBuffer.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 let inputReaderId = 0;
 export class InputReaderImplementation {
-    _inputCompanion;
+    _parserInputCompanion;
     _inputAsyncIterator;
     _id = inputReaderId++;
     _position = 0;
     _uncommitedSkipOffset = 0;
     _promiseMutex = new PromiseMutex();
     _sequenceBuffer;
-    constructor(_inputCompanion, _inputAsyncIterator) {
-        this._inputCompanion = _inputCompanion;
+    constructor(_parserInputCompanion, _inputAsyncIterator) {
+        this._parserInputCompanion = _parserInputCompanion;
         this._inputAsyncIterator = _inputAsyncIterator;
-        this._sequenceBuffer = new SequenceBufferImplementation(this._inputCompanion);
+        this._sequenceBuffer = new SequenceBufferImplementation(this._parserInputCompanion);
     }
     get [Symbol.toStringTag]() {
         return [
@@ -43,11 +43,11 @@ export class InputReaderImplementation {
                 if (inputIteratorResult.done) {
                     return undefined;
                 }
-                parserImplementationInvariant(this._inputCompanion.is(inputIteratorResult.value), [
+                parserImplementationInvariant(this._parserInputCompanion.is(inputIteratorResult.value), [
                     'Input iterator result value (%s) is of unexpected type.',
                     'Expected a sequence (a chunk of input) recognized by the input companion (%s).',
                     'You may have provided a wrong input companion for the input.',
-                ], inputIteratorResult.value, this._inputCompanion.constructor.name);
+                ], inputIteratorResult.value, this._parserInputCompanion.constructor.name);
                 this._sequenceBuffer.push(inputIteratorResult.value);
             }
         });

package/build/inputReader.test.js

@@ -1,9 +1,9 @@
 import test from 'ava';
 import { InputReaderImplementation } from './inputReader.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { ParserImplementationError } from './parserError.js';
 test('inputReader', async (t) => {
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield '';
         yield 'abc';
         yield 'def';
@@ -32,7 +32,7 @@ test('inputReader', async (t) => {
     t.is(await inputReader.peek(0), undefined);
 });
 test('inputReader.peek concurrent', async (t) => {
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })());
     const peeks = await Promise.all([
@@ -51,7 +51,7 @@ test('inputReader.peek concurrent', async (t) => {
     t.deepEqual(peeks, ['a', 'a', 'a', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
 });
 test('inputReader skip while peeking', async (t) => {
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })());
     const peekPromise = inputReader.peek(0);
@@ -61,7 +61,7 @@ test('inputReader skip while peeking', async (t) => {
 });
 test('inputReader.lookahead', async (t) => {
     let read = 0;
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         for (const character of 'abcdefgh') {
             read++;
             yield character;
@@ -129,7 +129,7 @@ test('inputReader.lookahead', async (t) => {
 });
 test('inputReader.lookahead concurrent', async (t) => {
     let read = 0;
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         for (const character of 'abcdefgh') {
             read++;
             yield character;
@@ -154,7 +154,7 @@ test('inputReader.lookahead concurrent', async (t) => {
 });
 test('inputReader.lookahead skip position', async (t) => {
     let read = 0;
-    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         for (const character of 'abcdefgh') {
             read++;
             yield character;

package/build/javaKeyStore.d.ts

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

package/build/javaKeyStore.js

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

package/build/javaKeyStoreParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const javaKeyStoreParser: Parser<unknown, Uint8Array>;

package/build/javaKeyStoreParser.js

@@ -0,0 +1,67 @@
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { setParserName } from './parser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createQuantifierParser } from './quantifierParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createUnionParser } from './unionParser.js';
+// https://github.com/openjdk/jdk/blob/c517ffba7d9388e75b5d7bba77e565e71c0a7d76/src/java.base/share/classes/com/sun/crypto/provider/JceKeyStore.java#L512-L553
+const uint64BEParser = promiseCompose(createFixedLengthSequenceParser(8), array => Buffer.from(array).readBigUInt64BE());
+setParserName(uint64BEParser, 'uint64BEParser');
+const uint32BEParser = promiseCompose(createFixedLengthSequenceParser(4), array => Buffer.from(array).readUInt32BE());
+setParserName(uint32BEParser, 'uint32BEParser');
+const uint16BEParser = promiseCompose(createFixedLengthSequenceParser(2), array => Buffer.from(array).readUInt16BE());
+setParserName(uint16BEParser, 'uint16BEParser');
+const createUint32BECountPrefixedParser = (elementParser) => parserCreatorCompose(() => uint32BEParser, count => createQuantifierParser(elementParser, count))();
+const javaModifiedUTF8StringParser = promiseCompose(parserCreatorCompose(() => uint16BEParser, length => createFixedLengthSequenceParser(length))(), uint8Array => Buffer.from(uint8Array).toString('utf8'));
+const uint32LengthPrefixedUint8ArrayParser = parserCreatorCompose(() => uint32BEParser, length => createFixedLengthSequenceParser(length))();
+const javaKeyStoreImplementationParser = promiseCompose(createUnionParser([
+    createExactSequenceParser(Buffer.from('feedfeed', 'hex')),
+    createExactSequenceParser(Buffer.from('cececece', 'hex')),
+]), uint8Array => uint8Array[0] === 0xFE ? 'JKS' : 'JCEKS');
+const javaKeyStorePrivateKeyEntryPrivateKeyParser = uint32LengthPrefixedUint8ArrayParser;
+const javaKeyStorePrivateKeyEntryCertificateParser = promiseCompose(createTupleParser([
+    javaModifiedUTF8StringParser,
+    uint32LengthPrefixedUint8ArrayParser,
+]), ([type, certificate]) => ({ type, certificate }));
+const javaKeyStorePrivateKeyEntryCertificateChainParser = createUint32BECountPrefixedParser(javaKeyStorePrivateKeyEntryCertificateParser);
+const javaKeyStorePrivateKeyEntryParser = promiseCompose(createTupleParser([
+    createExactSequenceParser(Buffer.from('00000001', 'hex')),
+    javaModifiedUTF8StringParser,
+    uint64BEParser,
+    javaKeyStorePrivateKeyEntryPrivateKeyParser,
+    javaKeyStorePrivateKeyEntryCertificateChainParser,
+]), ([_tag, alias, creationDate, privateKey, certificateChain,]) => ({
+    type: 'privateKey',
+    alias,
+    creationDate: new Date(Number(creationDate)),
+    privateKey,
+    certificateChain,
+}));
+const javaKeyStoreTrustedCertEntryParser = createTupleParser([
+    createExactSequenceParser(Buffer.from('00000002', 'hex')),
+    async (parserContext) => parserContext.invariant(false, 'Not implemented'),
+]);
+const javaKeyStoreSecretKeyEntryParser = createTupleParser([
+    createExactSequenceParser(Buffer.from('00000003', 'hex')),
+    async (parserContext) => parserContext.invariant(false, 'Not implemented'),
+]);
+const javaKeyStoreEntryParser = createUnionParser([
+    javaKeyStorePrivateKeyEntryParser,
+    javaKeyStoreTrustedCertEntryParser,
+    javaKeyStoreSecretKeyEntryParser,
+]);
+const javaKeyStoreEntriesParser = createUint32BECountPrefixedParser(javaKeyStoreEntryParser);
+const javaKeyStoreParser_ = createTupleParser([
+    javaKeyStoreImplementationParser,
+    uint32BEParser,
+    javaKeyStoreEntriesParser,
+    createFixedLengthSequenceParser(20),
+]);
+export const javaKeyStoreParser = promiseCompose(javaKeyStoreParser_, ([implementation, version, entries, hash,]) => ({
+    implementation,
+    version,
+    entries,
+    hash,
+}));

package/build/javaKeyStoreParser.test.d.ts

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

package/build/javaKeyStoreParser.test.js

@@ -0,0 +1,16 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { javaKeyStoreParser } from './javaKeyStoreParser.js';
+for (const javaKeyStoreCid of [
+    'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4',
+]) {
+    test('javaKeyStore ' + javaKeyStoreCid, async (t) => {
+        const javaKeyStoreResponse = await fetch('https://ipfs.io/ipfs/' + javaKeyStoreCid);
+        const javaKeyStoreStream = javaKeyStoreResponse.body;
+        const actual = await runParser(javaKeyStoreParser, javaKeyStoreStream, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        t.snapshot(actual);
+    });
+}

package/build/javaKeystoreParser.d.ts

@@ -0,0 +1,2 @@
+import { Parser } from "./parser.js";
+export declare const javaKeyStoreParser: Parser<unknown, Uint8Array>;

package/build/javaKeystoreParser.js

@@ -0,0 +1,7 @@
+import { createArrayParser } from "./arrayParser.js";
+import { createElementParser } from "./elementParser.js";
+import { createTupleParser } from "./tupleParser.js";
+export const javaKeyStoreParser = createTupleParser([
+    createArrayParser(createElementParser()),
+    createArrayParser(createElementParser()),
+]);

package/build/jsonParser.js

@@ -51,7 +51,7 @@ const jsonStringParser = promiseCompose(createTupleParser([
     createExactSequenceParser('"'),
     promiseCompose(createTerminatedArrayParser(jsonStringCharacterParser, createExactSequenceParser('"')), ([characters]) => characters.join('')),
 ]), ([, string]) => string);
-const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, (character) => async (parserContext) => {
+const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, character => async (parserContext) => {
     parserContext.invariant((character === '-'
         || (character >= '0' && character <= '9')
         || character === '.'
@@ -59,7 +59,7 @@ const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCrea
         || character === 'E'
         || character === '+'), 'Expected "-", "0" to "9", ".", "e", "E", "+", got "%s"', character);
     return character;
-})()), (characters) => async (parserContext) => {
+})()), characters => async (parserContext) => {
     parserContext.invariant(characters.length > 0, 'Expected at least one character');
     return Number(characters.join(''));
 })();
@@ -67,6 +67,7 @@ const jsonTrueParser = promiseCompose(createExactSequenceParser('true'), () => t
 setParserName(jsonTrueParser, 'jsonTrueParser');
 const jsonFalseParser = promiseCompose(createExactSequenceParser('false'), () => false);
 setParserName(jsonFalseParser, 'jsonFalseParser');
+// eslint-disable-next-line @typescript-eslint/ban-types
 const jsonNullParser = promiseCompose(createExactSequenceParser('null'), () => null);
 setParserName(jsonNullParser, 'jsonNullParser');
 const jsonPrimitiveParser = createUnionParser([

package/build/jsonParser.test.js

@@ -2,12 +2,12 @@ import { testProp, fc } from '@fast-check/ava';
 import { jsonValueParser } from './jsonParser.js';
 import { runParser } from './parser.js';
 import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 testProp('json', [
     arbitrarilySlicedAsyncIterator(fc.tuple(fc.json(), fc.nat())
         .map(([jsonString, indent]) => JSON.stringify(JSON.parse(jsonString), null, indent))),
 ], async (t, [jsonString, jsonStringChunkIterator]) => {
-    const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringInputCompanion, {
+    const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringParserInputCompanion, {
         errorJoinMode: 'none',
     });
     const expected = JSON.parse(jsonString);

package/build/listParser.d.ts

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

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/negativeLookahead.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/negativeLookahead.js

@@ -1,20 +1,18 @@
-import { getParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
-export const createNegativeLookaheadParser = (childParser) => {
-    return async (parserContext) => {
-        const childParserContext = parserContext.lookahead();
-        try {
-            await childParser(childParserContext);
-            parserContext.invariant(false, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
+import { getParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+export const createNegativeLookaheadParser = (childParser) => async (parserContext) => {
+    const childParserContext = parserContext.lookahead();
+    try {
+        await childParser(childParserContext);
+        parserContext.invariant(false, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
+    }
+    catch (error) {
+        if (error instanceof ParserParsingFailedError) {
+            return;
         }
-        catch (error) {
-            if (error instanceof ParserParsingFailedError) {
-                return;
-            }
-            throw error;
-        }
-        finally {
-            childParserContext.dispose();
-        }
-    };
+        throw error;
+    }
+    finally {
+        childParserContext.dispose();
+    }
 };

package/build/negativeLookaheadParser.d.ts

@@ -0,0 +1,2 @@
+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,18 @@
+import { getParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+export const createNegativeLookaheadParser = (childParser) => async (parserContext) => {
+    const childParserContext = parserContext.lookahead();
+    try {
+        await childParser(childParserContext);
+        parserContext.invariant(false, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
+    }
+    catch (error) {
+        if (error instanceof ParserParsingFailedError) {
+            return;
+        }
+        throw error;
+    }
+    finally {
+        childParserContext.dispose();
+    }
+};

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,10 @@
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type ParserContext } from './parserContext.js';
-import { DeriveSequenceElement } from './sequence.js';
+import { type DeriveSequenceElement } from './sequence.js';
 export type Parser<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = (parserContext: ParserContext<Sequence, Element>) => 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 type RunParserOptions<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = {
     errorJoinMode?: 'none' | 'deepest' | 'furthest' | 'all';
 };
-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 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

@@ -42,10 +42,10 @@ function toAsyncIterator(value) {
     }
     invariant(false, 'Value must be an async iterator, async iterable, iterable or iterator got %s.', value);
 }
-export async function runParser(parser, input, inputCompanion, options = {}) {
+export async function runParser(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 = new ParserContextImplementation(parserInputCompanion, inputReader, undefined, {
         ...options,
         debugName: 'root',
     });

package/build/parser.test.js

@@ -1,12 +1,12 @@
 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 { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError, } 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 { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
@@ -44,23 +44,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 +79,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 +101,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 +114,13 @@ 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/,
     });
 });

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/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,17 @@
+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];
+};

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;
@@ -23,14 +23,14 @@ 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;
     length(sequence: Sequence): number;