@futpib/parser 1.0.0 → 1.0.2

package/src/javaKeyStoreParser.ts

@@ -0,0 +1,136 @@
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { type Parser, setParserName } from './parser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createQuantifierParser } from './quantifierParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createUnionParser } from './unionParser.js';
+
+// https://github.com/openjdk/jdk/blob/c517ffba7d9388e75b5d7bba77e565e71c0a7d76/src/java.base/share/classes/com/sun/crypto/provider/JceKeyStore.java#L512-L553
+
+const uint64BEParser: Parser<bigint, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser(8),
+	array => Buffer.from(array).readBigUInt64BE(),
+);
+
+setParserName(uint64BEParser, 'uint64BEParser');
+
+const uint32BEParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser(4),
+	array => Buffer.from(array).readUInt32BE(),
+);
+
+setParserName(uint32BEParser, 'uint32BEParser');
+
+const uint16BEParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser(2),
+	array => Buffer.from(array).readUInt16BE(),
+);
+
+setParserName(uint16BEParser, 'uint16BEParser');
+
+const createUint32BECountPrefixedParser = <T>(elementParser: Parser<T, Uint8Array>): Parser<T[], Uint8Array> => parserCreatorCompose(
+	() => uint32BEParser,
+	count => createQuantifierParser(elementParser, count),
+)();
+
+const javaModifiedUTF8StringParser: Parser<string, Uint8Array> = promiseCompose(
+	parserCreatorCompose(
+		() => uint16BEParser,
+		length => createFixedLengthSequenceParser(length),
+	)(),
+	uint8Array => Buffer.from(uint8Array).toString('utf8'), // TODO?: Java Modified UTF-8 decoding
+);
+
+const uint32LengthPrefixedUint8ArrayParser = parserCreatorCompose(
+	() => uint32BEParser,
+	length => createFixedLengthSequenceParser(length),
+)();
+
+const javaKeyStoreImplementationParser: Parser<'JKS' | 'JCEKS', Uint8Array> = promiseCompose(
+	createUnionParser<Uint8Array, Uint8Array>([
+		createExactSequenceParser<Uint8Array>(Buffer.from('feedfeed', 'hex')),
+		createExactSequenceParser<Uint8Array>(Buffer.from('cececece', 'hex')),
+	]),
+	uint8Array => uint8Array[0] === 0xFE ? 'JKS' : 'JCEKS',
+);
+
+const javaKeyStorePrivateKeyEntryPrivateKeyParser = uint32LengthPrefixedUint8ArrayParser;
+
+const javaKeyStorePrivateKeyEntryCertificateParser = promiseCompose(
+	createTupleParser([
+		javaModifiedUTF8StringParser,
+		uint32LengthPrefixedUint8ArrayParser,
+	]),
+	([ type, certificate ]) => ({ type, certificate }),
+);
+
+const javaKeyStorePrivateKeyEntryCertificateChainParser = createUint32BECountPrefixedParser(
+	javaKeyStorePrivateKeyEntryCertificateParser,
+);
+
+const javaKeyStorePrivateKeyEntryParser = promiseCompose(
+	createTupleParser([
+		createExactSequenceParser<Uint8Array>(Buffer.from('00000001', 'hex')),
+		javaModifiedUTF8StringParser,
+		uint64BEParser,
+		javaKeyStorePrivateKeyEntryPrivateKeyParser,
+		javaKeyStorePrivateKeyEntryCertificateChainParser,
+	]),
+	([
+		_tag,
+		alias,
+		creationDate,
+		privateKey,
+		certificateChain,
+	]) => ({
+		type: 'privateKey',
+		alias,
+		creationDate: new Date(Number(creationDate)),
+		privateKey,
+		certificateChain,
+	}),
+);
+
+const javaKeyStoreTrustedCertEntryParser = createTupleParser([
+	createExactSequenceParser<Uint8Array>(Buffer.from('00000002', 'hex')),
+	async parserContext => parserContext.invariant(false, 'Not implemented'),
+]);
+
+const javaKeyStoreSecretKeyEntryParser = createTupleParser([
+	createExactSequenceParser<Uint8Array>(Buffer.from('00000003', 'hex')),
+	async parserContext => parserContext.invariant(false, 'Not implemented'),
+]);
+
+const javaKeyStoreEntryParser = createUnionParser([
+	javaKeyStorePrivateKeyEntryParser,
+	javaKeyStoreTrustedCertEntryParser,
+	javaKeyStoreSecretKeyEntryParser,
+]);
+
+const javaKeyStoreEntriesParser = createUint32BECountPrefixedParser(
+	javaKeyStoreEntryParser,
+);
+
+const javaKeyStoreParser_ = createTupleParser([
+	javaKeyStoreImplementationParser,
+	uint32BEParser,
+	javaKeyStoreEntriesParser,
+	createFixedLengthSequenceParser(20),
+]);
+
+export const javaKeyStoreParser: Parser<unknown, Uint8Array> = promiseCompose(
+	javaKeyStoreParser_,
+	([
+		implementation,
+		version,
+		entries,
+		hash,
+	]) => ({
+		implementation,
+		version,
+		entries,
+		hash,
+	}),
+);

