@futpib/parser 1.0.1 → 1.0.2

package/src/leb128Parser.ts

@@ -0,0 +1,125 @@
+import { Parser } from "./parser.js";
+
+export const uleb128Parser: Parser<bigint, Uint8Array> = async (parserContext) => {
+	let leastSignificantValueBitIndex = 0n;
+	let value = 0n;
+
+	while (true) {
+		const byte = await parserContext.read(0);
+		const byteValue = BigInt(byte & 0b01111111);
+		const byteNotLast = BigInt(byte & 0b10000000);
+
+		value |= byteValue << leastSignificantValueBitIndex;
+
+		if (byteNotLast) {
+			leastSignificantValueBitIndex += 7n;
+			continue;
+		}
+
+		break;
+	}
+
+	return value;
+}
+
+export const sleb128Parser: Parser<bigint, Uint8Array> = async (parserContext) => {
+	let value = 0n;
+	let leastSignificantValueBitIndex = 0n;
+
+	while (true) {
+		const byte = await parserContext.read(0);
+		const byteValue = BigInt(byte & 0b01111111);
+		const byteNotLast = BigInt(byte & 0b10000000);
+
+		value |= byteValue << leastSignificantValueBitIndex;
+		leastSignificantValueBitIndex += 7n;
+
+		if (byteNotLast) {
+			continue;
+		}
+
+		const mostSignificantInputBit = byte & 0b01000000;
+
+		if (mostSignificantInputBit) {
+			value |= (~0n << leastSignificantValueBitIndex);
+		}
+
+		break;
+	}
+
+	return value;
+};
+
+export const uleb128NumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+	const value = await uleb128Parser(parserContext);
+
+	parserContext.invariant(
+		Number(value) <= Number.MAX_SAFE_INTEGER,
+		'Value is too large to be represented as a number: %s',
+		value,
+	);
+
+	return Number(value);
+};
+
+export const sleb128NumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+	const value = await sleb128Parser(parserContext);
+
+	parserContext.invariant(
+		Number(value) >= Number.MIN_SAFE_INTEGER && Number(value) <= Number.MAX_SAFE_INTEGER,
+		'Value is too large to be represented as a number: %s',
+		value,
+	);
+
+	return Number(value);
+};
+
+export const uleb128UnsafeNumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+	let leastSignificantValueBitIndex = 0;
+	let value = 0;
+
+	while (true) {
+		const byte = await parserContext.read(0);
+		const byteValue = byte & 0b01111111;
+		const byteNotLast = byte & 0b10000000;
+
+		value |= byteValue << leastSignificantValueBitIndex;
+
+		if (byteNotLast) {
+			leastSignificantValueBitIndex += 7;
+			continue;
+		}
+
+		break;
+	}
+
+	return value;
+}
+
+export const sleb128UnsafeNumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+	let value = 0;
+	let leastSignificantValueBitIndex = 0;
+
+	while (true) {
+		const byte = await parserContext.read(0);
+		const byteValue = byte & 0b01111111;
+		const byteNotLast = byte & 0b10000000;
+
+		value |= byteValue << leastSignificantValueBitIndex;
+		leastSignificantValueBitIndex += 7;
+
+		if (byteNotLast) {
+			continue;
+		}
+
+		const mostSignificantInputBit = byte & 0b01000000;
+
+		if (leastSignificantValueBitIndex < 32 && mostSignificantInputBit) {
+			value |= (~0 << leastSignificantValueBitIndex);
+		}
+
+		break;
+	}
+
+	return value;
+};

package/src/lookaheadParser.ts

@@ -0,0 +1,19 @@
+import { getParserName, setParserName, type Parser } from './parser.js';
+
+export const createLookaheadParser = <Output, Sequence>(
+	childParser: Parser<Output, Sequence>,
+): Parser<Output, Sequence> => {
+	const lookaheadParser: Parser<Output, Sequence> = async parserContext => {
+		const childParserContext = parserContext.lookahead();
+
+		try {
+			return await childParser(childParserContext);
+		} finally {
+			childParserContext.dispose();
+		}
+	};
+
+	setParserName(lookaheadParser, `(?=${getParserName(childParser)})`);
+
+	return lookaheadParser;
+};

package/src/negativeLookaheadParser.test.ts

