@futpib/parser 1.0.0

package/src/jsonParser.ts

@@ -0,0 +1,225 @@
+import {
+	type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, type Writable,
+} from 'type-fest';
+import { setParserName, type Parser } from './parser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { createUnionParser } from './unionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createTerminatedArrayParser } from './terminatedArrayParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createElementParser } from './elementParser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+
+const whitespaceParser: Parser<unknown, string> = createArrayParser(
+	createUnionParser([
+		createExactSequenceParser(' '),
+		createExactSequenceParser('\t'),
+		createExactSequenceParser('\r'),
+		createExactSequenceParser('\n'),
+	]),
+);
+
+const jsonQuoteEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\"'), () => '"');
+const jsonBackslashEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\\\'), () => '\\');
+const jsonSlashEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\/'), () => '/');
+const jsonBackspaceEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\b'), () => '\b');
+const jsonFormFeedEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\f'), () => '\f');
+const jsonNewLineEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\n'), () => '\n');
+const jsonCarriageReturnEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\r'), () => '\r');
+const jsonTabEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\t'), () => '\t');
+
+const jsonUnicodeEscapeSequenceParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser('\\u'),
+		createFixedLengthSequenceParser<string>(4),
+	]),
+	([ , hexCode ]) => String.fromCharCode(Number.parseInt(hexCode, 16)),
+);
+
+const jsonStringEscapeSequenceParser: Parser<string, string> = createUnionParser([
+	jsonQuoteEscapeSequenceParser,
+	jsonBackslashEscapeSequenceParser,
+	jsonSlashEscapeSequenceParser,
+	jsonBackspaceEscapeSequenceParser,
+	jsonFormFeedEscapeSequenceParser,
+	jsonNewLineEscapeSequenceParser,
+	jsonCarriageReturnEscapeSequenceParser,
+	jsonTabEscapeSequenceParser,
+	jsonUnicodeEscapeSequenceParser,
+]);
+
+const elementParser: Parser<string, string> = createElementParser();
+
+const jsonStringCharacterParser: Parser<string, string> = createDisjunctionParser([
+	jsonStringEscapeSequenceParser,
+	parserCreatorCompose(
+		() => elementParser,
+		character => async parserContext => {
+			parserContext.invariant(character !== '"', 'Unexpected """');
+			return character;
+		},
+	)(),
+]);
+
+const jsonStringParser: Parser<string, string> = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser('"'),
+		promiseCompose(
+			createTerminatedArrayParser(
+				jsonStringCharacterParser,
+				createExactSequenceParser('"'),
+			),
+			([ characters ]) => characters.join(''),
+		),
+	]),
+	([ , string ]) => string,
+);
+
+const jsonNumberParser: Parser<number, string> = parserCreatorCompose(
+	() => createArrayParser(
+		parserCreatorCompose(
+			() => elementParser,
+			(character) => async parserContext => {
+				parserContext.invariant(
+					(
+						character === '-'
+							|| (character >= '0' && character <= '9')
+							|| character === '.'
+							|| character === 'e'
+							|| character === 'E'
+							|| character === '+'
+					),
+					'Expected "-", "0" to "9", ".", "e", "E", "+", got "%s"',
+					character,
+				);
+
+				return character;
+			},
+		)(),
+	),
+	(characters) => async parserContext => {
+		parserContext.invariant(characters.length > 0, 'Expected at least one character');
+
+		return Number(characters.join(''));
+	},
+)();
+
+const jsonTrueParser: Parser<true, string> = promiseCompose(createExactSequenceParser('true'), () => true);
+
+setParserName(jsonTrueParser, 'jsonTrueParser');
+
+const jsonFalseParser: Parser<false, string> = promiseCompose(createExactSequenceParser('false'), () => false);
+
+setParserName(jsonFalseParser, 'jsonFalseParser');
+
+const jsonNullParser: Parser<null, string> = promiseCompose(createExactSequenceParser('null'), () => null);
+
+setParserName(jsonNullParser, 'jsonNullParser');
+
+const jsonPrimitiveParser: Parser<JsonPrimitive, string> = createUnionParser([
+	jsonStringParser,
+	jsonNumberParser,
+	jsonTrueParser,
+	jsonFalseParser,
+	jsonNullParser,
+]);
+
+setParserName(jsonPrimitiveParser, 'jsonPrimitiveParser');
+
+const jsonObjectEntryParser: Parser<[string, JsonValue], string> = promiseCompose(
+	createTupleParser([
+		jsonStringParser,
+		whitespaceParser,
+		createExactSequenceParser(':'),
+		whitespaceParser,
+		createParserAccessorParser(() => jsonValueParser),
+	]),
+	([key, _whitespace1, _colon, _whitespace2, value]) => [key, value],
+);
+
+const jsonObjectParser: Parser<JsonObject, string> = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser('{'),
+		whitespaceParser,
+		promiseCompose(
+			createTerminatedArrayParser(
+				createDisjunctionParser<[string, JsonValue], string>([
+					promiseCompose(
+						createTupleParser([
+							createParserAccessorParser(() => jsonObjectEntryParser),
+							whitespaceParser,
+							createExactSequenceParser(','),
+							whitespaceParser,
+						]),
+						([entry]) => entry,
+					),
+					promiseCompose(
+						createTupleParser([
+							createParserAccessorParser(() => jsonObjectEntryParser),
+							whitespaceParser,
+						]),
+						([value]) => value,
+					),
+				]),
+				createExactSequenceParser('}'),
+			),
+			([entries]) => entries,
+		),
+	]),
+	([ _brace, _whitespace, entries]) => {
+		const object: Writable<JsonObject> = {};
+
+		for (const [key, value] of entries) {
+			Object.defineProperty(object, key, {
+				value,
+				enumerable: true,
+			});
+		}
+
+		return object;
+	},
+);
+
+const jsonArrayParser: Parser<JsonArray, string> = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser('['),
+		whitespaceParser,
+		promiseCompose(
+			createTerminatedArrayParser(
+				createDisjunctionParser<JsonValue, string>([
+					promiseCompose(
+						createTupleParser([
+							createParserAccessorParser(() => jsonValueParser),
+							whitespaceParser,
+							createExactSequenceParser(','),
+							whitespaceParser,
+						]),
+						([value]) => value,
+					),
+					promiseCompose(
+						createTupleParser([
+							createParserAccessorParser(() => jsonValueParser),
+							whitespaceParser,
+						]),
+						([value]) => value,
+					),
+				]),
+				createExactSequenceParser(']'),
+			),
+			([values]) => values,
+		),
+	]),
+	([_bracket, _whitespace, values]) => values,
+);
+
+export const jsonValueParser: Parser<JsonValue, string> = createUnionParser([
+	jsonObjectParser,
+	jsonArrayParser,
+	jsonPrimitiveParser,
+]);
+
+setParserName(jsonValueParser, 'jsonValueParser');