package/src/jsonParser.test.ts

@@ -2,7 +2,7 @@ import { testProp, fc } from '@fast-check/ava';
 import { jsonValueParser } from './jsonParser.js';
 import { runParser } from './parser.js';
 import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 
 testProp(
 	'json',
@@ -13,7 +13,7 @@ testProp(
 		),
 	],
 	async (t, [ jsonString, jsonStringChunkIterator ]) => {
-		const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringInputCompanion, {
+		const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringParserInputCompanion, {
 			errorJoinMode: 'none',
 		});
 		const expected = JSON.parse(jsonString);

package/src/jsonParser.ts

@@ -13,6 +13,7 @@ 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([
@@ -65,7 +66,7 @@ const jsonStringCharacterParser: Parser<string, string> = createDisjunctionParse
 	)(),
 ]);
 
-const jsonStringParser: Parser<string, string> = promiseCompose(
+export const jsonStringParser: Parser<string, string> = promiseCompose(
 	createTupleParser([
 		createExactSequenceParser('"'),
 		promiseCompose(
@@ -79,11 +80,11 @@ const jsonStringParser: Parser<string, string> = promiseCompose(
 	([ , string ]) => string,
 );
 
-const jsonNumberParser: Parser<number, string> = parserCreatorCompose(
+export const jsonNumberParser: Parser<number, string> = parserCreatorCompose(
 	() => createArrayParser(
 		parserCreatorCompose(
 			() => elementParser,
-			(character) => async parserContext => {
+			character => async parserContext => {
 				parserContext.invariant(
 					(
 						character === '-'
@@ -101,7 +102,7 @@ const jsonNumberParser: Parser<number, string> = parserCreatorCompose(
 			},
 		)(),
 	),
-	(characters) => async parserContext => {
+	characters => async parserContext => {
 		parserContext.invariant(characters.length > 0, 'Expected at least one character');
 
 		return Number(characters.join(''));
@@ -116,6 +117,7 @@ const jsonFalseParser: Parser<false, string> = promiseCompose(createExactSequenc
 
 setParserName(jsonFalseParser, 'jsonFalseParser');
 
+// eslint-disable-next-line @typescript-eslint/ban-types
 const jsonNullParser: Parser<null, string> = promiseCompose(createExactSequenceParser('null'), () => null);
 
 setParserName(jsonNullParser, 'jsonNullParser');
@@ -138,7 +140,7 @@ const jsonObjectEntryParser: Parser<[string, JsonValue], string> = promiseCompos
 		whitespaceParser,
 		createParserAccessorParser(() => jsonValueParser),
 	]),
-	([key, _whitespace1, _colon, _whitespace2, value]) => [key, value],
+	([ key, _whitespace1, _colon, _whitespace2, value ]) => [ key, value ],
 );
 
 const jsonObjectParser: Parser<JsonObject, string> = promiseCompose(
@@ -155,25 +157,25 @@ const jsonObjectParser: Parser<JsonObject, string> = promiseCompose(
 							createExactSequenceParser(','),
 							whitespaceParser,
 						]),
-						([entry]) => entry,
+						([ entry ]) => entry,
 					),
 					promiseCompose(
 						createTupleParser([
 							createParserAccessorParser(() => jsonObjectEntryParser),
 							whitespaceParser,
 						]),
-						([value]) => value,
+						([ value ]) => value,
 					),
 				]),
 				createExactSequenceParser('}'),
 			),
-			([entries]) => entries,
+			([ entries ]) => entries,
 		),
 	]),
-	([ _brace, _whitespace, entries]) => {
+	([ _brace, _whitespace, entries ]) => {
 		const object: Writable<JsonObject> = {};
 
-		for (const [key, value] of entries) {
+		for (const [ key, value ] of entries) {
 			Object.defineProperty(object, key, {
 				value,
 				enumerable: true,
@@ -188,32 +190,19 @@ 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,
+	([ _bracket, _whitespace, values ]) => values,
 );
 
 export const jsonValueParser: Parser<JsonValue, string> = createUnionParser([

package/src/leb128Parser.test.ts

@@ -0,0 +1,171 @@
+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, 16256n ],
+	] 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 ]), 12857n ],
+	] 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(() => 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(() => 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 { 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/listParser.ts

@@ -1,9 +1,9 @@
-import { createNegativeLookaheadParser } from "./negativeLookahead.js";
-import { Parser } from "./parser.js";
-import { createParserAccessorParser } from "./parserAccessorParser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createTupleParser } from "./tupleParser.js";
-import { createUnionParser } from "./unionParser.js";
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { type Parser } from './parser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createUnionParser } from './unionParser.js';
 
 class Nil {}
 class Cons<Head, Tail> {

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