@futpib/parser 1.0.2 → 1.0.3

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

@@ -4,17 +4,19 @@ import test from 'ava';
 import leb128 from 'leb128';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
-import { uleb128Parser, sleb128Parser, uleb128NumberParser, sleb128NumberParser } from './leb128Parser.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, 16256n ],
-	] as const) {
+			[ 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);
 
@@ -25,12 +27,12 @@ test('sleb128, uleb128, uleb128p1', async t => {
 	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 ]), 12857n ],
-	] as const) {
+			[ 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');
@@ -39,15 +41,15 @@ test('sleb128, uleb128, uleb128p1', async t => {
 	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) {
+			[ 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');
@@ -98,7 +100,7 @@ testProp.skip(
 		const uleb128 = leb128.unsigned.encode(natural);
 
 		if (natural > (2 ** 32) - 1) {
-			await t.throwsAsync(() => runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion));
+			await t.throwsAsync(async () => runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion));
 
 			return;
 		}
@@ -122,7 +124,7 @@ testProp.skip(
 		const sleb128 = leb128.signed.encode(integer);
 
 		if (integer > (2 ** 32) - 1 || integer < -(2 ** 32)) {
-			await t.throwsAsync(() => runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion));
+			await t.throwsAsync(async () => runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion));
 
 			return;
 		}

package/src/leb128Parser.ts

@@ -1,13 +1,13 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 
-export const uleb128Parser: Parser<bigint, Uint8Array> = async (parserContext) => {
+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);
+		const byteValue = BigInt(byte & 0b0111_1111);
+		const byteNotLast = BigInt(byte & 0b1000_0000);
 
 		value |= byteValue << leastSignificantValueBitIndex;
 
@@ -20,16 +20,16 @@ export const uleb128Parser: Parser<bigint, Uint8Array> = async (parserContext) =
 	}
 
 	return value;
-}
+};
 
-export const sleb128Parser: Parser<bigint, Uint8Array> = async (parserContext) => {
+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);
+		const byteValue = BigInt(byte & 0b0111_1111);
+		const byteNotLast = BigInt(byte & 0b1000_0000);
 
 		value |= byteValue << leastSignificantValueBitIndex;
 		leastSignificantValueBitIndex += 7n;
@@ -38,7 +38,7 @@ export const sleb128Parser: Parser<bigint, Uint8Array> = async (parserContext) =
 			continue;
 		}
 
-		const mostSignificantInputBit = byte & 0b01000000;
+		const mostSignificantInputBit = byte & 0b0100_0000;
 
 		if (mostSignificantInputBit) {
 			value |= (~0n << leastSignificantValueBitIndex);
@@ -50,7 +50,7 @@ export const sleb128Parser: Parser<bigint, Uint8Array> = async (parserContext) =
 	return value;
 };
 
