@futpib/parser 1.0.0 → 1.0.1

package/src/arrayParser.test.ts

@@ -1,11 +1,11 @@
 import test from 'ava';
 import { createArrayParser } from './arrayParser.js';
-import { Parser, runParser } from './parser.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { type Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 
 test('does not loop forever with a child parser that does not consume anything', async t => {
 	const parser: Parser<undefined[], string> = createArrayParser(async () => undefined);
-	const result = await runParser(parser, 'foo', stringInputCompanion);
+	const result = await runParser(parser, 'foo', stringParserInputCompanion);
 
 	t.deepEqual(result, []);
 });

package/src/arrayParser.ts

@@ -1,5 +1,5 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
 
 export const createArrayParser = <ElementOutput, Sequence>(
 	elementParser: Parser<ElementOutput, Sequence>,
@@ -15,6 +15,7 @@ export const createArrayParser = <ElementOutput, Sequence>(
 				if (elementParserContext.position === initialPosition) {
 					return elements;
 				}
+
 				elements.push(element);
 				elementParserContext.unlookahead();
 			} catch (error) {

package/src/arrayUnparser.ts

@@ -0,0 +1,13 @@
+import { Unparser } from "./unparser.js";
+
+export const createArrayUnparser = <ElementInput, Sequence>(
+	elementUnparser: Unparser<ElementInput, Sequence>,
+): Unparser<ElementInput[], Sequence> => {
+	const arrayUnparser: Unparser<ElementInput[], Sequence> = async function * (input, unparserContext) {
+		for (const element of input) {
+			yield * elementUnparser(element, unparserContext);
+		}
+	};
+
+	return arrayUnparser;
+}

package/src/bsonParser.test.ts

@@ -3,7 +3,7 @@ import { BSON } from 'bson';
 import { bsonDocumentParser } from './bsonParser.js';
 import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
 import { runParser } from './parser.js';
-import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 
 testProp(
 	'bson',
@@ -27,7 +27,7 @@ testProp(
 	async (t, [ bsonUint8Array, bsonUint8ArrayChunkIterator ]) => {
 		const expected = BSON.deserialize(bsonUint8Array);
 
-		const actual = await runParser(bsonDocumentParser, bsonUint8ArrayChunkIterator, uint8ArrayInputCompanion);
+		const actual = await runParser(bsonDocumentParser, bsonUint8ArrayChunkIterator, uint8ArrayParserInputCompanion);
 
 		t.deepEqual(actual, expected);
 	},

package/src/bsonParser.ts

@@ -30,7 +30,7 @@ const cstringParser: Parser<string, Uint8Array> = promiseCompose(
 		)(),
 		nullByteParser,
 	),
-	([sequence]) => Buffer.from(sequence).toString('utf8'),
+	([ sequence ]) => Buffer.from(sequence).toString('utf8'),
 );
 
 const doubleParser: Parser<number, Uint8Array> = promiseCompose(buffer8Parser, buffer => buffer.readDoubleLE(0));
@@ -47,7 +47,7 @@ const createFixedLengthNullTerminatedStringParser = (lengthWihoutNullTerminator:
 		createFixedLengthStringParser(lengthWihoutNullTerminator),
 		nullByteParser,
 	]),
-	([string]) => string,
+	([ string ]) => string,
 );
 
 const bsonStringParser: Parser<string, Uint8Array> = async parserContext => {
@@ -119,7 +119,7 @@ const bsonElementListParser: Parser<Array<[ string, JsonValue ]>, Uint8Array> =
 		bsonElementParser,
 		nullByteParser,
 	),
