@futpib/parser 1.0.1 → 1.0.3

package/src/fixedLengthSequenceParser.test.ts

@@ -0,0 +1,75 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createFixedLengthSequenceParser, createFixedLengthSequenceParserNaive } from './fixedLengthSequenceParser.js';
+import { type Parser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { arbitrarilySlicedAsyncIterable } from './arbitrarilySlicedAsyncInterable.js';
+
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const totalTimer = new HighResolutionTotalTimer();
+
+testProp.serial(
+	'fixedLengthSequenceParser',
+	[
+		fc
+			.bigInt({
+				min: 1n,
+				max: 2n ** 14n,
+			})
+			.chain(length => fc.tuple(
+				arbitrarilySlicedAsyncIterable(fc.string({
+					minLength: Number(length),
+					maxLength: Number(length) * 2,
+				})),
+				fc.constant(length),
+			)),
+	],
+	async (t, [ [ _, sequence ], length ]) => {
+		const fixedLengthSequenceParserNaive = createFixedLengthSequenceParserNaive<string>(length);
+		const fixedLengthSequenceParser = createFixedLengthSequenceParser<string>(length);
+
+		const createTestWrapperParser = (innerParser: typeof fixedLengthSequenceParser): Parser<{
+			result: string;
+			position: number;
+		}, string> => async parserContext => {
+			const result = await innerParser(parserContext);
+
+			return {
+				result,
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const { output: actualNaive } = await naiveTotalTimer.measureAsync(async () => runParserWithRemainingInput(
+			createTestWrapperParser(fixedLengthSequenceParserNaive),
+			sequence,
+			stringParserInputCompanion,
+		));
+
+		t.true(actualNaive.result.length === Number(length));
+
+		const { output: actual } = await totalTimer.measureAsync(async () => runParserWithRemainingInput(
+			createTestWrapperParser(fixedLengthSequenceParser),
+			sequence,
+			stringParserInputCompanion,
+		));
+
+		t.deepEqual(actual, actualNaive);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test.serial(
+	'fixedLengthSequenceParser performance',
+	t => {
+		t.true(
+			totalTimer.time * 10n < naiveTotalTimer.time,
+			`Naive: ${naiveTotalTimer.time / 1_000_000n}ms, Optimized: ${totalTimer.time / 1_000_000n}ms`,
+		);
+	},
+);

package/src/fixedLengthSequenceParser.ts

@@ -1,7 +1,7 @@
 import { setParserName, type Parser } from './parser.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
-export const createFixedLengthSequenceParser = <Sequence>(lengthInput: bigint | number) => {
+export const createFixedLengthSequenceParserNaive = <Sequence>(lengthInput: bigint | number) => {
 	const length = BigInt(lengthInput);
 
 	parserImplementationInvariant(length >= 0n, 'Length must be non-negative got %s.', length);
@@ -22,3 +22,30 @@ export const createFixedLengthSequenceParser = <Sequence>(lengthInput: bigint |
 
 	return fixedLengthSequenceParser;
 };
+
+const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+
+export const createFixedLengthSequenceParser = <Sequence>(lengthInput: bigint | number) => {
+	const length = BigInt(lengthInput);
+
+	parserImplementationInvariant(length >= 0n, 'Length must be non-negative got %s.', length);
+
+	const fixedLengthSequenceParser: Parser<Sequence, Sequence, unknown> = async parserContext => {
+		const safeIntegerSequences: Sequence[] = [];
+		let remainingLength = length;
+
+		while (remainingLength > 0n) {
+			const safeIntegerLength = length > MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(length);
+
+			safeIntegerSequences.push(await parserContext.readSequence(0, safeIntegerLength));
+
+			remainingLength -= BigInt(safeIntegerLength);
+		}
+
+		return parserContext.concat(safeIntegerSequences);
+	};
+
+	setParserName(fixedLengthSequenceParser, `.{${length}}`);
+
+	return fixedLengthSequenceParser;
+};

package/src/hasExecutable.ts

@@ -0,0 +1,11 @@
+import { execa } from 'execa';
+
+export async function hasExecutable(executable: string) {
+	const hasExecutable = execa(executable).catch(() => false).then(() => true);
+
+	if (!hasExecutable) {
+		console.warn('Executable %o not found', executable);
+	}
+
+	return hasExecutable;
+}

package/src/highResolutionTimer.ts

@@ -0,0 +1,49 @@
+import process from 'node:process';
+import invariant from 'invariant';
+
+class HighResolutionSubTimer {
+	private _ended = false;
+
+	constructor(
+		private readonly _parent: HighResolutionTotalTimer,
+		private readonly _start: bigint,
+	) {}
+
+	end() {
+		invariant(!this._ended, 'Timer already ended.');
+		const end = process.hrtime.bigint();
+		const time = end - this._start;
+		this._parent.add(time);
+		this._ended = true;
+	}
+}
+
+export class HighResolutionTotalTimer {
+	private _total = 0n;
+
+	start(): HighResolutionSubTimer {
+		return new HighResolutionSubTimer(this, process.hrtime.bigint());
+	}
+
+	add(time: bigint) {
+		this._total += time;
+	}
+
+	get time() {
+		return this._total;
+	}
+
+	measure<T>(fn: () => T): T {
+		const timer = this.start();
+		const result = fn();
+		timer.end();
+		return result;
+	}
+
+	async measureAsync<T>(fn: () => Promise<T>): Promise<T> {
+		const timer = this.start();
+		const result = await fn();
+		timer.end();
+		return result;
+	}
+}

package/src/inputReader.test.ts

@@ -1,7 +1,8 @@
 import test from 'ava';
 import { InputReaderImplementation } from './inputReader.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
-import { ParserImplementationError } from './parserError.js';
+import { toAsyncIterable } from './toAsyncIterable.js';
+import { type InputReaderState } from './inputReaderState.js';
 
 test('inputReader', async t => {
 	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
@@ -46,6 +47,53 @@ test('inputReader', async t => {
 	t.is(await inputReader.peek(0), undefined);
 });
 
+test('inputReader peekSequence', async t => {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+		yield '';
+		yield 'abc';
+		yield 'def';
+		yield '';
+		yield 'gh';
+	})());
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), 'a');
+
+	inputReader.skip(0);
+
+	t.is(await inputReader.peekSequence(1, 2), 'b');
+
+	inputReader.skip(1);
+
+	t.is(await inputReader.peekSequence(1, 7), 'bcdefgh'.slice(1, 7));
+	t.is(await inputReader.peekSequence(1, 8), undefined);
+
+	inputReader.skip(6);
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), 'h');
+	t.is(await inputReader.peekSequence(1, 2), undefined);
+	t.is(await inputReader.peekSequence(2, 2), undefined);
+
+	inputReader.skip(1);
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), undefined);
+	t.is(await inputReader.peekSequence(1, 1), undefined);
+
+	inputReader.skip(0);
+
+	t.is(await inputReader.peekSequence(0, 0), '');
+	t.is(await inputReader.peekSequence(0, 1), undefined);
+	t.is(await inputReader.peekSequence(1, 1), undefined);
+
+	inputReader.skip(1);
+
+	t.is(await inputReader.peekSequence(0, 0), undefined);
+	t.is(await inputReader.peekSequence(0, 1), undefined);
+	t.is(await inputReader.peekSequence(1, 1), undefined);
+});
+
 test('inputReader.peek concurrent', async t => {
 	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
@@ -68,6 +116,64 @@ test('inputReader.peek concurrent', async t => {
 	t.deepEqual(peeks, [ 'a', 'a', 'a', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' ]);
 });
 
+test('inputReader.peekSequence concurrent', async t => {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+		yield * 'abcdefgh';
+	})());
+
+	const peeks = await Promise.all([ 1, 2, 3 ].flatMap(length => [
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(0, 0 + length),
+		inputReader.peekSequence(1, 1 + length),
+		inputReader.peekSequence(2, 2 + length),
+		inputReader.peekSequence(3, 3 + length),
+		inputReader.peekSequence(4, 4 + length),
+		inputReader.peekSequence(5, 5 + length),
+		inputReader.peekSequence(6, 6 + length),
+		inputReader.peekSequence(7, 7 + length),
+	]));
+
+	t.deepEqual(peeks, [
+		'a',
+		'a',
+		'a',
+		'a',
+		'b',
+		'c',
+		'd',
+		'e',
+		'f',
+		'g',
+		'h',
+
+		'ab',
+		'ab',
+		'ab',
+		'ab',
+		'bc',
+		'cd',
+		'de',
+		'ef',
+		'fg',
+		'gh',
+		undefined,
+
+		'abc',
+		'abc',
+		'abc',
+		'abc',
+		'bcd',
+		'cde',
+		'def',
+		'efg',
+		'fgh',
+		undefined,
+		undefined,
+	]);
+});
+
 test('inputReader skip while peeking', async t => {
 	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
@@ -77,8 +183,33 @@ test('inputReader skip while peeking', async t => {
 
 	inputReader.skip(1);
 
+	const peekAfterSkipPromise = inputReader.peek(0);
+	const peekSequenceAfterSkipPromise = inputReader.peekSequence(0, 5);
+
 	t.is(await peekPromise, 'a');
 	t.is(await inputReader.peek(0), 'b');
+
+	t.is(await peekAfterSkipPromise, 'b');
+	t.is(await peekSequenceAfterSkipPromise, 'bcdef');
+});
+
+test('inputReader skip while peeking sequence', async t => {
+	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+		yield * 'abcdefgh';
+	})());
+
+	const peekPromise = inputReader.peekSequence(1, 5);
+
+	inputReader.skip(1);
+
+	const peekAfterSkipPromise = inputReader.peek(0);
+	const peekSequenceAfterSkipPromise = inputReader.peekSequence(0, 4);
+
+	t.is(await peekPromise, 'bcde', 'peekPromise');
+	t.is(await inputReader.peekSequence(0, 4), 'bcde', 'inputReader.peekSequence(0, 4)');
+
+	t.is(await peekAfterSkipPromise, 'b', 'peekAfterSkipPromise');
+	t.is(await peekSequenceAfterSkipPromise, 'bcde', 'peekSequenceAfterSkipPromise');
 });
 
 test('inputReader.lookahead', async t => {
@@ -115,10 +246,16 @@ test('inputReader.lookahead', async t => {
 	inputReader.skip(1);
 
 	await t.throwsAsync(async () => lookahead0a.peek(0), {
-		instanceOf: ParserImplementationError,
+		any: true,
+		name: 'ParserImplementationInvariantError',
+	});
+
+	await t.throwsAsync(async () => lookahead0b.peek(0), {
+		any: true,
+	});
+	await t.throwsAsync(async () => lookahead0c.peek(0), {
+		any: true,
 	});
-	await t.throwsAsync(async () => lookahead0b.peek(0));
-	await t.throwsAsync(async () => lookahead0c.peek(0));
 
 	const lookahead1a = inputReader.lookahead();
 	const lookahead1b = inputReader.lookahead();
@@ -160,11 +297,19 @@ test('inputReader.lookahead', async t => {
 
 	t.is(inputReader.position, 2);
 
-	await t.throwsAsync(async () => lookahead0a.peek(0));
-	await t.throwsAsync(async () => lookahead0b.peek(0));
-	await t.throwsAsync(async () => lookahead0c.peek(0));
+	await t.throwsAsync(async () => lookahead0a.peek(0), {
+		any: true,
+	});
+	await t.throwsAsync(async () => lookahead0b.peek(0), {
+		any: true,
+	});
+	await t.throwsAsync(async () => lookahead0c.peek(0), {
+		any: true,
+	});
 	t.is(await lookahead1a.peek(0), 'c');
-	await t.throwsAsync(async () => lookahead1b.peek(0));
+	await t.throwsAsync(async () => lookahead1b.peek(0), {
+		any: true,
+	});
 	t.is(await lookahead2a.peek(0), 'd');
 	t.is(await lookahead2b.peek(0), 'c');
 
@@ -236,3 +381,54 @@ test('inputReader.lookahead skip position', async t => {
 	t.is(await lookahead.peek(0), 'c');
 	t.is(await lookahead1.peek(0), 'd');
 });
+
+const END_OF_CONSUMED_SEQUENCES = Symbol('END_OF_CONSUMED_SEQUENCES');
+const END_OF_BUFFERED_SEQUENCES = Symbol('END_OF_BUFFERED_SEQUENCES');
+
+async function inputReaderStateToArray<Sequence>({
+	unconsumedBufferedSequences,
+	consumedBufferedSequences,
+	unbufferedSequences,
+}: InputReaderState<Sequence>): Promise<Array<Sequence | typeof END_OF_CONSUMED_SEQUENCES | typeof END_OF_BUFFERED_SEQUENCES>> {
+	const unconsumedBufferedSequencesArray = [ ...unconsumedBufferedSequences ];
+	const consumedBufferedSequencesArray = [ ...consumedBufferedSequences ];
+
+	const unbufferedSequencesArray = [];
+	if (unbufferedSequences) {
+		for await (const sequence of toAsyncIterable(unbufferedSequences)) {
+			unbufferedSequencesArray.push(sequence);
+		}
+	}
+
+	return [
+		...consumedBufferedSequencesArray,
+		END_OF_CONSUMED_SEQUENCES,
+		...unconsumedBufferedSequencesArray,
+		END_OF_BUFFERED_SEQUENCES,
+		...unbufferedSequencesArray,
+	];
+}
+
+const inputReaderStateMacro = test.macro({
+	title: (providedTitle, input: readonly string[], position: number) =>
+		providedTitle ?? `inputReader.toInputReaderState ${JSON.stringify({ input, position })}`,
+	async exec(t, input: readonly string[], position: number, expected: ReadonlyArray<string | symbol>) {
+		const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+			yield * input;
+		})());
+
+		inputReader.skip(position);
+		await inputReader.peek(0);
+
+		const actual = await inputReaderStateToArray(inputReader.toInputReaderState());
+
+		t.deepEqual(actual, expected);
+	},
+});
+
+test(inputReaderStateMacro, [ '', 'abc', 'def', '', 'gh' ], 0, [ END_OF_CONSUMED_SEQUENCES, 'abc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ]);
+test(inputReaderStateMacro, [ '', 'abc', 'def', '', 'gh' ], 1, [ 'a', END_OF_CONSUMED_SEQUENCES, 'bc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ]);
+test(inputReaderStateMacro, [ '', 'abc', 'def', '', 'gh' ], 2, [ 'ab', END_OF_CONSUMED_SEQUENCES, 'c', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ]);
+test(inputReaderStateMacro, [ '', 'abc', 'def', '', 'gh' ], 3, [ END_OF_CONSUMED_SEQUENCES, 'def', END_OF_BUFFERED_SEQUENCES, '', 'gh' ]);
+test(inputReaderStateMacro, [ '', 'abc', 'def', '', 'gh' ], 4, [ 'd', END_OF_CONSUMED_SEQUENCES, 'ef', END_OF_BUFFERED_SEQUENCES, '', 'gh' ]);
+test(inputReaderStateMacro, [ '', 'abc', 'def', '', 'gh' ], 8, [ END_OF_CONSUMED_SEQUENCES, END_OF_BUFFERED_SEQUENCES ]);

package/src/inputReader.ts

@@ -3,14 +3,18 @@ import invariant from 'invariant';
 import { type SequenceBuffer, SequenceBufferImplementation } from './sequenceBuffer.js';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { type InputReaderState } from './inputReaderState.js';
 
 export type InputReader<Sequence, Element> = {
 	get position(): number;
 
 	peek(offset: number): Promise<Element | undefined>;
+	peekSequence(start: number, end: number): Promise<Sequence | undefined>;
 	skip(offset: number): void;
 
 	lookahead(): InputReader<Sequence, Element>;
+
+	toInputReaderState(): InputReaderState<Sequence>;
 };
 
 let inputReaderId = 0;
@@ -20,6 +24,7 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 
 	private _position = 0;
 	private _uncommitedSkipOffset = 0;
+	private _inputAsyncIteratorDone = false;
 
 	private readonly _promiseMutex = new PromiseMutex();
 
@@ -66,6 +71,8 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 				const inputIteratorResult = await this._inputAsyncIterator.next();
 
 				if (inputIteratorResult.done) {
+					this._inputAsyncIteratorDone = true;
+
 					return undefined;
 				}
 
@@ -85,6 +92,47 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 		});
 	}
 
+	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
+		parserImplementationInvariant(
+			start >= 0,
+			'start (%s) >= 0',
+			start,
+		);
+		parserImplementationInvariant(
+			end >= start,
+			'end (%s) >= start (%s)',
+			start,
+			end,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(start),
+			'start (%s) is not a safe integer',
+			start,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(end),
+			'end (%s) is not a safe integer',
+			end,
+		);
+
+		start += this._uncommitedSkipOffset;
+		end += this._uncommitedSkipOffset;
+
+		const sequence = this._sequenceBuffer.peekSequence(start, end);
+
+		if (sequence !== undefined) {
+			return sequence;
+		}
+
+		const lastElement = await this.peek(Math.max(0, end - 1));
+
+		if (lastElement === undefined) {
+			return undefined;
+		}
+
+		return this._sequenceBuffer.peekSequence(start, end);
+	}
+
 	skip(offset: number) {
 		parserImplementationInvariant(offset >= 0, 'offset >= 0');
 
@@ -101,15 +149,27 @@ export class InputReaderImplementation<Sequence, Element> implements InputReader
 	lookahead(): InputReader<Sequence, Element> {
 		return new InputReaderLookaheadImplementation(this);
 	}
+
+	toInputReaderState() {
+		const {
+			consumedBufferedSequences,
+			unconsumedBufferedSequences,
+		} = this._sequenceBuffer.toSequenceBufferState();
+
+		return {
+			consumedBufferedSequences,
+			unconsumedBufferedSequences,
+			unbufferedSequences: this._inputAsyncIteratorDone ? undefined : this._inputAsyncIterator,
+			position: this._position,
+		};
+	}
 }
 
 class InputReaderLookaheadImplementation<Sequence, Element> implements InputReader<Sequence, Element> {
 	private _initialInputReaderPosition = 0;
 	private _offset = 0;
 
-	constructor(
-		private readonly _inputReader: InputReaderImplementation<Sequence, Element>,
-	) {
+	constructor(private readonly _inputReader: InputReaderImplementation<Sequence, Element>) {
 		this._initialInputReaderPosition = this._inputReader.position;
 	}
 
@@ -134,6 +194,15 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 		return this._inputReader.peek(this._offset + offset);
 	}
 
+	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
+		const inputReaderMovedForward = this._inputReader.position - this._initialInputReaderPosition;
+
+		this._initialInputReaderPosition = this._inputReader.position;
+		this._offset -= inputReaderMovedForward;
+
+		return this._inputReader.peekSequence(this._offset + start, this._offset + end);
+	}
+
 	skip(offset: number) {
 		parserImplementationInvariant(offset >= 0, 'offset >= 0');
 
@@ -156,4 +225,8 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 
 		return lookahead;
 	}
+
+	toInputReaderState() {
+		return invariant(false, 'Not implemented');
+	}
 }

package/src/inputReaderState.ts

@@ -0,0 +1,33 @@
+export type InputReaderState<Sequence> = {
+	position: number;
+	consumedBufferedSequences: Sequence[];
+	unconsumedBufferedSequences: Sequence[];
+	unbufferedSequences: undefined | AsyncIterator<Sequence>;
+};
+
+export const inputReaderStateCompanion = {
+	isDone<Sequence>({
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+	}: InputReaderState<Sequence>): boolean {
+		return (
+			unconsumedBufferedSequences.length === 0
+			&& unbufferedSequences === undefined
+		);
+	},
+
+	async * toRemainingInputAsyncIterator<Sequence>({
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+	}: InputReaderState<Sequence>): AsyncIterable<Sequence> {
+		yield * unconsumedBufferedSequences;
+
+		if (unbufferedSequences !== undefined) {
+			yield * {
+				[Symbol.asyncIterator]() {
+					return unbufferedSequences;
+				},
+			};
+		}
+	},
+};

package/src/inspect.ts

@@ -0,0 +1,9 @@
+import { inspect as nodeInspect } from 'node:util';
+
+export const inspect = (value: unknown) => {
+	if (value instanceof Uint8Array) {
+		value = Buffer.from(value);
+	}
+
+	return nodeInspect(value);
+};

package/src/javaKeyStoreParser.test.ts

@@ -2,22 +2,19 @@ import test from 'ava';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
 import { javaKeyStoreParser } from './javaKeyStoreParser.js';
+import { fetchCid } from './fetchCid.js';
 
-for (const javaKeyStoreCid of [
-	'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4',
-]) {
-	test(
-		'javaKeyStore ' + javaKeyStoreCid,
-		async t => {
-			const javaKeyStoreResponse = await fetch('https://ipfs.io/ipfs/' + javaKeyStoreCid);
+const javaKeyStoreMacro = test.macro({
+	title: (providedTitle, javaKeyStoreCid: string) => providedTitle ?? `javaKeyStore ${javaKeyStoreCid}`,
+	async exec(t, javaKeyStoreCid: string) {
+		const javaKeyStoreStream = await fetchCid(javaKeyStoreCid);
 
-			const javaKeyStoreStream = javaKeyStoreResponse.body!;
+		const actual = await runParser(javaKeyStoreParser, javaKeyStoreStream, uint8ArrayParserInputCompanion, {
+			errorJoinMode: 'all',
+		});
 
-			const actual = await runParser(javaKeyStoreParser, javaKeyStoreStream, uint8ArrayParserInputCompanion, {
-				errorJoinMode: 'all',
-			});
+		t.snapshot(actual);
+	},
+});
 
-			t.snapshot(actual);
-		},
-	);
-}
+test(javaKeyStoreMacro, 'bafkreig6k53b6p7bdvfjxc5mcb4qv3mffqls5ymqerxkqd6ih2xy5cs3n4');

package/src/javaKeyStoreParser.ts

@@ -66,9 +66,7 @@ const javaKeyStorePrivateKeyEntryCertificateParser = promiseCompose(
 	([ type, certificate ]) => ({ type, certificate }),
 );
 
-const javaKeyStorePrivateKeyEntryCertificateChainParser = createUint32BECountPrefixedParser(
-	javaKeyStorePrivateKeyEntryCertificateParser,
-);
+const javaKeyStorePrivateKeyEntryCertificateChainParser = createUint32BECountPrefixedParser(javaKeyStorePrivateKeyEntryCertificateParser);
 
 const javaKeyStorePrivateKeyEntryParser = promiseCompose(
 	createTupleParser([
@@ -109,9 +107,7 @@ const javaKeyStoreEntryParser = createUnionParser([
 	javaKeyStoreSecretKeyEntryParser,
 ]);
 
-const javaKeyStoreEntriesParser = createUint32BECountPrefixedParser(
-	javaKeyStoreEntryParser,
-);
+const javaKeyStoreEntriesParser = createUint32BECountPrefixedParser(javaKeyStoreEntryParser);
 
 const javaKeyStoreParser_ = createTupleParser([
 	javaKeyStoreImplementationParser,

package/src/jsonParser.test.ts

@@ -7,10 +7,8 @@ import { stringParserInputCompanion } from './parserInputCompanion.js';
 testProp(
 	'json',
 	[
-		arbitrarilySlicedAsyncIterator(
-			fc.tuple(fc.json(), fc.nat())
-				.map(([ jsonString, indent ]) => JSON.stringify(JSON.parse(jsonString), null, indent)),
-		),
+		arbitrarilySlicedAsyncIterator(fc.tuple(fc.json(), fc.nat())
+			.map(([ jsonString, indent ]) => JSON.stringify(JSON.parse(jsonString), null, indent))),
 	],
 	async (t, [ jsonString, jsonStringChunkIterator ]) => {
 		const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringParserInputCompanion, {