@futpib/parser 1.0.1 → 1.0.3

package/src/parser.ts

@@ -1,15 +1,22 @@
-import invariant from 'invariant';
+import { type Class } from 'type-fest';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
 import { type ParserContext, ParserContextImplementation } from './parserContext.js';
 import { type DeriveSequenceElement } from './sequence.js';
+import { toAsyncIterator } from './toAsyncIterator.js';
+import { inputReaderStateCompanion } from './inputReaderState.js';
+import { isLazyMessageError } from './lazyMessageError.js';
+import { isParserError, isParserParsingFailedError, normalParserErrorModule, noStackCaptureOverheadParserErrorModule, ParserError } from './parserError.js';
+import { NoStackCaptureOverheadError } from './noStackCaptureOverheadError.js';
+import invariant from 'invariant';
 
 export type Parser<
 	Output,
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
-> = (parserContext: ParserContext<Sequence, Element>) => Promise<Output>;
+> = (parserContext: ParserContext<Sequence, Element>) => Output | Promise<Output>;
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function getParserName(parser: Parser<any, any, any>, default_ = 'anonymous'): string {
 	return parser.name || default_;
 }
@@ -26,59 +33,171 @@ export function setParserName<
 	return parser;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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 => 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';
+	errorStack?: boolean;
+	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 NoStackCaptureOverheadError) {
+			invariant(
+				error.name in normalParserErrorModule,
+				'NoStackCaptureOverheadError with unknown name encountered during parser execution: %s',
+				error.name,
+			);
+
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const normalError: ParserError = new ((normalParserErrorModule as any)[error.name])(error.message);
+			Object.assign(normalError, error);
+
+			normalError.stack = normalError.stack + '\nIf you need a useful stack trace, pass `errorStack: true` to `runParser`, trading off some performance.';
+
+			error = normalError;
+		}
+
+		if (isLazyMessageError(error)) {
+			error.computeMessage();
+		}
+
+		if (isParserError(error)) {
+			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,
+		errorsModule: options.errorStack ? normalParserErrorModule : noStackCaptureOverheadParserErrorModule,
+		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 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<
@@ -91,13 +210,21 @@ export async function runParser<
 	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>(parserInputCompanion, inputAsyncIterator);
-	const parserContext = new ParserContextImplementation<Sequence, Element>(parserInputCompanion, inputReader, undefined, {
-		...options,
-		debugName: 'root',
-	});
+	return withEnrichedParserError(parserContext, inputReader, async () => {
+		const output = await outputPromise;
+
+		const inputReaderState = inputReader.toInputReaderState();
 
-	return parser(parserContext);
+		if (!inputReaderStateCompanion.isDone(inputReaderState)) {
+			throw new normalParserErrorModule.ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position);
+		}
+
+		return output;
+	});
 }

package/src/parserAccessorParser.ts

@@ -1,3 +1,13 @@
-import { type 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

@@ -1,20 +1,29 @@
-import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
-import { Parser } from "./parser.js";
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { getParserName, type Parser, setParserName } from './parser.js';
 
 export const createParserConsumedSequenceParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
-): 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];
-}
+): 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

@@ -2,13 +2,15 @@ import test from 'ava';
 import { ParserContextImplementation } from './parserContext.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
-import { ParserUnexpectedEndOfInputError } from './parserError.js';
+import { noStackCaptureOverheadParserErrorModule } from './parserError.js';
 
 const commonParserContextArguments = [
 	undefined,
 	{
 		debugName: 'root',
 		errorJoinMode: 'all',
+		errorStack: false,
+		errorsModule: noStackCaptureOverheadParserErrorModule,
 	},
 ] as const;
 
@@ -26,7 +28,32 @@ test('parserContext.read', async t => {
 	t.is(await parserContext.read(5), 'h');
 
 	await t.throwsAsync(async () => parserContext.read(0), {
-		instanceOf: ParserUnexpectedEndOfInputError,
+		any: true,
+		name: '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), {
+		any: true,
+		name: 'ParserUnexpectedEndOfInputError',
 	});
 });
 
@@ -42,11 +69,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,6 +94,10 @@ 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 => {