@futpib/parser 1.0.1 → 1.0.3

package/src/jsonParser.ts

@@ -13,28 +13,27 @@ import { createArrayParser } from './arrayParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createElementParser } from './elementParser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
 
-const whitespaceParser: Parser<unknown, string> = createArrayParser(
-	createUnionParser([
-		createExactSequenceParser(' '),
-		createExactSequenceParser('\t'),
-		createExactSequenceParser('\r'),
-		createExactSequenceParser('\n'),
-	]),
-);
+const whitespaceParser: Parser<unknown, string> = createArrayParser(createUnionParser([
+	createExactSequenceParser(' '),
+	createExactSequenceParser('\t'),
+	createExactSequenceParser('\r'),
+	createExactSequenceParser('\n'),
+]));
 
-const jsonQuoteEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser('\\"'), () => '"');
+const jsonQuoteEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser(String.raw`\"`), () => '"');
 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 jsonSlashEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser(String.raw`\/`), () => '/');
+const jsonBackspaceEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser(String.raw`\b`), () => '\b');
+const jsonFormFeedEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser(String.raw`\f`), () => '\f');
+const jsonNewLineEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser(String.raw`\n`), () => '\n');
+const jsonCarriageReturnEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser(String.raw`\r`), () => '\r');
+const jsonTabEscapeSequenceParser: Parser<string, string> = promiseCompose(createExactSequenceParser(String.raw`\t`), () => '\t');
 
 const jsonUnicodeEscapeSequenceParser: Parser<string, string> = promiseCompose(
 	createTupleParser([
-		createExactSequenceParser('\\u'),
+		createExactSequenceParser(String.raw`\u`),
 		createFixedLengthSequenceParser<string>(4),
 	]),
 	([ , hexCode ]) => String.fromCharCode(Number.parseInt(hexCode, 16)),
@@ -65,7 +64,7 @@ const jsonStringCharacterParser: Parser<string, string> = createDisjunctionParse
 	)(),
 ]);
 
