@futpib/parser 1.0.0 → 1.0.2

package/src/parserContext.ts

@@ -1,9 +1,13 @@
-import invariant from 'invariant';
-import { type InputCompanion } from './inputCompanion.js';
+/* eslint-disable prefer-arrow-callback */
+
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type InputReader } from './inputReader.js';
-import { ParserParsingFailedError, ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError } from './parserError.js';
-import { RunParserOptions } from './parser.js';
-import { Falsy, parserInvariant, ValueOrAccessor } from './parserInvariant.js';
+import {
+	type ParserParsingFailedError, ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError,
+} from './parserError.js';
+import { type RunParserOptions } from './parser.js';
+import { type Falsy, customInvariant, type ValueOrAccessor } from './customInvariant.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
 type LookaheadOptions = {
 	debugName?: string;
@@ -17,14 +21,21 @@ type ParserContextOptions<Sequence, Element> =
 
 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;
@@ -43,7 +54,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	private _exclusiveChildParserContext: ParserContext<Sequence, Element> | undefined = undefined;
 
 	constructor(
-		private readonly _inputCompanion: InputCompanion<Sequence, Element>,
+		private readonly _parserInputCompanion: ParserInputCompanion<Sequence, Element>,
 		private _inputReader: InputReader<Sequence, Element>,
 		private _parentParserContext: ParserContextImplementation<Sequence, Element> | undefined = undefined,
 		private readonly _options: ParserContextOptions<Sequence, Element>,
@@ -65,15 +76,35 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	from(elements: Element[]): Sequence {
-		return this._inputCompanion.from(elements);
+		return this._parserInputCompanion.from(elements);
+	}
+
+	concat(sequences: Sequence[]): Sequence {
+		return this._parserInputCompanion.concat(sequences);
 	}
 
 	length(sequence: Sequence): number {
-		return this._inputCompanion.length(sequence);
+		return this._parserInputCompanion.length(sequence);
 	}
 
 	at(sequence: Sequence, index: number): Element | undefined {
-		return this._inputCompanion.at(sequence, index);
+		return this._parserInputCompanion.at(sequence, index);
+	}
+
+	subsequence(sequence: Sequence, start: number, end: number): Sequence {
+		return this._parserInputCompanion.subsequence(sequence, start, end);
+	}
+
+	indexOf(sequence: Sequence, element: Element, fromIndex?: number): number {
+		return this._parserInputCompanion.indexOf(sequence, element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number {
+		return this._parserInputCompanion.indexOfSubsequence(sequence, subsequence, fromIndex);
+	}
+
+	equals(sequenceA: Sequence, sequenceB: Sequence): boolean {
+		return this._parserInputCompanion.equals(sequenceA, sequenceB);
 	}
 
 	get position() {
@@ -91,6 +122,39 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._inputReader.peek(offset);
 	}
 
+	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
+		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: number) {
 		this._inputReader.skip(offset);
 	}
@@ -107,22 +171,32 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return element;
 	}
 
-	lookahead(options: LookaheadOptions = {}): ParserContext<Sequence, Element> {
-		const lookaheadInputReader = this._inputReader.lookahead();
+	async readSequence(start: number, end: number): Promise<Sequence> {
+		const sequence = await this.peekSequence(start, end);
 
-		if (this.position !== lookaheadInputReader.position) {
-			debugger;
+		if (sequence === undefined) {
+			throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
 		}
 
-		invariant(
+		this.skip(end);
+
+		return sequence;
+	}
+
+	lookahead(options: LookaheadOptions = {}): ParserContext<Sequence, Element> {
+		const lookaheadInputReader = this._inputReader.lookahead();
+
+		parserImplementationInvariant(
 			this.position === lookaheadInputReader.position,
 			'lookahead this.position (%s) === lookaheadInputReader.position (%s)',
 			this.position,
 			lookaheadInputReader.position,
 		);
 
-		const lookaheadParserContext = new ParserContextImplementation(
-			this._inputCompanion,
+		const ParserContext = this._options.parserContextClass ?? ParserContextImplementation;
+
+		const lookaheadParserContext = new ParserContext<Sequence, Element>(
+			this._parserInputCompanion,
 			lookaheadInputReader,
 			this,
 			{
@@ -139,11 +213,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 			},
 		);
 
-		if (this.position !== lookaheadParserContext.position) {
-			debugger;
-		}
-
-		invariant(
+		parserImplementationInvariant(
 			this.position === lookaheadParserContext.position,
 			'lookahead this.position (%s) === lookaheadParserContext.position (%s)',
 			this.position,
@@ -154,11 +224,14 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	unlookahead() {
-		invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-		invariant(
+		const parentParserContext = parserImplementationInvariant(
+			this._parentParserContext,
+			'this._parentParserContext !== undefined',
+		);
+		parserImplementationInvariant(
 			(
-				this._parentParserContext._exclusiveChildParserContext === undefined
-				|| this._parentParserContext._exclusiveChildParserContext === this
+				parentParserContext._exclusiveChildParserContext === undefined
+				|| parentParserContext._exclusiveChildParserContext === this
 			),
 			[
 				'Parent\'s exclusive child must be undefined or this',
@@ -167,29 +240,29 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 				'parent.exclusiveChild: %s',
 			].join('\n'),
 			this.toString(),
-			this._parentParserContext.toString(),
-			this._parentParserContext._exclusiveChildParserContext?.toString(),
+			parentParserContext.toString(),
+			parentParserContext._exclusiveChildParserContext?.toString(),
 		);
-		invariant(
-			this._parentParserContext.position <= this.position,
+		parserImplementationInvariant(
+			parentParserContext.position <= this.position,
 			'unlookahead this._parentParserContext.position (%s) <= this.position (%s)',
-			this._parentParserContext.position,
+			parentParserContext.position,
 			this.position,
 		);
 
-		const offset = this._inputReader.position - this._parentParserContext._inputReader.position;
+		const offset = this._inputReader.position - parentParserContext._inputReader.position;
 
-		this._parentParserContext.skip(offset);
+		parentParserContext.skip(offset);
 
-		invariant(
-			this._parentParserContext.position === this.position,
+		parserImplementationInvariant(
+			parentParserContext.position === this.position,
 			'unlookahead this._parentParserContext.position (%s) === this.position (%s)',
-			this._parentParserContext.position,
+			parentParserContext.position,
 			this.position,
 		);
 
-		this._inputReader = this._parentParserContext._inputReader;
-		this._parentParserContext._exclusiveChildParserContext = this;
+		this._inputReader = parentParserContext._inputReader;
+		parentParserContext._exclusiveChildParserContext = this;
 
 		if (this._exclusiveChildParserContext) {
 			this._exclusiveChildParserContext.unlookahead();
@@ -197,11 +270,14 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	dispose() {
-		invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-		invariant(
+		const parentParserContext = parserImplementationInvariant(
+			this._parentParserContext,
+			'this._parentParserContext !== undefined',
+		);
+		parserImplementationInvariant(
 			(
-				this._parentParserContext._exclusiveChildParserContext === undefined
-				|| this._parentParserContext._exclusiveChildParserContext === this
+				parentParserContext._exclusiveChildParserContext === undefined
+				|| parentParserContext._exclusiveChildParserContext === this
 			),
 			[
 				'Parent\'s exclusive child must be undefined or this',
@@ -210,36 +286,36 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 				'parent.exclusiveChild: %s',
 			].join('\n'),
 			this.toString(),
-			this._parentParserContext.toString(),
-			this._parentParserContext._exclusiveChildParserContext?.toString(),
+			parentParserContext.toString(),
+			parentParserContext._exclusiveChildParserContext?.toString(),
 		);
 
-		this._parentParserContext._exclusiveChildParserContext = undefined;
+		parentParserContext._exclusiveChildParserContext = undefined;
 		this._parentParserContext = undefined;
 	}
 
 	invariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
 		const parserContext = this;
 
-		return parserInvariant(function (message: string) {
+		return customInvariant(function (message: string) {
 			return new ParserParsingInvariantError(message, parserContext._depth, parserContext.position);
 		}, value, format, ...formatArguments);
 	}
 
 	invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
-		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: string) {
+			return customInvariant(function (message: string) {
 				return new ParserParsingJoinNoneError(message, parserContext._depth, parserContext.position);
 			}, value, format, ...formatArguments);
 		}
 
 		if (errorJoinMode === 'furthest') {
-			return parserInvariant(function (message: string) {
+			return customInvariant(function (message: string) {
 				let furthestPosition = 0;
 				let furthestChildErrors: ParserParsingFailedError[] = [];
 
@@ -269,7 +345,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		}
 
 		if (errorJoinMode === 'deepest') {
-			return parserInvariant(function (message: string) {
+			return customInvariant(function (message: string) {
 				let deepestDepth = 0;
 				let deepestChildErrors: ParserParsingFailedError[] = [];
 
@@ -299,7 +375,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		}
 
 		if (errorJoinMode === 'all') {
-			return parserInvariant(function (message: string) {
+			return customInvariant(function (message: string) {
 				message += [
 					'',
 					'Child error stacks, indented:',
@@ -311,6 +387,6 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 			}, value, format, ...formatArguments);
 		}
 
-		invariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
+		return parserImplementationInvariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
 	}
 }

package/src/parserCreatorCompose.ts

@@ -1,5 +1,6 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import mem from 'mem';
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export function parserCreatorCompose<
 	Arguments extends unknown[],
@@ -8,16 +9,33 @@ export function parserCreatorCompose<
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
 >(
-	f1: (...args: Arguments) => Parser<OutputA, Sequence, Element>,
+	f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>,
 	f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>,
-): (...args: Arguments) => Parser<OutputB, Sequence, Element> {
-	return (...args) => {
-		const parserA = f1(...args);
+): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> {
+	const parserCreatorComposedOuter: (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> = (...arguments_) => {
+		const parserA = f1(...arguments_);
 
-		return async parserContext => {
+		const parserCreatorComposedInner: Parser<OutputB, Sequence, Element> = async parserContext => {
 			const outputA = await parserA(parserContext);
 			const parserB = f2(outputA);
 			return parserB(parserContext);
 		};
+
+		return parserCreatorComposedInner;
 	};
+
+	return parserCreatorComposedOuter;
+}
+
+export 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> {
+	return parserCreatorCompose(mem(f1), mem(f2));
 }

package/src/parserError.ts

@@ -1,6 +1,10 @@
+import { InputReaderState } from "./inputReaderState.js";
 
 export class ParserError extends Error {
 	name = 'ParserError';
+
+	public position: undefined | number = undefined;
+	public inputReaderSate: undefined | InputReaderState<unknown> = undefined;
 }
 
 export class ParserImplementationError extends ParserError {
@@ -18,12 +22,7 @@ export class ParserParsingFailedError extends ParserError {
 		public readonly depth: number,
 		public readonly position: number,
 	) {
-		super([
-			'(position: ',
-			position,
-			') ',
-			message,
-		].join(''));
+		super(message);
 	}
 }
 
@@ -83,3 +82,7 @@ export class ParserParsingInvariantError extends ParserParsingFailedError {
 export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
 	name = 'ParserUnexpectedEndOfInputError';
 }
+
+export class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+	name = 'ParserUnexpectedRemainingInputError';
+}

package/src/parserImplementationInvariant.ts

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

package/src/parserInputCompanion.ts

@@ -0,0 +1,102 @@
+
+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 class StringParserInputCompanion implements ParserInputCompanion<string, string> {
+	is(value: unknown): value is string {
+		return typeof value === 'string';
+	}
+
+	from(elements: string[]): string {
+		return elements.join('');
+	}
+
+	concat(sequences: string[]): string {
+		return sequences.join('');
+	}
+
+	length(sequence: string): number {
+		return sequence.length;
+	}
+
+	at(sequence: string, index: number): string | undefined {
+		return sequence.at(index);
+	}
+
+	subsequence(sequence: string, start: number, end: number): string {
+		return sequence.slice(start, end);
+	}
+
+	indexOf(sequence: string, element: string, fromIndex?: number): number {
+		return sequence.indexOf(element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: string, subsequence: string, fromIndex?: number): number {
+		return sequence.indexOf(subsequence, fromIndex);
+	}
+
+	equals(sequenceA: string, sequenceB: string): boolean {
+		return sequenceA === sequenceB;
+	}
+}
+
+export const stringParserInputCompanion = new StringParserInputCompanion();
+
+export class Uint8ArrayParserInputCompanion implements ParserInputCompanion<Uint8Array, number> {
+	is(value: unknown): value is Uint8Array {
+		return value instanceof Uint8Array;
+	}
+
+	from(elements: number[]): Uint8Array {
+		return new Uint8Array(elements);
+	}
+
+	concat(sequences: Uint8Array[]): Uint8Array {
+		return new Uint8Array(Buffer.concat(sequences));
+	}
+
+	length(sequence: Uint8Array): number {
+		return sequence.length;
+	}
+
+	at(sequence: Uint8Array, index: number): number | undefined {
+		return sequence.at(index);
+	}
+
+	subsequence(sequence: Uint8Array, start: number, end: number): Uint8Array {
+		return sequence.subarray(start, end);
+	}
+
+	indexOf(sequence: Uint8Array, element: number, fromIndex?: number): number {
+		return sequence.indexOf(element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: Uint8Array, subsequence: Uint8Array, fromIndex?: number): number {
+		return Buffer.from(sequence).indexOf(Buffer.from(subsequence), fromIndex);
+	}
+
+	equals(sequenceA: Uint8Array, sequenceB: Uint8Array): boolean {
+		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/src/promiseCompose.ts

@@ -1,7 +1,21 @@
 
 export function promiseCompose<A, B, C>(
-	f1: (a: A) => Promise<B>,
+	f1: (a: A) => B | Promise<B>,
 	f2: (b: B) => C | Promise<C>,
-): (a: A) => Promise<C> {
-	return async a => f1(a).then(f2);
+): (a: A) => C | Promise<C> {
+	function promiseComposed(a: 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/src/promiseSettled.ts

@@ -0,0 +1,6 @@
+
+export async function promiseSettled<T>(promise: Promise<T>): Promise<PromiseSettledResult<T>> {
+	const [ promiseSettledResult ] = await Promise.allSettled([ promise ]);
+
+	return promiseSettledResult;
+}

package/src/quantifierParser.ts

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

package/src/separatedArrayParser.test.ts

@@ -0,0 +1,34 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { type Parser, 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: Parser<undefined[], string> = 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,
+	},
+);

package/src/separatedArrayParser.ts

@@ -0,0 +1,55 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+
+export const createSeparatedArrayParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	separatorParser: Parser<unknown, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	const separatorThenElementParser: Parser<ElementOutput, Sequence> = promiseCompose(
+		createTupleParser([
+			separatorParser,
+			elementParser,
+		]),
+		([ , element ]) => element,
+	);
+
+	const separatedArrayParser: Parser<ElementOutput[], Sequence> = async parserContext => {
+		let parser = elementParser;
+
+		const elements: ElementOutput[] = [];
+
+		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;
+};