@@ -0,0 +1,53 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createTupleParser } from './tupleParser.js';
+import { ParserParsingFailedError } from './parserError.js';
+
+testProp(
+	'negativeLookaheadParser',
+	[
+		fc.tuple(
+			fc.string({
+				minLength: 1,
+			}),
+			fc.string({
+				minLength: 1,
+			}),
+		).filter(([ a, b ]) => !a.startsWith(b))
+	],
+	async (t, [ stringA, stringB ]) => {
+		const result = await runParser(
+			createTupleParser([
+				createNegativeLookaheadParser(
+					createExactSequenceParser(stringB),
+				),
+				createExactSequenceParser(stringA + stringB),
+			]),
+			stringA + stringB,
+			stringParserInputCompanion,
+		);
+
+		t.deepEqual(result, [undefined, stringA + stringB]);
+
+		await t.throwsAsync(() => runParser(
+			createTupleParser([
+				createNegativeLookaheadParser(
+					createExactSequenceParser(stringA),
+				),
+				createExactSequenceParser(stringA + stringB),
+			]),
+			stringA + stringB,
+			stringParserInputCompanion,
+		), {
+			instanceOf: ParserParsingFailedError,
+			message: /lookahead/,
+		});
+	},
+	{
+		verbose: true,
+	},
+);

package/src/negativeLookaheadParser.ts

@@ -1,24 +1,36 @@
-import { getParserName, type Parser } from './parser.js';
+import { getParserName, setParserName, type Parser } from './parser.js';
 import { ParserParsingFailedError } from './parserError.js';
 
 export const createNegativeLookaheadParser = <Sequence>(
 	childParser: Parser<unknown, Sequence>,
-): Parser<void, Sequence> => async parserContext => {
-	const childParserContext = parserContext.lookahead();
-	try {
-		await childParser(childParserContext);
+): Parser<void, Sequence> => {
+	const negativeLookaheadParser: Parser<void, Sequence> = async parserContext => {
+		const childParserContext = parserContext.lookahead();
+
+		let childParserSuccess: boolean;
+
+		try {
+			await childParser(childParserContext);
+
+			childParserSuccess = true;
+		} catch (error) {
+			if (!(error instanceof ParserParsingFailedError)) {
+				throw error;
+			}
+
+			childParserSuccess = false;
+		} finally {
+			childParserContext.dispose();
+		}
+
 		parserContext.invariant(
-			false,
+			!childParserSuccess,
 			'Negative lookahead assertion failed for child parser %s.',
 			getParserName(childParser),
 		);
-	} catch (error) {
-		if (error instanceof ParserParsingFailedError) {
-			return;
-		}
+	};
+
+	setParserName(negativeLookaheadParser, `(?!${getParserName(childParser)})`);
 
-		throw error;
-	} finally {
-		childParserContext.dispose();
-	}
+	return negativeLookaheadParser;
 };

package/src/nonEmptyArrayParser.test.ts