package/src/listParser.ts

@@ -0,0 +1,52 @@
+import { createNegativeLookaheadParser } from "./negativeLookahead.js";
+import { Parser } from "./parser.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<Head, Tail> {
+	constructor(
+		public readonly head: Head,
+		public readonly tail: Tail,
+	) {}
+}
+
+export const createListParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	type List = Nil | Cons<ElementOutput, List>;
+
+	const consParser = promiseCompose(
+		createTupleParser([
+			elementParser,
+			createParserAccessorParser(() => listParser),
+		]),
+		([ head, tail ]) => new Cons(head, tail),
+	);
+
+	const nilParser = promiseCompose(
+		createNegativeLookaheadParser(elementParser),
+		() => new Nil(),
+	);
+
+	const listParser: Parser<List, Sequence> = createUnionParser([
+		consParser,
+		nilParser,
+	]);
+
+	return promiseCompose(
+		listParser,
+		list => {
+			const array: ElementOutput[] = [];
+
+			while (list instanceof Cons) {
+				array.push(list.head);
+				list = list.tail;
+			}
+
+			return array;
+		},
+	);
+};

package/src/negativeLookahead.ts

@@ -0,0 +1,26 @@
+import { getParserName, Parser } from "./parser.js";
+import { ParserParsingFailedError } from "./parserError.js";
+
+export const createNegativeLookaheadParser = <Sequence>(
+	childParser: Parser<unknown, Sequence>,
+): Parser<void, Sequence> => {
+	return 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/src/optionalParser.ts

@@ -0,0 +1,27 @@
+import { getParserName, Parser, setParserName } from "./parser.js";
+import { ParserParsingFailedError } from "./parserError.js";
+
+export const createOptionalParser = <Output, Sequence>(
+	childParser: Parser<Output, Sequence>,
+): Parser<undefined | Output, Sequence> => {
+	const optionalParser: Parser<undefined | Output, Sequence> = async parserContext => {
+		const childParserContext = parserContext.lookahead();
+		try {
+			const value = await childParser(childParserContext);
+			childParserContext.unlookahead();
+			return value;
+		} catch (error) {
+			if (error instanceof ParserParsingFailedError) {
+				return undefined;
+			}
+
+			throw error;
+		} finally {
+			childParserContext.dispose();
+		}
+	};
+
+	setParserName(optionalParser, getParserName(childParser, 'anonymousOptionalChild') + '?');
+
+	return optionalParser;
+}

package/src/parser.test.ts

@@ -0,0 +1,176 @@
+import test from 'ava';
+import { createUnionParser } from './unionParser.js';
+import { Parser, runParser } from './parser.js';
+import { stringInputCompanion, uint8ArrayInputCompanion } from './inputCompanion.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';
+
+const aUnionParser = createUnionParser<string, string>([
+	createExactSequenceParser('1'),
+	createExactSequenceParser('aa'),
+	createExactSequenceParser('AAA'),
+]);
+
+const abDisjunctionParser = createDisjunctionParser<string, string>([
+	aUnionParser,
+	createExactSequenceParser('2'),
+	createExactSequenceParser('bb'),
+	createExactSequenceParser('BBB'),
+]);
+
+const abcUnionParser = createUnionParser<string, string>([
+	abDisjunctionParser,
+	createExactSequenceParser('final_3'),
+	createExactSequenceParser('final_cc'),
+	createExactSequenceParser('final_CCC'),
+]);
+
+const sampleParser = promiseCompose(
+	createTupleParser<string, string, string, string>([
+		aUnionParser,
+		abDisjunctionParser,
+		abcUnionParser,
+	]),
+	strings => strings.join(''),
+);
+
+async function * asyncIteratorFromString(string: string) {
+	yield string;
+}
+
+function sortChildErrors(error: ParserParsingJoinNoneError) {
+	error.childErrors.sort((a, b) => a.message.localeCompare(b.message));
+
+	for (const childError of error.childErrors) {
+		if (childError instanceof ParserParsingJoinError) {
+			sortChildErrors(childError);
+		}
+	}
+}
+
+function removeStackLocations(errorStack: string) {
+	return errorStack.replace(/((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, {
+		errorJoinMode: 'none',
+	}), {
+		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, {
+		errorJoinMode: 'all',
+	}), {
+		instanceOf: ParserParsingJoinAllError
+	});
+
+	sortChildErrors(error);
+
+	t.snapshot(removeStackLocations(error.stack!));
+
+	t.is(error.position, 12, 'error.position');
+	t.is(error.childErrors.length, 4);
+
+	const error1 = error.childErrors.at(-1)!;
+
+	invariant(error1 instanceof ParserParsingJoinAllError, 'error1 instanceof ParserParsingJoinAllError');
+
+	t.is(error1.position, 3, 'error1.position');
+	t.is(error1.childErrors.length, 4);
+
+	const error2 = error1.childErrors.at(-1)!;
+
+	invariant(error2 instanceof ParserParsingJoinAllError, 'error2 instanceof ParserParsingJoinAllError');
+
+	t.is(error2.position, 4, 'error2.position');
+	t.is(error2.childErrors.length, 3);
+
+	const error3 = error2.childErrors.at(-1)!;
+
+	invariant(error3 instanceof ParserParsingInvariantError, 'error3 instanceof ParserParsingInvariantError');
+
+	t.is(error3.position, 4, 'error3.position');
+});
+
+test('errorJoinMode: deepest', async t => {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+		errorJoinMode: 'deepest',
+	}), {
+		instanceOf: ParserParsingJoinDeepestError,
+	});
+
+	sortChildErrors(error);
+
+	t.snapshot(removeStackLocations(error.stack!));
+
+	t.is(error.position, 12);
+	t.is(error.childErrors.length, 1);
+
+	const error1 = error.childErrors.at(-1)!;
+
+	invariant(error1 instanceof ParserParsingJoinDeepestError, 'error1 instanceof ParserParsingJoinDeepestError');
+
+	t.is(error1.position, 3);
+	t.is(error1.childErrors.length, 1);
+
+	const error2 = error1.childErrors.at(-1)!;
+
+	invariant(error2 instanceof ParserParsingJoinDeepestError, 'error2 instanceof ParserParsingJoinDeepestError');
+
+	t.is(error2.position, 4);
+	t.is(error2.childErrors.length, 3);
+
+	const error3 = error2.childErrors.at(-1)!;
+
+	invariant(error3 instanceof ParserParsingInvariantError, 'error3 instanceof ParserParsingInvariantError');
+
+	t.is(error3.position, 4);
+});
+
+test('errorJoinMode: furthest', async t => {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+		errorJoinMode: 'furthest',
+	}), {
+		instanceOf: ParserParsingJoinFurthestError,
+	});
+
+	sortChildErrors(error);
+
+	t.snapshot(removeStackLocations(error.stack!));
+
+	t.is(error.position, 12);
+	t.is(error.childErrors.length, 1);
+
+	const error1 = error.childErrors.at(-1)!;
+
+	invariant(error1 instanceof ParserParsingInvariantError, 'error1 instanceof ParserParsingInvariantError');
+
+	t.is(error1.position, 12);
+});
+
+test('throws on inputCompanion type mismatch', async t => {
+	const anythingParser: Parser<any, any> = 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), {
+		message: /input companion/,
+	});
+});