-export const uleb128NumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+export const uleb128NumberParser: Parser<number, Uint8Array> = async parserContext => {
 	const value = await uleb128Parser(parserContext);
 
 	parserContext.invariant(
@@ -62,7 +62,7 @@ export const uleb128NumberParser: Parser<number, Uint8Array> = async (parserCont
 	return Number(value);
 };
 
-export const sleb128NumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+export const sleb128NumberParser: Parser<number, Uint8Array> = async parserContext => {
 	const value = await sleb128Parser(parserContext);
 
 	parserContext.invariant(
@@ -74,14 +74,14 @@ export const sleb128NumberParser: Parser<number, Uint8Array> = async (parserCont
 	return Number(value);
 };
 
-export const uleb128UnsafeNumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+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;
+		const byteValue = byte & 0b0111_1111;
+		const byteNotLast = byte & 0b1000_0000;
 
 		value |= byteValue << leastSignificantValueBitIndex;
 
@@ -94,16 +94,16 @@ export const uleb128UnsafeNumberParser: Parser<number, Uint8Array> = async (pars
 	}
 
 	return value;
-}
+};
 
-export const sleb128UnsafeNumberParser: Parser<number, Uint8Array> = async (parserContext) => {
+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;
+		const byteValue = byte & 0b0111_1111;
+		const byteNotLast = byte & 0b1000_0000;
 
 		value |= byteValue << leastSignificantValueBitIndex;
 		leastSignificantValueBitIndex += 7;
@@ -112,7 +112,7 @@ export const sleb128UnsafeNumberParser: Parser<number, Uint8Array> = async (pars
 			continue;
 		}
 
-		const mostSignificantInputBit = byte & 0b01000000;
+		const mostSignificantInputBit = byte & 0b0100_0000;
 
 		if (leastSignificantValueBitIndex < 32 && mostSignificantInputBit) {
 			value |= (~0 << leastSignificantValueBitIndex);

package/src/negativeLookaheadParser.test.ts

@@ -5,7 +5,6 @@ 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',
@@ -17,33 +16,30 @@ testProp(
 			fc.string({
 				minLength: 1,
 			}),
-		).filter(([ a, b ]) => !a.startsWith(b))
+		).filter(([ a, b ]) => !a.startsWith(b)),
 	],
 	async (t, [ stringA, stringB ]) => {
 		const result = await runParser(
 			createTupleParser([
-				createNegativeLookaheadParser(
-					createExactSequenceParser(stringB),
-				),
+				createNegativeLookaheadParser(createExactSequenceParser(stringB)),
 				createExactSequenceParser(stringA + stringB),
 			]),
 			stringA + stringB,
 			stringParserInputCompanion,
 		);
 
-		t.deepEqual(result, [undefined, stringA + stringB]);
+		t.deepEqual(result, [ undefined, stringA + stringB ]);
 
-		await t.throwsAsync(() => runParser(
+		await t.throwsAsync(async () => runParser(
 			createTupleParser([
-				createNegativeLookaheadParser(
-					createExactSequenceParser(stringA),
-				),
+				createNegativeLookaheadParser(createExactSequenceParser(stringA)),
 				createExactSequenceParser(stringA + stringB),
 			]),
 			stringA + stringB,
 			stringParserInputCompanion,
 		), {
-			instanceOf: ParserParsingFailedError,
+			any: true,
+			name: 'ParserParsingInvariantError',
 			message: /lookahead/,
 		});
 	},

package/src/negativeLookaheadParser.ts

@@ -1,5 +1,5 @@
 import { getParserName, setParserName, type Parser } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 
 export const createNegativeLookaheadParser = <Sequence>(
 	childParser: Parser<unknown, Sequence>,
@@ -14,7 +14,7 @@ export const createNegativeLookaheadParser = <Sequence>(
 
 			childParserSuccess = true;
 		} catch (error) {
-			if (!(error instanceof ParserParsingFailedError)) {
+			if (!isParserParsingFailedError(error)) {
 				throw error;
 			}
 

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');
+});

package/src/noStackCaptureOverheadError.ts

@@ -0,0 +1,12 @@
+
+class NoStackCaptureOverheadErrorClass extends Error {}
+
+function NoStackCaptureOverheadErrorConstructor(this: Error, message: string) {
+	this.name = 'NoStackCaptureOverheadError';
+	this.message = message;
+	this.stack = 'This stack is intentionally left blank to avoid capture overhead.';
+}
+
+NoStackCaptureOverheadErrorConstructor.prototype = Object.create(Error.prototype);
+
+export const NoStackCaptureOverheadError = NoStackCaptureOverheadErrorConstructor as unknown as typeof NoStackCaptureOverheadErrorClass

package/src/nonEmptyArrayParser.test.ts

@@ -7,7 +7,8 @@ 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), {
+	await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+		any: true,
 		message: /Expected .* to match at least once/,
 	});
 });
@@ -16,5 +17,5 @@ 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']);
+	t.deepEqual(result, [ '0' ]);
 });

package/src/nonEmptyArrayParser.ts

@@ -1,5 +1,5 @@
 import { getParserName, type Parser, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 
 export const createNonEmptyArrayParser = <ElementOutput, Sequence>(
 	elementParser: Parser<ElementOutput, Sequence>,
@@ -19,7 +19,7 @@ export const createNonEmptyArrayParser = <ElementOutput, Sequence>(
 				elements.push(element);
 				elementParserContext.unlookahead();
 			} catch (error) {
-				if (error instanceof ParserParsingFailedError) {
+				if (isParserParsingFailedError(error)) {
 					break;
 				}
 

package/src/optionalParser.ts

@@ -1,5 +1,5 @@
 import { getParserName, type Parser, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 
 export const createOptionalParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
@@ -12,7 +12,7 @@ export const createOptionalParser = <Output, Sequence>(
 			childParserContext.unlookahead();
 			return value;
 		} catch (error) {
-			if (error instanceof ParserParsingFailedError) {
+			if (isParserParsingFailedError(error)) {
 				return undefined;
 			}