@futpib/parser 1.0.0 → 1.0.2

package/src/parser.ts

@@ -1,14 +1,17 @@
-import invariant from 'invariant';
-import { type InputCompanion } from './inputCompanion.js';
+import { Class } from 'type-fest';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
 import { type ParserContext, ParserContextImplementation } from './parserContext.js';
-import { DeriveSequenceElement } from './sequence.js';
+import { type DeriveSequenceElement } from './sequence.js';
+import { ParserError, ParserUnexpectedRemainingInputError } from './parserError.js';
+import { toAsyncIterator } from './toAsyncIterator.js';
+import { inputReaderStateCompanion } from './inputReaderState.js';
 
 export type Parser<
 	Output,
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
-> = (parserContext: ParserContext<Sequence, Element>) => Promise<Output>;
+> = (parserContext: ParserContext<Sequence, Element>) => Output | Promise<Output>;
 
 export function getParserName(parser: Parser<any, any, any>, default_ = 'anonymous'): string {
 	return parser.name || default_;
@@ -26,59 +29,152 @@ export function setParserName<
 	return parser;
 }
 
+const originalParserByClone = new WeakMap<Parser<any, any, any>, Parser<any, any, any>>();
+
+export function cloneParser<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	parser: Parser<Output, Sequence, Element>,
+): Parser<Output, Sequence, Element> {
+	const originalParser = originalParserByClone.get(parser) ?? parser;
+
+	const clone: Parser<Output, Sequence, Element> = (parserContext) => {
+		return originalParser(parserContext);
+	};
+
+	setParserName(clone, getParserName(parser));
+
+	originalParserByClone.set(clone, originalParser);
+
+	return clone;
+}
+
 export type RunParserOptions<
 	Output,
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
 > = {
 	errorJoinMode?: 'none' | 'deepest' | 'furthest' | 'all';
-}
+	parserContextClass?: Class<ParserContext<Sequence, Element>>;
+};
 
-function isAsyncIterable<T>(value: any): value is AsyncIterable<T> {
-	return value && typeof value[Symbol.asyncIterator] === 'function';
-}
+export type RunParserWithRemainingInputResult<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+> = {
+	output: Output;
+	position: number;
+	remainingInput: undefined | AsyncIterable<Sequence>;
+};
 
-function isIterable<T>(value: any): value is Iterable<T> {
-	return value && typeof value[Symbol.iterator] === 'function';
+async function withEnrichedParserError<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	parserContext: ParserContext<Sequence, Element>,
+	inputReader: InputReaderImplementation<Sequence, Element>,
+	f: () => Promise<Output>,
+): Promise<Output> {
+	try {
+		return await f();
+	} catch (error) {
+		if (error instanceof ParserError) {
+			if (error.position === undefined) {
+				error.position = parserContext.position;
+			}
+
+			if (error.inputReaderSate === undefined) {
+				error.inputReaderSate = inputReader.toInputReaderState();
+			}
+		}
+
+		throw error;
+	}
 }
 
-function isIterator<T>(value: any): value is Iterator<T> {
-	return value && typeof value.next === 'function';
-}
+type RunParserInternalResult<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+> = {
+	outputPromise: Promise<Output>;
+	parserContext: ParserContext<Sequence, Element>;
+	inputReader: InputReaderImplementation<Sequence, Element>;
+};
 
-function iteratorToAsyncIterator<T>(iterator: Iterator<T>): AsyncIterator<T> {
-	return {
-		next: async () => iterator.next(),
-	};
-}
+function runParserInternal<
+	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> = {},
+): RunParserInternalResult<Output, Sequence, Element> {
+	const inputAsyncIterator = toAsyncIterator(input);
 
-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;
-		})();
-	}
+	const inputReader = new InputReaderImplementation<Sequence, Element>(parserInputCompanion, inputAsyncIterator);
 
-	if (isAsyncIterable(value)) {
-		return value[Symbol.asyncIterator]();
-	}
+	const ParserContext = options.parserContextClass ?? ParserContextImplementation;
 
-	if (isIterable(value)) {
-		return iteratorToAsyncIterator(value[Symbol.iterator]());
-	}
+	const parserContext = new ParserContext<Sequence, Element>(parserInputCompanion, inputReader, undefined, {
+		...options,
+		debugName: 'root',
+	});
 
-	if (isIterator<T>(value)) {
-		return iteratorToAsyncIterator(value);
-	}
+	const outputPromise = (async () => {
+		try {
+			return await parser(parserContext);
+		} finally {
+			await parserContext.peek(0);
+		}
+	})();
 