@@ -0,0 +1,20 @@
+import test from 'ava';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { type Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactElementParser } from './exactElementParser.js';
+
+test('empty array does not match', async t => {
+	const parser: Parser<string[], string> = createNonEmptyArrayParser(createExactElementParser('0'));
+
+	await t.throwsAsync(() => runParser(parser, '', stringParserInputCompanion), {
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('non-empty array matches', async t => {
+	const parser: Parser<string[], string> = createNonEmptyArrayParser(createExactElementParser('0'));
+	const result = await runParser(parser, '0', stringParserInputCompanion);
+
+	t.deepEqual(result, ['0']);
+});

package/src/nonEmptyArrayParser.ts

@@ -0,0 +1,44 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+
+export const createNonEmptyArrayParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	const nonEmptyArrayParser: Parser<ElementOutput[], Sequence> = async parserContext => {
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const elementParserContext = parserContext.lookahead();
+			const initialPosition = elementParserContext.position;
+			try {
+				const element = await elementParser(elementParserContext);
+				if (elementParserContext.position === initialPosition) {
+					break;
+				}
+
+				elements.push(element);
+				elementParserContext.unlookahead();
+			} catch (error) {
+				if (error instanceof ParserParsingFailedError) {
+					break;
+				}
+
+				throw error;
+			} finally {
+				elementParserContext.dispose();
+			}
+		}
+
+		parserContext.invariant(
+			elements.length > 0,
+			'Expected elementParser (%s) to match at least once',
+			getParserName(elementParser, 'anonymousNonEmptyArrayChild'),
+		);
+
+		return elements;
+	};
+
+	setParserName(nonEmptyArrayParser, getParserName(elementParser, 'anonymousNonEmptyArrayChild') + '+');
+
+	return nonEmptyArrayParser;
+};

package/src/optionalParser.ts

@@ -6,6 +6,7 @@ export const createOptionalParser = <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();

package/src/parser.test.ts

@@ -1,36 +1,44 @@
 import test from 'ava';
 import invariant from 'invariant';
 import { createUnionParser } from './unionParser.js';
-import { type Parser, runParser } from './parser.js';
+import { type Parser, runParser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import {
-	ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError,
+	ParserError,
+	ParserParsingInvariantError,
+	ParserParsingJoinAllError,
+	ParserParsingJoinDeepestError,
+	ParserParsingJoinError,
+	ParserParsingJoinFurthestError,
+	ParserParsingJoinNoneError,
+	ParserUnexpectedRemainingInputError,
 } from './parserError.js';
 import { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
-import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createExactSequenceNaiveParser } from './exactSequenceParser.js';
 import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
+import { toAsyncIterable } from './toAsyncIterable.js';
 
 const aUnionParser = createUnionParser<string, string>([
-	createExactSequenceParser('1'),
-	createExactSequenceParser('aa'),
-	createExactSequenceParser('AAA'),
+	createExactSequenceNaiveParser('1'),
+	createExactSequenceNaiveParser('aa'),
+	createExactSequenceNaiveParser('AAA'),
 ]);
 
 const abDisjunctionParser = createDisjunctionParser<string, string>([
 	aUnionParser,
-	createExactSequenceParser('2'),
-	createExactSequenceParser('bb'),
-	createExactSequenceParser('BBB'),
+	createExactSequenceNaiveParser('2'),
+	createExactSequenceNaiveParser('bb'),
+	createExactSequenceNaiveParser('BBB'),
 ]);
 
 const abcUnionParser = createUnionParser<string, string>([
 	abDisjunctionParser,
-	createExactSequenceParser('final_3'),
-	createExactSequenceParser('final_cc'),
-	createExactSequenceParser('final_CCC'),
+	createExactSequenceNaiveParser('final_3'),
+	createExactSequenceNaiveParser('final_cc'),
+	createExactSequenceNaiveParser('final_CCC'),
 ]);
 
 const sampleParser = promiseCompose(
@@ -46,6 +54,16 @@ async function * asyncIteratorFromString(string: string) {
 	yield string;
 }
 
+async function stringFromAsyncIterable(asyncIterable: AsyncIterable<string>) {
+	let string = '';
+
+	for await (const chunk of asyncIterable) {
+		string += chunk;
+	}
+
+	return string;
+}
+
 function sortChildErrors(error: ParserParsingJoinNoneError) {
 	error.childErrors.sort((a, b) => a.message.localeCompare(b.message));
 
@@ -176,3 +194,104 @@ test('throws on parserInputCompanion type mismatch', async t => {
 		message: /input companion/,
 	});
 });
+
+test('thrown error has input reader state', async t => {
+	const error = await t.throwsAsync(
+		runParser(
+			createTupleParser([
+				createExactSequenceNaiveParser('foo'),
+				createExactSequenceNaiveParser('bar'),
+			]),
+			(async function * () {
+				yield 'foo';
+				yield 'qux';
+				yield 'bar';
+			})(),
+			stringParserInputCompanion,
+		),
+		{
+			instanceOf: ParserError,
+		},
+	);
+
+	t.is(error.position, 4);
+
+	invariant(error.inputReaderSate, 'error.inputReaderSate');
+
+	const {
+		consumedBufferedSequences,
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+		position,
+		...inputReaderStateRest
+	} = error.inputReaderSate;
+
+	t.is(position, 4);
+	t.deepEqual(inputReaderStateRest, {});
+
+	const unbufferedSequencesArray = [];
+
+	if (unbufferedSequences) {
+		for await (const sequence of toAsyncIterable(unbufferedSequences)) {
+			unbufferedSequencesArray.push(sequence);
+		}
+	}
+
+	t.deepEqual(consumedBufferedSequences, [ 'q' ]);
+	t.deepEqual(unconsumedBufferedSequences, [ 'ux' ]);
+	t.deepEqual(unbufferedSequencesArray, [ 'bar' ]);
+});
+
+test('runParser throws with remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const error = await t.throwsAsync(() => runParser(parser, 'foobar', stringParserInputCompanion), {
+		instanceOf: ParserUnexpectedRemainingInputError,
+		message: /remaining input/,
+	});
+
+	t.is(error.position, 3);
+
+	const {
+		position,
+		consumedBufferedSequences,
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+		...inputReaderStateRest
+	} = error.inputReaderSate!;
+
+	t.deepEqual(inputReaderStateRest, {});
+	t.is(position, 3);
+	t.deepEqual(consumedBufferedSequences, [ 'foo' ]);
+	t.deepEqual(unconsumedBufferedSequences, [ 'bar' ]);
+	t.truthy(unbufferedSequences);
+});
+
+test('runParser does not throw without remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const output = await runParser(parser, 'foo', stringParserInputCompanion);
+
+	t.deepEqual(output, 'foo');
+});
+
+test('runParserWithRemainingInput with remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const {
+		output,
+		remainingInput,
+		position,
+		...resultRest
+	} = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
+
+	t.deepEqual(resultRest, {});
+	t.deepEqual(output, 'foo');
+	t.deepEqual(await stringFromAsyncIterable(remainingInput!), 'bar');
+	t.is(position, 3);
+});
+
+test('runParserWithRemainingInput without remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const { output, remainingInput } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+
+	t.deepEqual(output, 'foo');
+	t.is(remainingInput, undefined);
+});