-const jsonStringParser: Parser<string, string> = promiseCompose(
+export const jsonStringParser: Parser<string, string> = promiseCompose(
 	createTupleParser([
 		createExactSequenceParser('"'),
 		promiseCompose(
@@ -79,28 +78,26 @@ const jsonStringParser: Parser<string, string> = promiseCompose(
 	([ , 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;
-			},
-		)(),
-	),
+export 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');
 
@@ -189,30 +186,17 @@ 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,
+		createSeparatedArrayParser(
+			createParserAccessorParser(() => jsonValueParser),
+			createTupleParser([
+				whitespaceParser,
+				createExactSequenceParser(','),
+				whitespaceParser,
+			]),
 		),
+		whitespaceParser,
+		createExactSequenceParser(']'),
+		whitespaceParser,
 	]),
 	([ _bracket, _whitespace, values ]) => values,
 );

package/src/lazyMessageError.test.ts

@@ -0,0 +1,21 @@
+import test from 'ava';
+import { NormalLazyMessageError } from './lazyMessageError.js';
+
+test('LazyMessageError works', t => {
+	const error = new NormalLazyMessageError([
+		() => [
+			'Line 1: %s',
+			'Line 2: %s and %s.',
+		],
+		42,
+		() => 'foo',
+		true,
+	]);
+
+	error.computeMessage();
+
+	t.is(
+		error.message,
+		'Line 1: 42\nLine 2: foo and true.',
+	);
+});

package/src/lazyMessageError.ts

@@ -0,0 +1,88 @@
+import { NoStackCaptureOverheadError } from "./noStackCaptureOverheadError.js";
+
+type ValueOrAccessor<T> = T | (() => T);
+
+export type LazyMessage =
+	| ValueOrAccessor<string | string[]>
+	| [ ValueOrAccessor<string | string[]>, ...Array<ValueOrAccessor<unknown>> ]
+;
+
+function formatLazyMessageFormat(
+	format: ValueOrAccessor<string | string[]>,
+): string {
+	if (typeof format === 'function') {
+		format = format();
+	}
+
+	if (Array.isArray(format)) {
+		return format.join('\n');
+	}
+
+	return format;
+}
+
+function formatLazyMessageSubstitutions(
+	format: string,
+	formatArguments: Array<ValueOrAccessor<unknown>>,
+): string {
+	return format.replaceAll('%s', () => {
+		const argumentOrAccessor = formatArguments.shift();
+		return typeof argumentOrAccessor === 'function' ? argumentOrAccessor() : argumentOrAccessor;
+	});
+}
+
+export function formatLazyMessage(lazyMessage: LazyMessage): string {
+	if (Array.isArray(lazyMessage)) {
+		const [ format, ...formatArguments ] = lazyMessage;
+		const formattedFormat = formatLazyMessageFormat(format);
+		return formatLazyMessageSubstitutions(formattedFormat, formatArguments);
+	} else {
+		return formatLazyMessageFormat(lazyMessage);
+	}
+}
+
+export interface LazyMessageError extends Error {
+	computeMessage(): void;
+}
+
+export function createLazyMessageErrorClass(
+	BaseError: typeof NoStackCaptureOverheadError | typeof Error,
+) {
+	return class LazyMessageError extends (BaseError as typeof Error) implements LazyMessageError {
+		name = 'LazyMessageError';
+
+		_lazyMessage: undefined | LazyMessage;
+
+		constructor(
+			lazyMessage: LazyMessage,
+		) {
+			super('LAZY_MESSAGE');
+			this._lazyMessage = lazyMessage;
+		}
+
+		computeMessage(): void {
+			if (this._lazyMessage === undefined) {
+				return;
+			}
+
+			this.message = formatLazyMessage(this._lazyMessage);
+			this.stack = this.stack?.replace('LAZY_MESSAGE', this.message);
+			delete this._lazyMessage;
+		}
+	}
+}
+
+export const NormalLazyMessageError = createLazyMessageErrorClass(Error);
+export const NoStackCaptureOverheadLazyMessageError = createLazyMessageErrorClass(NoStackCaptureOverheadError);
+
+export function isLazyMessageError(
+	value: unknown,
+): value is LazyMessageError {
+	return (
+		typeof value === 'object'
+			&& value !== null
+			&& value instanceof Error
+			&& '_lazyMessage' in value
+			&& typeof (value as Record<string, unknown>).computeMessage === 'function'
+	);
+}

package/src/leb128Parser.test.ts

@@ -0,0 +1,173 @@
+import { testProp, fc } from '@fast-check/ava';
+import test from 'ava';
+// @ts-expect-error
+import leb128 from 'leb128';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import {
+	uleb128Parser, sleb128Parser, uleb128NumberParser, sleb128NumberParser,
+} from './leb128Parser.js';
+
+test('sleb128, uleb128, uleb128p1', async t => {
+	for (const [
+		input, expectedSleb128, expectedUleb128,
+	] of [
+			[ Buffer.from('00', 'hex'), 0n, 0n ],
+			[ Buffer.from('01', 'hex'), 1n, 1n ],
+			[ Buffer.from('7f', 'hex'), -1n, 127n ],
+			[ Buffer.from('807f', 'hex'), -128n, 16_256n ],
+		] as const) {
+		const actualSleb128 = await runParser(sleb128Parser, input, uint8ArrayParserInputCompanion);
+		const actualUleb128 = await runParser(uleb128Parser, input, uint8ArrayParserInputCompanion);
+
+		t.is(actualSleb128, expectedSleb128, 'sleb128');
+		t.is(actualUleb128, expectedUleb128, 'uleb128');
+	}
+
+	for (const [
+		input, expectedUleb128,
+	] of [
+			[ new Uint8Array([ 2 ]), 2n ],
+			[ new Uint8Array([ 127 ]), 127n ],
+			[ new Uint8Array([ 0 + 0x80, 1 ]), 128n ],
+			[ new Uint8Array([ 1 + 0x80, 1 ]), 129n ],
+			[ new Uint8Array([ 57 + 0x80, 100 ]), 12_857n ],
+		] as const) {
+		const actualUleb128 = await runParser(uleb128Parser, input, uint8ArrayParserInputCompanion);
+
+		t.is(actualUleb128, expectedUleb128, 'uleb128');
+	}
+
+	for (const [
+		input, expectedSleb128,
+	] of [
+			[ new Uint8Array([ 2 ]), 2n ],
+			[ new Uint8Array([ 0x7E ]), -2n ],
+			[ new Uint8Array([ 127 + 0x80, 0 ]), 127n ],
+			[ new Uint8Array([ 1 + 0x80, 0x7F ]), -127n ],
+			[ new Uint8Array([ 0 + 0x80, 1 ]), 128n ],
+			[ new Uint8Array([ 0 + 0x80, 0x7F ]), -128n ],
+			[ new Uint8Array([ 1 + 0x80, 1 ]), 129n ],
+			[ new Uint8Array([ 0x7F + 0x80, 0x7E ]), -129n ],
+		] as const) {
+		const actualSleb128 = await runParser(sleb128Parser, input, uint8ArrayParserInputCompanion);
+
+		t.is(actualSleb128, expectedSleb128, 'sleb128');
+	}
+});
+
+testProp(
+	'uleb128NumberParser on small number',
+	[
+		fc.nat(),
+	],
+	async (t, natural) => {
+		const uleb128 = leb128.unsigned.encode(natural);
+
+		const actualUleb128 = await runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion);
+
+		t.is(actualUleb128, natural, 'uleb128');
+	},
+	{
+		verbose: true,
+	},
+);
+
+testProp(
+	'sleb128NumberParser on small number',
+	[
+		fc.integer(),
+	],
+	async (t, integer) => {
+		const sleb128 = leb128.signed.encode(integer);
+
+		const actualSleb128 = await runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion);
+
+		t.is(actualSleb128, integer, 'sleb128');
+	},
+	{
+		verbose: true,
+	},
+);
+
+// TODO?
+testProp.skip(
+	'uleb128NumberParser on large number',
+	[
+		fc.maxSafeNat(),
+	],
+	async (t, natural) => {
+		const uleb128 = leb128.unsigned.encode(natural);
+
+		if (natural > (2 ** 32) - 1) {
+			await t.throwsAsync(async () => runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion));
+
+			return;
+		}
+
+		const actualUleb128 = await runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion);
+
+		t.is(actualUleb128, natural, 'uleb128');
+	},
+	{
+		verbose: true,
+	},
+);
+
+// TODO?
+testProp.skip(
+	'sleb128NumberParser on large number',
+	[
+		fc.maxSafeInteger(),
+	],
+	async (t, integer) => {
+		const sleb128 = leb128.signed.encode(integer);
+
+		if (integer > (2 ** 32) - 1 || integer < -(2 ** 32)) {
+			await t.throwsAsync(async () => runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion));
+
+			return;
+		}
+
+		const actualSleb128 = await runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion);
+
+		t.is(actualSleb128, integer, 'sleb128');
+	},
+	{
+		verbose: true,
+	},
+);
+
+testProp(
+	'uleb128Parser on bigint',
+	[
+		fc.bigInt({ min: 0n }),
+	],
+	async (t, bigInt) => {
+		const uleb128 = leb128.unsigned.encode(bigInt);
+
+		const actualUleb128 = await runParser(uleb128Parser, uleb128, uint8ArrayParserInputCompanion);
+
+		t.is(actualUleb128, bigInt, 'uleb128');
+	},
+	{
+		verbose: true,
+	},
+);
+
+testProp(
+	'sleb128Parser on bigint',
+	[
+		fc.bigInt(),
+	],
+	async (t, bigInt) => {
+		const sleb128 = leb128.signed.encode(bigInt);
+
+		const actualSleb128 = await runParser(sleb128Parser, sleb128, uint8ArrayParserInputCompanion);
+
+		t.is(actualSleb128, bigInt, 'sleb128');
+	},
+	{
+		verbose: true,
+	},
+);