-	invariant(
-		false,
-		'Value must be an async iterator, async iterable, iterable or iterator got %s.',
-		value,
-	);
+	return {
+		outputPromise,
+		parserContext,
+		inputReader,
+	};
+}
+
+export async function runParserWithRemainingInput<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	parser: Parser<Output, Sequence, Element>,
+	input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence,
+	parserInputCompanion: ParserInputCompanion<Sequence, Element>,
+	options: RunParserOptions<Output, Sequence, Element> = {},
+): Promise<RunParserWithRemainingInputResult<Output, Sequence, Element>> {
+	const {
+		outputPromise,
+		parserContext,
+		inputReader,
+	} = runParserInternal(parser, input, parserInputCompanion, options);
+
+	return await withEnrichedParserError(parserContext, inputReader, async () => {
+		const output = await outputPromise;
+
+		const inputReaderState = inputReader.toInputReaderState();
+
+		const remainingInput = (
+			inputReaderStateCompanion.isDone(inputReaderState)
+				? undefined
+				: inputReaderStateCompanion.toRemainingInputAsyncIterator(inputReaderState)
+		);
+
+		return {
+			output,
+			position: parserContext.position,
+			remainingInput,
+		};
+	});
 }
 
 export async function runParser<
@@ -88,16 +184,24 @@ export async function runParser<
 >(
 	parser: Parser<Output, Sequence, Element>,
 	input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence,
-	inputCompanion: InputCompanion<Sequence, Element>,
+	parserInputCompanion: ParserInputCompanion<Sequence, Element>,
 	options: RunParserOptions<Output, Sequence, Element> = {},
 ): Promise<Output> {
-	const inputAsyncIterator = toAsyncIterator(input);
+	const {
+		outputPromise,
+		parserContext,
+		inputReader,
+	} = runParserInternal(parser, input, parserInputCompanion, options);
 
-	const inputReader = new InputReaderImplementation<Sequence, Element>(inputCompanion, inputAsyncIterator);
-	const parserContext = new ParserContextImplementation<Sequence, Element>(inputCompanion, inputReader, undefined, {
-		...options,
-		debugName: 'root',
-	});
+	return await withEnrichedParserError(parserContext, inputReader, async () => {
+		const output = await outputPromise;
+
+		const inputReaderState = inputReader.toInputReaderState();
 
-	return parser(parserContext);
+		if (!inputReaderStateCompanion.isDone(inputReaderState)) {
+			throw new ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position);
+		}
+
+		return output;
+	});
 }

package/src/parserAccessorParser.ts

@@ -1,3 +1,13 @@
-import { Parser } from "./parser.js";
+import { getParserName, setParserName, type Parser } from './parser.js';
 
-export const createParserAccessorParser = <Output, Sequence>(parserAccessor: () => Parser<Output, Sequence>): Parser<Output, Sequence> => async parserContext => parserAccessor()(parserContext);
+export const createParserAccessorParser = <Output, Sequence>(parserAccessor: () => Parser<Output, Sequence>): Parser<Output, Sequence> => {
+	const parserAccessorParser: Parser<Output, Sequence> = async parserContext => {
+		const parser = parserAccessor();
+
+		setParserName(parserAccessorParser, `parserAccessorParser(${getParserName(parser, 'anonymousParserAccessor')})`);
+
+		return parser(parserContext);
+	};
+
+	return parserAccessorParser;
+}

package/src/parserConsumedSequenceParser.ts

@@ -0,0 +1,29 @@
+import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
+import { getParserName, Parser, setParserName } from "./parser.js";
+
+export const createParserConsumedSequenceParser = <Output, Sequence>(
+	childParser: Parser<Output, Sequence>,
+): Parser<[Output, Sequence], Sequence> => {
+	const parserConsumedSequenceParser: Parser<[Output, Sequence], Sequence> = async parserContext => {
+		const initialPosition = parserContext.position;
+		const childParserContext = parserContext.lookahead();
+
+		let value: Output;
+		let consumedLength: number;
+		try {
+			value = await childParser(childParserContext);
+			consumedLength = childParserContext.position - initialPosition;
+		} finally {
+			childParserContext.dispose();
+		}
+
+		const consumedSequenceParser = createFixedLengthSequenceParser<Sequence>(consumedLength);
+		const consumedSequence = await consumedSequenceParser(parserContext);
+
+		return [value, consumedSequence];
+	};
+
+	setParserName(parserConsumedSequenceParser, `parserConsumedSequenceParser(${getParserName(childParser, 'anonymousParserConsumedSequenceParserChild')})`);
+
+	return parserConsumedSequenceParser;
+};

package/src/parserContext.test.ts

@@ -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';
 
@@ -13,7 +13,7 @@ const commonParserContextArguments = [
 ] as const;
 
 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';
@@ -30,8 +30,31 @@ test('parserContext.read', async t => {
 	});
 });
 
+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);
 
@@ -42,11 +65,15 @@ test('parserContext.lookahead', async t => {
 	});
 
 	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');
@@ -63,10 +90,14 @@ 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);
 
@@ -86,7 +117,7 @@ test('parserContext.unlookahead', async t => {
 });
 
 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);
 
@@ -103,7 +134,7 @@ test('parserContext.unlookahead while peeking', async t => {
 });
 
 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);
 
@@ -125,7 +156,7 @@ test('parserContext deep unlookahead normal order', async t => {
 });
 
 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);