package/src/parser.test.ts.md

@@ -8,32 +8,32 @@ Generated by [AVA](https://avajs.dev).
 
 > Snapshot 1
 
-    `ParserParsingJoinNoneError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinNoneError: No union child parser succeeded.␊
         at [LOCATIONS]`
 
 ## errorJoinMode: all
 
 > Snapshot 1
 
-    `ParserParsingJoinAllError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinAllError: 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.␊
+      ParserParsingInvariantError: Expected "3", got "C", at [LOCATIONS]␊
+      ParserParsingInvariantError: Expected "c", got "C", at [LOCATIONS]␊
+      ParserParsingJoinAllError: No disjunction child parser succeeded.␊
       Child error stacks, indented:␊
-        ParserParsingJoinAllError: (position: 4) No union child parser succeeded.␊
+        ParserParsingJoinAllError: 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]␊
+          ParserParsingInvariantError: Expected "1", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "a", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: 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]␊
+        ParserParsingInvariantError: Expected "2", got "f", at [LOCATIONS]␊
+        ParserParsingInvariantError: Expected "b", got "f", at [LOCATIONS]␊
+        ParserParsingInvariantError: Expected "B", got "f", at [LOCATIONS]␊
       End of child error stacks␊
           at [LOCATIONS]␊
-      ParserParsingInvariantError: (position: 12) Expected "C", got "!", at [LOCATIONS]␊
+      ParserParsingInvariantError: Expected "C", got "!", at [LOCATIONS]␊
     End of child error stacks␊
         at [LOCATIONS]`
 
@@ -41,15 +41,15 @@ Generated by [AVA](https://avajs.dev).
 
 > Snapshot 1
 
-    `ParserParsingJoinDeepestError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinDeepestError: No union child parser succeeded.␊
     Deepest child error stacks, indented:␊
-      ParserParsingJoinDeepestError: (position: 3) No disjunction child parser succeeded.␊
+      ParserParsingJoinDeepestError: No disjunction child parser succeeded.␊
       Deepest child error stacks, indented:␊
-        ParserParsingJoinDeepestError: (position: 4) No union child parser succeeded.␊
+        ParserParsingJoinDeepestError: 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]␊
+          ParserParsingInvariantError: Expected "1", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "a", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "A", got "f", at [LOCATIONS]␊
         End of deepest child error stacks␊
             at [LOCATIONS]␊
       End of deepest child error stacks␊
@@ -61,8 +61,8 @@ Generated by [AVA](https://avajs.dev).
 
 > Snapshot 1
 
-    `ParserParsingJoinFurthestError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinFurthestError: No union child parser succeeded.␊
     Furthest child error stacks, indented:␊
-      ParserParsingInvariantError: (position: 12) Expected "C", got "!", at [LOCATIONS]␊
+      ParserParsingInvariantError: Expected "C", got "!", at [LOCATIONS]␊
     End of furthest child error stacks␊
         at [LOCATIONS]`