package/src/leb128Parser.ts

@@ -0,0 +1,125 @@
+import { type 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 & 0b0111_1111);
+		const byteNotLast = BigInt(byte & 0b1000_0000);
+
+		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 & 0b0111_1111);
+		const byteNotLast = BigInt(byte & 0b1000_0000);
+
+		value |= byteValue << leastSignificantValueBitIndex;
+		leastSignificantValueBitIndex += 7n;
+
+		if (byteNotLast) {
+			continue;
+		}
+
+		const mostSignificantInputBit = byte & 0b0100_0000;
+
+		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 & 0b0111_1111;
+		const byteNotLast = byte & 0b1000_0000;
+
+		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 & 0b0111_1111;
+		const byteNotLast = byte & 0b1000_0000;
+
+		value |= byteValue << leastSignificantValueBitIndex;
+		leastSignificantValueBitIndex += 7;
+
+		if (byteNotLast) {
+			continue;
+		}
+
+		const mostSignificantInputBit = byte & 0b0100_0000;
+
+		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,49 @@
+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';
+
+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(async () => runParser(
+			createTupleParser([
+				createNegativeLookaheadParser(createExactSequenceParser(stringA)),
+				createExactSequenceParser(stringA + stringB),
+			]),
+			stringA + stringB,
+			stringParserInputCompanion,
+		), {
+			any: true,
+			name: 'ParserParsingInvariantError',
+			message: /lookahead/,
+		});
+	},
+	{
+		verbose: true,
+	},
+);

package/src/negativeLookaheadParser.ts

@@ -1,24 +1,36 @@
-import { getParserName, type Parser } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { getParserName, setParserName, type Parser } from './parser.js';
+import { isParserParsingFailedError, 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 (!isParserParsingFailedError(error)) {
+				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/noStackCaptureOverheadError.test.ts

@@ -0,0 +1,17 @@
+import test from 'ava';
+import util from 'util';
+import { NoStackCaptureOverheadError } from './noStackCaptureOverheadError.js';
+
+test('NoStackCaptureOverheadError works', t => {
+	const error = new NoStackCaptureOverheadError('Test message');
+
+	t.is(error.name, 'NoStackCaptureOverheadError');
+	t.is(error.message, 'Test message');
+	t.true(error instanceof Error, 'error is instance of Error');
+	t.true(error instanceof NoStackCaptureOverheadError, 'error is instance of NoStackCaptureOverheadError');
+	t.false(new Error() instanceof NoStackCaptureOverheadError, 'regular Error is not instance of NoStackCaptureOverheadError');
+	if (typeof (Error as any).isError === 'function') {
+		t.false((Error as any).isError(error), 'Error.isError does not identify error as Error');
+	}
+	t.false(util.types.isNativeError(error), 'util.types.isNativeError does not identify error as native Error');
+});