@futpib/parser 1.0.0 → 1.0.2

package/build/parserContext.js

@@ -1,17 +1,18 @@
-import invariant from 'invariant';
-import { ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError } from './parserError.js';
-import { parserInvariant } from './parserInvariant.js';
+/* eslint-disable prefer-arrow-callback */
+import { ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError, } from './parserError.js';
+import { customInvariant } from './customInvariant.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 let parserContextId = 0;
 export class ParserContextImplementation {
-    _inputCompanion;
+    _parserInputCompanion;
     _inputReader;
     _parentParserContext;
     _options;
     _id = parserContextId++;
     _depth;
     _exclusiveChildParserContext = undefined;
-    constructor(_inputCompanion, _inputReader, _parentParserContext = undefined, _options) {
-        this._inputCompanion = _inputCompanion;
+    constructor(_parserInputCompanion, _inputReader, _parentParserContext = undefined, _options) {
+        this._parserInputCompanion = _parserInputCompanion;
         this._inputReader = _inputReader;
         this._parentParserContext = _parentParserContext;
         this._options = _options;
@@ -30,13 +31,28 @@ export class ParserContextImplementation {
         ].join(' ');
     }
     from(elements) {
-        return this._inputCompanion.from(elements);
+        return this._parserInputCompanion.from(elements);
+    }
+    concat(sequences) {
+        return this._parserInputCompanion.concat(sequences);
     }
     length(sequence) {
-        return this._inputCompanion.length(sequence);
+        return this._parserInputCompanion.length(sequence);
     }
     at(sequence, index) {
-        return this._inputCompanion.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;
@@ -48,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);
     }
@@ -59,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._inputCompanion, 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: [
@@ -77,60 +110,57 @@ 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) {
         const parserContext = this;
-        return parserInvariant(function (message) {
+        return customInvariant(function (message) {
             return new ParserParsingInvariantError(message, parserContext._depth, parserContext.position);
         }, 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') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 return new ParserParsingJoinNoneError(message, parserContext._depth, parserContext.position);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'furthest') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 let furthestPosition = 0;
                 let furthestChildErrors = [];
                 for (const childError of childErrors) {
@@ -154,7 +184,7 @@ export class ParserContextImplementation {
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'deepest') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 let deepestDepth = 0;
                 let deepestChildErrors = [];
                 for (const childError of childErrors) {
@@ -178,7 +208,7 @@ export class ParserContextImplementation {
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'all') {
-            return parserInvariant(function (message) {
+            return customInvariant(function (message) {
                 message += [
                     '',
                     'Child error stacks, indented:',
@@ -188,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

@@ -1,6 +1,6 @@
 import test from 'ava';
 import { ParserContextImplementation } from './parserContext.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
 import { ParserUnexpectedEndOfInputError } from './parserError.js';
 const commonParserContextArguments = [
@@ -11,7 +11,7 @@ const commonParserContextArguments = [
     },
 ];
 test('parserContext.read', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield '';
         yield 'abc';
         yield 'def';
@@ -25,8 +25,28 @@ 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(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const lookaheadContext1 = parserContext.lookahead();
@@ -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,9 +76,12 @@ 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(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const lookaheadContext = parserContext.lookahead();
@@ -68,7 +95,7 @@ test('parserContext.unlookahead', async (t) => {
     t.is(await lookaheadContext.read(0), 'c');
 });
 test('parserContext.unlookahead while peeking', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const lookaheadContext = parserContext.lookahead();
@@ -79,7 +106,7 @@ test('parserContext.unlookahead while peeking', async (t) => {
     t.is(await peekPromise, 'c');
 });
 test('parserContext deep unlookahead normal order', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const child = parserContext.lookahead();
@@ -92,7 +119,7 @@ test('parserContext deep unlookahead normal order', async (t) => {
     t.is(await parserContext.read(0), 'd');
 });
 test('parserContext deep unlookahead weird order', async (t) => {
-    const parserContext = new ParserContextImplementation(stringInputCompanion, new InputReaderImplementation(stringInputCompanion, (async function* () {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
         yield* 'abcdefgh';
     })()), ...commonParserContextArguments);
     const child = parserContext.lookahead({

package/build/parserCreatorCompose.d.ts

@@ -1,3 +1,4 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
-export declare function parserCreatorCompose<Arguments extends unknown[], OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: (...args: Arguments) => Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): (...args: Arguments) => Parser<OutputB, Sequence, Element>;
+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 (...args) => {
-        const parserA = f1(...args);
-        return async (parserContext) => {
+    const parserCreatorComposedOuter = (...arguments_) => {
+        const parserA = f1(...arguments_);
+        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/parserImplementationInvariant.d.ts

@@ -1,2 +1,2 @@
-import { type Falsy, type ValueOrAccessor } from './parserInvariant.js';
+import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
 export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;

package/build/parserImplementationInvariant.js

@@ -1,5 +1,5 @@
 import { ParserImplementationInvariantError } from './parserError.js';
-import { parserInvariant } from './parserInvariant.js';
+import { customInvariant } from './customInvariant.js';
 export function parserImplementationInvariant(value, format, ...formatArguments) {
-    return parserInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+    return customInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
 }

package/build/parserInputCompanion.d.ts

@@ -0,0 +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

@@ -0,0 +1,68 @@
+export class StringParserInputCompanion {
+    is(value) {
+        return typeof value === 'string';
+    }
+    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 {
+    is(value) {
+        return value instanceof Uint8Array;
+    }
+    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/quantifierParser.d.ts

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

package/build/quantifierParser.js

@@ -0,0 +1,17 @@
+import { getParserName, setParserName } from './parser.js';
+export const createQuantifierParser = (childParser, count) => {
+    const quantifierParser = async (parserContext) => {
+        const elements = [];
+        for (let index = 0; index < count; index++) {
+            elements.push(await childParser(parserContext));
+        }
+        return elements;
+    };
+    setParserName(quantifierParser, [
+        getParserName(childParser, 'anonymousQuantifierChild'),
+        '{',
+        count,
+        '}',
+    ].join(''));
+    return quantifierParser;
+};

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>;

package/build/separatedArrayParser.js

@@ -0,0 +1,39 @@
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+export const createSeparatedArrayParser = (elementParser, separatorParser) => {
+    const separatorThenElementParser = promiseCompose(createTupleParser([
+        separatorParser,
+        elementParser,
+    ]), ([, element]) => element);
+    const separatedArrayParser = async (parserContext) => {
+        let parser = elementParser;
+        const elements = [];
+        while (true) {
+            const elementParserContext = parserContext.lookahead();
+            const initialPosition = elementParserContext.position;
+            try {
+                const element = await parser(elementParserContext);
+                if (elementParserContext.position === initialPosition) {
+                    break;
+                }
+                elements.push(element);
+                elementParserContext.unlookahead();
+            }
+            catch (error) {
+                if (error instanceof ParserParsingFailedError) {
+                    break;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+            parser = separatorThenElementParser;
+        }
+        return elements;
+    };
+    setParserName(separatedArrayParser, getParserName(elementParser, 'anonymousSeparatedArrayChild') + '*');
+    return separatedArrayParser;
+};

package/build/separatedArrayParser.test.d.ts

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

package/build/separatedArrayParser.test.js

@@ -0,0 +1,21 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+test('does not loop forever with a child parser that does not consume anything', async (t) => {
+    const parser = createSeparatedArrayParser(async () => undefined, () => undefined);
+    const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+    t.deepEqual(output, []);
+});
+testProp('separatedArray', [
+    fc.array(fc.constant('element')),
+], async (t, elements) => {
+    const separatedArrayParser = createSeparatedArrayParser(createExactSequenceParser('element'), createExactSequenceParser('separator'));
+    const actual = await runParser(separatedArrayParser, elements.join('separator'), stringParserInputCompanion);
+    const expected = elements;
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+});