package/src/parser.test.ts.md

@@ -0,0 +1,68 @@
+# Snapshot report for `src/parser.test.ts`
+
+The actual snapshot is saved in `parser.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## errorJoinMode: none
+
+> Snapshot 1
+
+    `ParserParsingJoinNoneError: (position: 12) No union child parser succeeded.␊
+        at [LOCATIONS]`
+
+## errorJoinMode: all
+
+> Snapshot 1
+
+    `ParserParsingJoinAllError: (position: 12) No union child parser succeeded.␊
+    Child error stacks, indented:␊
+      ParserParsingInvariantError: (position: 10) Expected "3", got "C", at [LOCATIONS]␊
+      ParserParsingInvariantError: (position: 10) Expected "c", got "C", at [LOCATIONS]␊
+      ParserParsingJoinAllError: (position: 3) No disjunction child parser succeeded.␊
+      Child error stacks, indented:␊
+        ParserParsingJoinAllError: (position: 4) No union child parser succeeded.␊
+        Child error stacks, indented:␊
+          ParserParsingInvariantError: (position: 4) Expected "1", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: (position: 4) Expected "a", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: (position: 4) Expected "A", got "f", at [LOCATIONS]␊
+        End of child error stacks␊
+            at [LOCATIONS]␊
+        ParserParsingInvariantError: (position: 4) Expected "2", got "f", at [LOCATIONS]␊
+        ParserParsingInvariantError: (position: 4) Expected "b", got "f", at [LOCATIONS]␊
+        ParserParsingInvariantError: (position: 4) Expected "B", got "f", at [LOCATIONS]␊
+      End of child error stacks␊
+          at [LOCATIONS]␊
+      ParserParsingInvariantError: (position: 12) Expected "C", got "!", at [LOCATIONS]␊
+    End of child error stacks␊
+        at [LOCATIONS]`
+
+## errorJoinMode: deepest
+
+> Snapshot 1
+
+    `ParserParsingJoinDeepestError: (position: 12) No union child parser succeeded.␊
+    Deepest child error stacks, indented:␊
+      ParserParsingJoinDeepestError: (position: 3) No disjunction child parser succeeded.␊
+      Deepest child error stacks, indented:␊
+        ParserParsingJoinDeepestError: (position: 4) No union child parser succeeded.␊
+        Deepest child error stacks, indented:␊
+          ParserParsingInvariantError: (position: 4) Expected "1", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: (position: 4) Expected "a", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: (position: 4) Expected "A", got "f", at [LOCATIONS]␊
+        End of deepest child error stacks␊
+            at [LOCATIONS]␊
+      End of deepest child error stacks␊
+          at [LOCATIONS]␊
+    End of deepest child error stacks␊
+        at [LOCATIONS]`
+
+## errorJoinMode: furthest
+
+> Snapshot 1
+
+    `ParserParsingJoinFurthestError: (position: 12) No union child parser succeeded.␊
+    Furthest child error stacks, indented:␊
+      ParserParsingInvariantError: (position: 12) Expected "C", got "!", at [LOCATIONS]␊
+    End of furthest child error stacks␊
+        at [LOCATIONS]`

package/src/parser.ts

@@ -0,0 +1,103 @@
+import invariant from 'invariant';
+import { type InputCompanion } from './inputCompanion.js';
+import { InputReaderImplementation } from './inputReader.js';
+import { type ParserContext, ParserContextImplementation } from './parserContext.js';
+import { DeriveSequenceElement } from './sequence.js';
+
+export type Parser<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+> = (parserContext: ParserContext<Sequence, Element>) => Promise<Output>;
+
+export function getParserName(parser: Parser<any, any, any>, default_ = 'anonymous'): string {
+	return parser.name || default_;
+}
+
+export function setParserName<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(parser: Parser<Output, Sequence, Element>, name: string): Parser<Output, Sequence, Element> {
+	Object.defineProperty(parser, 'name', {
+		value: name,
+	});
+
+	return parser;
+}
+
+export type RunParserOptions<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+> = {
+	errorJoinMode?: 'none' | 'deepest' | 'furthest' | 'all';
+}
+
+function isAsyncIterable<T>(value: any): value is AsyncIterable<T> {
+	return value && typeof value[Symbol.asyncIterator] === 'function';
+}
+
+function isIterable<T>(value: any): value is Iterable<T> {
+	return value && typeof value[Symbol.iterator] === 'function';
+}
+
+function isIterator<T>(value: any): value is Iterator<T> {
+	return value && typeof value.next === 'function';
+}
+
+function iteratorToAsyncIterator<T>(iterator: Iterator<T>): AsyncIterator<T> {
+	return {
+		next: async () => iterator.next(),
+	};
+}
+
+function toAsyncIterator<T>(value: AsyncIterator<T> | AsyncIterable<T> | Iterable<T> | T): AsyncIterator<T> {
+	if (
+		typeof value === 'string'
+		|| value instanceof Uint8Array
+	) {
+		return (async function*() {
+			yield value as any;
+		})();
+	}
+
+	if (isAsyncIterable(value)) {
+		return value[Symbol.asyncIterator]();
+	}
+
+	if (isIterable(value)) {
+		return iteratorToAsyncIterator(value[Symbol.iterator]());
+	}
+
+	if (isIterator<T>(value)) {
+		return iteratorToAsyncIterator(value);
+	}
+
+	invariant(
+		false,
+		'Value must be an async iterator, async iterable, iterable or iterator got %s.',
+		value,
+	);
+}
+
+export async 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> {
+	const inputAsyncIterator = toAsyncIterator(input);
+
+	const inputReader = new InputReaderImplementation<Sequence, Element>(inputCompanion, inputAsyncIterator);
+	const parserContext = new ParserContextImplementation<Sequence, Element>(inputCompanion, inputReader, undefined, {
+		...options,
+		debugName: 'root',
+	});
+
+	return parser(parserContext);
+}

package/src/parserAccessorParser.ts

@@ -0,0 +1,3 @@
+import { Parser } from "./parser.js";
+
+export const createParserAccessorParser = <Output, Sequence>(parserAccessor: () => Parser<Output, Sequence>): Parser<Output, Sequence> => async parserContext => parserAccessor()(parserContext);