-	([elements]) => elements,
+	([ elements ]) => elements,
 );
 
 export const bsonDocumentParser: Parser<JsonObject, Uint8Array> = promiseCompose(

package/src/{parserInvariant.ts → customInvariant.ts}

@@ -4,7 +4,7 @@ export type Falsy = '' | 0 | false | undefined;
 
 export type ValueOrAccessor<T> = T | (() => T);
 
-export function parserInvariant<T>(
+export function customInvariant<T>(
 	ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error),
 	value: T,
 	formatOrFormatLines: ValueOrAccessor<string | string[]>,

package/src/debugLogParser.ts

@@ -1,4 +1,4 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
 
 export const createDebugLogParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,

package/src/elementParser.ts

@@ -1,4 +1,4 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
-export const createElementParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(): Parser<Element, Sequence, Element> => parserContext => parserContext.read(0);
+export const createElementParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(): Parser<Element, Sequence, Element> => async parserContext => parserContext.read(0);

package/src/endOfInputParser.ts

@@ -1,11 +1,11 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export const createEndOfInputParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(): Parser<void, Sequence, Element> => async parserContext => {
 	parserContext.invariant(
 		await parserContext.peek(0) === undefined,
-		'Expected end of input.'
+		'Expected end of input.',
 	);
-}
+};
 
 export const endOfInputParser = createEndOfInputParser<any, any>();

package/src/exactElementParser.ts

@@ -1,5 +1,5 @@
 import { type Parser } from './parser.js';
-import { DeriveSequenceElement } from './sequence.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export const createExactElementParser = <
 	Sequence,

package/src/exactSequenceParser.ts

@@ -1,4 +1,4 @@
-import { inspect } from 'util';
+import { inspect } from 'node:util';
 import { setParserName, type Parser } from './parser.js';
 
 export const createExactSequenceParser = <Sequence>(sequence: Sequence) => {
@@ -24,4 +24,4 @@ export const createExactSequenceParser = <Sequence>(sequence: Sequence) => {
 	setParserName(exactSequenceParser, inspect(sequence));
 
 	return exactSequenceParser;
-}
+};

package/src/index.ts

@@ -1,13 +1,13 @@
 
 export {
-	Parser,
+	type Parser,
 	runParser,
 
 	setParserName,
 	getParserName,
 } from './parser.js';
 
-export {
+export type {
 	ParserContext,
 } from './parserContext.js';
 
@@ -74,3 +74,16 @@ export {
 export {
 	createDebugLogParser,
 } from './debugLogParser.js';
+
+export {
+	type Unparser,
+	runUnparser,
+} from './unparser.js';
+
+export {
+	createArrayUnparser,
+} from './arrayUnparser.js';
+
+export {
+	createSequenceUnparser,
+} from './sequenceUnparser.js';

package/src/inputReader.test.ts

@@ -1,10 +1,10 @@
 import test from 'ava';
 import { InputReaderImplementation } from './inputReader.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { ParserImplementationError } from './parserError.js';
 
 test('inputReader', async t => {
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield '';
 		yield 'abc';
 		yield 'def';
@@ -47,7 +47,7 @@ test('inputReader', async t => {
 });
 
 test('inputReader.peek concurrent', async t => {
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})());
 
@@ -69,7 +69,7 @@ test('inputReader.peek concurrent', async t => {
 });
 
 test('inputReader skip while peeking', async t => {
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
 	})());
 
@@ -84,7 +84,7 @@ test('inputReader skip while peeking', async t => {
 test('inputReader.lookahead', async t => {
 	let read = 0;
 
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		for (const character of 'abcdefgh') {
 			read++;
 			yield character;
@@ -180,7 +180,7 @@ test('inputReader.lookahead', async t => {
 test('inputReader.lookahead concurrent', async t => {
 	let read = 0;
 
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		for (const character of 'abcdefgh') {
 			read++;
 			yield character;
@@ -211,7 +211,7 @@ test('inputReader.lookahead concurrent', async t => {
 test('inputReader.lookahead skip position', async t => {
 	let read = 0;
 
-	const inputReader = new InputReaderImplementation(stringInputCompanion, (async function * () {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		for (const character of 'abcdefgh') {
 			read++;
 			yield character;

package/src/inputReader.ts

@@ -1,7 +1,7 @@
 import PromiseMutex from 'p-mutex';
 import invariant from 'invariant';
 import { type SequenceBuffer, SequenceBufferImplementation } from './sequenceBuffer.js';
-import { type InputCompanion } from './inputCompanion.js';
+import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
 export type InputReader<Sequence, Element> = {
@@ -26,10 +26,10 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 	private readonly _sequenceBuffer: SequenceBuffer<Sequence, Element>;
 
 	constructor(
-		private readonly _inputCompanion: InputCompanion<Sequence, Element>,
+		private readonly _parserInputCompanion: ParserInputCompanion<Sequence, Element>,
 		private readonly _inputAsyncIterator: AsyncIterator<Sequence>,
 	) {
-		this._sequenceBuffer = new SequenceBufferImplementation<Sequence, Element>(this._inputCompanion);
+		this._sequenceBuffer = new SequenceBufferImplementation<Sequence, Element>(this._parserInputCompanion);
 	}
 
 	get [Symbol.toStringTag]() {
@@ -70,14 +70,14 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 				}
 
 				parserImplementationInvariant(
-					this._inputCompanion.is(inputIteratorResult.value),
+					this._parserInputCompanion.is(inputIteratorResult.value),
 					[
 						'Input iterator result value (%s) is of unexpected type.',
 						'Expected a sequence (a chunk of input) recognized by the input companion (%s).',
 						'You may have provided a wrong input companion for the input.',
 					],
 					inputIteratorResult.value,
-					this._inputCompanion.constructor.name,
+					this._parserInputCompanion.constructor.name,
 				);
 
 				this._sequenceBuffer.push(inputIteratorResult.value);

package/src/javaKeyStoreParser.test.ts

@@ -0,0 +1,23 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { javaKeyStoreParser } from './javaKeyStoreParser.js';
+
+for (const javaKeyStoreCid of [
+	'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4',
+]) {
+	test(
+		'javaKeyStore ' + javaKeyStoreCid,
+		async t => {
+			const javaKeyStoreResponse = await fetch('https://ipfs.io/ipfs/' + javaKeyStoreCid);
+
+			const javaKeyStoreStream = javaKeyStoreResponse.body!;
+
+			const actual = await runParser(javaKeyStoreParser, javaKeyStoreStream, uint8ArrayParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			t.snapshot(actual);
+		},
+	);
+}

package/src/javaKeyStoreParser.test.ts.md

@@ -0,0 +1,103 @@
+# Snapshot report for `src/javaKeyStoreParser.test.ts`
+
+The actual snapshot is saved in `javaKeyStoreParser.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## javaKeyStore bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4
+
+> Snapshot 1
+
+    {
+      entries: [
+        {
+          alias: 'alias_name',
+          certificateChain: [
+            {
+              certificate: Uint8Array [
+                3082037d 30820265 a0030201 02020862 1867f6fc b0aab430 0d06092a 864886f7
+                0d01010b 0500306c 3110300e 06035504 06130755 6e6b6e6f 776e3110 300e0603
+                55040813 07556e6b 6e6f776e 3110300e 06035504 07130755 6e6b6e6f 776e3110
+                300e0603 55040a13 07556e6b 6e6f776e 3110300e 06035504 0b130755 6e6b6e6f
+                776e3110 300e0603 55040313 07556e6b 6e6f776e 3020170d 32343132 30383133
+                33343232 5a180f32 30353230 34323531 33333432 325a306c 3110300e 06035504
+                06130755 6e6b6e6f 776e3110 300e0603 55040813 07556e6b 6e6f776e 3110300e
+                06035504 07130755 6e6b6e6f 776e3110 300e0603 55040a13 07556e6b 6e6f776e
+                3110300e 06035504 0b130755 6e6b6e6f 776e3110 300e0603 55040313 07556e6b
+                6e6f776e 30820122 300d0609 2a864886 f70d0101 01050003 82010f00 3082010a
+                02820101 00c4d6d9 6e38ae16 54e1f3a6 d7b68d49 23a01024 ded06818 5e88835e
+                2edf5cdc 1839f148 864f20fc 355655a5 f1023e4f 6fced37e 0a55d77c d206c4f4
+                e6a7041e d16a439a 38bd824e 29e4d407 16a4a154 3e952838 79b5c1e6 1e376927
+                9ed92d62 c94bfd06 261b3034 1c5420c7 ca6d7925 8deafdb3 252ada5f 2a571b11
+                fb265869 d2c9335b ca9d2c06 5ce9586c 006b371b c555c122 d734be38 e57486b5
+                ccad06c2 b532dd4f 1a025e04 2bdea06a 1056367c 92b2db6e 9c8f6353 1d4d28fd
+                d6d78a45 9fcb5ada 16a9988b 032d6c69 6d63f739 9d5664b8 c0adf5a2 f748e177
+                e019a4a3 23a7fd10 dcd2be1b 6b8cbdcf eb7e76cd f35698a1 2c77b508 0d1a7884
+                ce8f1980 2f020301 0001a321 301f301d 0603551d 0e041604 14fdef9a ebf342b2
+                3bb007b1 6de4e2a8 0e953421 d4300d06 092a8648 86f70d01 010b0500 03820101
+                00c12e4e 03282b2f 36ee57a6 144d1774 55e08149 ce8e5b46 5f340757 7b301880
+                f3e7c4bd 564c5aa6 5202100e b819ae3a fb8c4adf c9e13cdc 82fdab8d c3cab7d7
+                68f01c41 18f67b0b 534eeb5c ab7ebeec af4cadd2 df3efe7c c4ec9311 9c3ec17e
+                3152746f 39d99717 042557f9 eb8aa2fa e87eb332 833c75db 1d373e50 2ea3b3ef
+                9bb847c0 8190fda7 318a0cac 374b507c 5db948e4 65c9ae38 4b304b8d d5c62014
+                ad01857b 5548dec0 b4c5b61f 0b21597a ede13707 e701dc44 933bb097 832e5158
+                2d19c606 a2b540ec bb501ffc 5d772e08 44e57a7f eb026278 c69e6160 8cddc2df
+                b56418b6 1cea3698 f86fa91d c7bd9e4b 83e80666 d343b087 7a0117a2 f8773fcc
+                31
+              ],
+              type: 'X.509',
+            },
+          ],
+          creationDate: Date 2024-12-08 13:34:25 771ms UTC {},
+          privateKey: Uint8Array [
+            308204fd 300e060a 2b060104 012a0211 01010500 048204e9 6bafd40a 4a5b9ba7
+            d71d60e8 3f9d1d2b e8f1a677 d30c00f9 8c27a431 cf19c6cf 01527d3c 23490657
+            9d30ee44 6f2a1c3d 8785c9e9 20cb403c 9c06bb6a 83eafd69 8a3e2a43 4a2340b1
+            873bf5d7 766a4003 935463f8 5894dd90 79c940b8 d7b908e9 5dc7b7e8 e01a9f55
+            7c31b465 cdf2b4e5 322f547c 74e28695 e49aff82 96144608 4e139e96 915022da
+            106a61b2 cda01a71 dd195aa2 d3db85e0 8d5e52b6 649e358e 38cc2b63 a95496e7
+            f13b35da a3812622 b6a8ca99 e25baf66 70cf30b6 3097794a 14385807 7f2ffd85
+            cd6c8ef9 4c87cd48 46cca8c1 9dc4c73e a62d6f0a 7fc8054f 1408c9b6 f7dd750b
+            595b6c60 2766bd8c db986cda 16829b4f a06f274f 5d540aac 814e5a50 9127bed4
+            a48dd702 f613b823 9218a9d0 344ba799 99e2caf2 8f9c976a 9db0fc39 d0d1c0a4
+            0338e5c2 03632ffb 5e58200a 3921a5bd 1516e598 f6e912aa 0f08129a f082088f
+            17165118 39fabef3 b6c93d25 1c35c8a5 b533546a 72e3dcb8 827b77b3 01b0bd60
+            a54ecae6 e37ab488 97ca7f26 014fe9f5 8b35c81e 5e201f05 43226ff7 fa41e019
+            3ed3f47a 92167c6c a691814d 4883471e 4ffdd7e5 66e32235 dfcbe212 99ef4559
+            d2b6fc5c 26e23964 e4c0ccf2 9ef4a0c1 9078ef4f 04ec1a8c 91916f0b 85bd18eb
+            1abe756c 9a90da9d 1293f95a db7edbc9 eb0aecd1 85ee554f 832dbb01 21dfacbf
+            12be629e 5b33e3b5 f3ebdcd1 69bc40b5 67607be4 d38e6a22 f8b520ab 6d498d23
+            a7af72f0 9a57690d c11113f8 744b77e2 b45b52a5 19e5cffe 3e19e106 ae2454d7
+            9741d01b 8cfbc4c0 16efaf4e d8ab96b3 bf04b7e1 81099b5f dcac9158 0636a33a
+            2ce348ba ddaeef30 0bb27d8a d762f9b1 0a87c57c 0787667f e7542cbb 4077ade1
+            c2784b03 fa590107 deaea210 59920506 472a5983 fdc7706e e99ec034 55b17fe8
+            8f8ed3a1 d43bde6e a392bbdd bdb81ff5 b6ad03de 8a46a97f 278f697a b0669db4
+            967ef9b8 7bca57f4 8507d655 5f77bce4 901010bc cf69106a 407481b0 efe8f5df
+            137aea5c cc6e1777 364809dd f39e2c80 437e11d4 692488ee 9760f10a 4b3078be
+            3f6b363d 25ccd315 4caee2d7 f29e44c9 3bb899fe 141e4233 b44a4dd8 6a7a3ab3
+            2ab7ecae 4c91bab1 a7223e88 d831ee3a 24fbca73 712dcd8c 22a22ea6 f74d52ff
+            52df9e06 c42e57cb 6e615094 52a6489a c985d992 38ed1861 f9c668d6 bedfa6b7
+            83f8f03f 66425389 fea1fd10 0cd78635 999194c9 54ea2233 99c8a384 7e034fe2
+            6be1e2b1 652ccb10 59c23b48 a34a4732 47b61a90 baa39965 db02b59d e5258a5e
+            6bd44e7b 46023f60 417c9a26 98d9435d cfed43cc c3235627 c4bc7589 bbbf520f
+            16480c66 8a355d3f aa4693db 499051be b85350d4 c45eb43f 7f09461c 882a4168
+            69135d31 db14dd3d bd49b28f 810f6cfc 70759172 66b79b43 951e020d 69bdb933
+            01f722f2 d77be629 8d0027be 96373dc2 e862792c 20894f6b ed8ec5ca 2b99fea5
+            4d37e8ca 01422458 025833bc 9bb4a8c8 491dee69 c8bb6b42 9eaa6bca 770b5a4d
+            95e9931e 12cffaa0 54566c76 7c323b6f f6f60e97 1e5c54fe eefa57f7 e6f6b352
+            d8f0f43e dc9b224a c7678d6b 35532593 6c1aac3b 4ae05907 4c70bb40 07373e8c
+            97126047 b3b23ae5 41e15db1 d251d5c5 e9a2dc51 6863ec2b ed2ad0b9 54d4ecc1
+            f184cba3 7e588d99 6be6caf1 72ba9771 650d92a7 3402ed51 4972e38e fb20b53e
+            1442e461 49054fc6 f6899e65 b02c968f 97884dd1 1e5b1bd6 d394ff8d a5155836
+            53d72788 e5de5454 5bbebefb 71b35c5d d63f9a1e 938210a8 d8f7e536 12494c5b
+            e5
+          ],
+          type: 'privateKey',
+        },
+      ],
+      hash: Uint8Array [
+        9bbf5a41 f2b3fcd4 a9ac77fe 0820317e 6a8f05e9
+      ],
+      implementation: 'JKS',
+      version: 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

@@ -83,7 +83,7 @@ const jsonNumberParser: Parser<number, string> = parserCreatorCompose(
 	() => createArrayParser(
 		parserCreatorCompose(
 			() => elementParser,
-			(character) => async parserContext => {
+			character => async parserContext => {
 				parserContext.invariant(
 					(
 						character === '-'
@@ -101,7 +101,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 +116,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 +139,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 +156,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,
@@ -198,22 +199,22 @@ const jsonArrayParser: Parser<JsonArray, string> = promiseCompose(
 							createExactSequenceParser(','),
 							whitespaceParser,
 						]),
-						([value]) => value,
+						([ value ]) => value,
 					),
 					promiseCompose(
 						createTupleParser([
 							createParserAccessorParser(() => jsonValueParser),
 							whitespaceParser,
 						]),
-						([value]) => value,
+						([ value ]) => value,
 					),
 				]),
 				createExactSequenceParser(']'),
 			),
-			([values]) => values,
+			([ values ]) => values,
 		),
 	]),
-	([_bracket, _whitespace, values]) => values,
+	([ _bracket, _whitespace, values ]) => values,
 );
 
 export const jsonValueParser: Parser<JsonValue, string> = createUnionParser([