@futpib/parser 1.0.2 → 1.0.4

package/src/elementTerminatedSequenceArrayParser.test.ts

@@ -1,6 +1,6 @@
 import * as fc from 'fast-check';
 import { testProp } from '@fast-check/ava';
-import { Parser, runParser } from './parser.js';
+import { type Parser, runParser } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createElementTerminatedSequenceArrayParser } from './elementTerminatedSequenceArrayParser.js';
 
@@ -13,14 +13,12 @@ testProp.serial(
 			})
 			.map(string => ({
 				string,
-				terminator: string.slice(-1)
+				terminator: string.slice(-1),
 			}))
-			.filter(({ string, terminator }) => string.split(terminator).length === 2)
+			.filter(({ string, terminator }) => string.split(terminator).length === 2),
 	],
 	async (t, { string, terminator }) => {
-		const elementTerminatedSequenceArrayParser = createElementTerminatedSequenceArrayParser<string>(
-			terminator,
-		);
+		const elementTerminatedSequenceArrayParser = createElementTerminatedSequenceArrayParser<string>(terminator);
 
 		const createTestWrapperParser = (innerParser: typeof elementTerminatedSequenceArrayParser): Parser<{
 			strings: string[];

package/src/elementTerminatedSequenceArrayParser.ts

@@ -1,5 +1,5 @@
-import { Parser, setParserName } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import { type Parser, setParserName } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export const createElementTerminatedSequenceArrayParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(
 	terminatorElement: Element,

package/src/elementTerminatedSequenceParser.test.ts

@@ -1,6 +1,6 @@
 import * as fc from 'fast-check';
 import { testProp } from '@fast-check/ava';
-import { Parser, runParser } from './parser.js';
+import { type Parser, runParser } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createElementTerminatedSequenceParser } from './elementTerminatedSequenceParser.js';
 
@@ -13,14 +13,12 @@ testProp.serial(
 			})
 			.map(string => ({
 				string,
-				terminator: string.slice(-1)
+				terminator: string.slice(-1),
 			}))
-			.filter(({ string, terminator }) => string.split(terminator).length === 2)
+			.filter(({ string, terminator }) => string.split(terminator).length === 2),
 	],
 	async (t, { string, terminator }) => {
-		const elementTerminatedSequenceParser = createElementTerminatedSequenceParser<string>(
-			terminator,
-		);
+		const elementTerminatedSequenceParser = createElementTerminatedSequenceParser<string>(terminator);
 
 		const createTestWrapperParser = (innerParser: typeof elementTerminatedSequenceParser): Parser<{
 			string: string;

package/src/elementTerminatedSequenceParser.ts

@@ -1,5 +1,5 @@
-import { Parser, setParserName } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import { type Parser, setParserName } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 export const createElementTerminatedSequenceParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(
 	terminatorElement: Element,

package/src/endOfInputParser.ts

@@ -8,4 +8,4 @@ export const createEndOfInputParser = <Sequence, Element = DeriveSequenceElement
 	);
 };
 
-export const endOfInputParser = createEndOfInputParser<any, any>();
+export const endOfInputParser = createEndOfInputParser<unknown, unknown>();

package/src/exactElementSwitchParser.ts

@@ -0,0 +1,41 @@
+import invariant from "invariant";
+import { getParserName, Parser, setParserName } from "./parser.js";
+import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
+import { DeriveSequenceElement } from "./sequence.js";
+
+export const createElementSwitchParser = <
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	childParsers: Map<Element, Parser<unknown, Sequence, Element>>,
+	defaultParser?: Parser<unknown, Sequence, Element>,
+): Parser<Output, Sequence, Element> => {
+	parserImplementationInvariant(childParsers.size > 0, 'Element switch parser must have at least one child parser.');
+
+	const elementSwitchParser: Parser<Output, Sequence, Element> = async parserContext => {
+		const currentElement = await parserContext.peek(0);
+
+		parserContext.invariant(currentElement !== undefined, 'Unexpected end of input.');
+		invariant(currentElement !== undefined, 'Unexpected end of input.');
+
+		const childParser = childParsers.get(currentElement) ?? defaultParser;
+
+		parserContext.invariant(childParser, `No child parser found for element: ${String(currentElement)}`);
+
+		const childParserOutput = await childParser!(parserContext) as Output;
+
+		return childParserOutput;
+	};
+
+	const name = [
+		'elementSwitch(',
+		...Array.from(childParsers.entries()).map(
+			([ element, childParser ]) => `${String(element)}=>${getParserName(childParser, 'anonymousElementSwitchChild')}`,
+		),
+		defaultParser ? `|default=>${getParserName(defaultParser, 'anonymousElementSwitchDefaultChild')}` : '',
+		')',
+	].join('');
+
+	return setParserName(elementSwitchParser, name);
+}

package/src/fetchCid.test.ts

@@ -0,0 +1,20 @@
+import test from 'ava';
+import { fetchCid } from './fetchCid.js';
+
+const cid = 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda';
+
+test('fetchCid', async t => {
+	await Promise.all([
+		fetchCid(cid),
+		fetchCid(cid),
+		fetchCid(cid),
+	]);
+
+	await Promise.all([
+		fetchCid(cid),
+		fetchCid(cid),
+		fetchCid(cid),
+	]);
+
+	t.pass();
+});

package/src/fetchCid.ts

@@ -47,15 +47,13 @@ class FsCache {
 		try {
 			const file = await fsPromises.open(this._getKeyPath(key), 'r');
 
-			const stream = file.readableWebStream({
-				type: 'bytes',
-			}) as ReadableStream<Uint8Array>;
+			const stream = file.readableWebStream() as ReadableStream<Uint8Array>;
 
 			const streamWithClose = readableWebStreamOnFinish(stream, () => {
 				file.close();
 			});
 
-			return [ streamWithClose, undefined as any ];
+			return [ streamWithClose, undefined as unknown as ReadableStream<Uint8Array> ];
 		} catch (error) {
 			if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
 				return undefined;
@@ -108,9 +106,7 @@ export async function fetchCid(cidOrPath: string): Promise<AsyncIterable<Uint8Ar
 	if (cidOrPath.includes('/')) {
 		const file = await fsPromises.open(cidOrPath, 'r');
 
-		const stream = file.readableWebStream({
-			type: 'bytes',
-		}) as ReadableStream<Uint8Array>;
+		const stream = file.readableWebStream() as ReadableStream<Uint8Array>;
 
 		const streamWithClose = readableWebStreamOnFinish(stream, () => {
 			file.close();

package/src/fixedLengthSequenceParser.test.ts

@@ -2,7 +2,7 @@ import test from 'ava';
 import * as fc from 'fast-check';
 import { testProp } from '@fast-check/ava';
 import { createFixedLengthSequenceParser, createFixedLengthSequenceParserNaive } from './fixedLengthSequenceParser.js';
-import { Parser, runParserWithRemainingInput } from './parser.js';
+import { type Parser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { HighResolutionTotalTimer } from './highResolutionTimer.js';
 import { arbitrarilySlicedAsyncIterable } from './arbitrarilySlicedAsyncInterable.js';
@@ -19,12 +19,10 @@ testProp.serial(
 				max: 2n ** 14n,
 			})
 			.chain(length => fc.tuple(
-				arbitrarilySlicedAsyncIterable(
-					fc.string({
-						minLength: Number(length),
-						maxLength: Number(length) * 2,
-					}),
-				),
+				arbitrarilySlicedAsyncIterable(fc.string({
+					minLength: Number(length),
+					maxLength: Number(length) * 2,
+				})),
 				fc.constant(length),
 			)),
 	],
@@ -33,8 +31,8 @@ testProp.serial(
 		const fixedLengthSequenceParser = createFixedLengthSequenceParser<string>(length);
 
 		const createTestWrapperParser = (innerParser: typeof fixedLengthSequenceParser): Parser<{
-			result: string,
-			position: number,
+			result: string;
+			position: number;
 		}, string> => async parserContext => {
 			const result = await innerParser(parserContext);
 
@@ -45,7 +43,7 @@ testProp.serial(
 			};
 		};
 
-		const { output: actualNaive } = await naiveTotalTimer.measureAsync(() => runParserWithRemainingInput(
+		const { output: actualNaive } = await naiveTotalTimer.measureAsync(async () => runParserWithRemainingInput(
 			createTestWrapperParser(fixedLengthSequenceParserNaive),
 			sequence,
 			stringParserInputCompanion,
@@ -53,7 +51,7 @@ testProp.serial(
 
 		t.true(actualNaive.result.length === Number(length));
 
-		const { output: actual } = await totalTimer.measureAsync(() => runParserWithRemainingInput(
+		const { output: actual } = await totalTimer.measureAsync(async () => runParserWithRemainingInput(
 			createTestWrapperParser(fixedLengthSequenceParser),
 			sequence,
 			stringParserInputCompanion,
@@ -71,7 +69,7 @@ test.serial(
 	t => {
 		t.true(
 			totalTimer.time * 10n < naiveTotalTimer.time,
-			`Naive: ${naiveTotalTimer.time / 1000000n}ms, Optimized: ${totalTimer.time / 1000000n}ms`,
+			`Naive: ${naiveTotalTimer.time / 1_000_000n}ms, Optimized: ${totalTimer.time / 1_000_000n}ms`,
 		);
 	},
 );

package/src/hasExecutable.ts

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

package/src/highResolutionTimer.ts

@@ -1,5 +1,5 @@
-import invariant from 'invariant';
 import process from 'node:process';
+import invariant from 'invariant';
 
 class HighResolutionSubTimer {
 	private _ended = false;

package/src/index.ts

@@ -1,16 +1,59 @@
-
 export {
 	type Parser,
 	runParser,
-
+	runParserWithRemainingInput,
 	setParserName,
 	getParserName,
+	cloneParser,
+	type RunParserOptions,
+	type RunParserWithRemainingInputResult,
 } from './parser.js';
 
 export type {
 	ParserContext,
 } from './parserContext.js';
 
+export {
+	type ParserInputCompanion,
+	StringParserInputCompanion,
+	stringParserInputCompanion,
+	Uint8ArrayParserInputCompanion,
+	uint8ArrayParserInputCompanion,
+} from './parserInputCompanion.js';
+
+export {
+	type UnparserOutputCompanion,
+	StringUnparserOutputCompanion,
+	stringUnparserOutputCompanion,
+	Uint8ArrayUnparserOutputCompanion,
+	uint8ArrayUnparserOutputCompanion,
+} from './unparserOutputCompanion.js';
+
+export {
+	type ParserError,
+	type ParserParsingFailedError,
+	type ParserParsingJoinError,
+	type ParserErrorModule,
+	isParserError,
+	isParserParsingFailedError,
+	isParserParsingJoinError,
+	normalParserErrorModule,
+	noStackCaptureOverheadParserErrorModule,
+} from './parserError.js';
+
+export {
+	parserCreatorCompose,
+	parserCreatorComposeMem,
+} from './parserCreatorCompose.js';
+
+export {
+	promiseCompose,
+} from './promiseCompose.js';
+
+export type {
+	DeriveSequenceElement,
+} from './sequence.js';
+
 export {
 	createTupleParser,
 } from './tupleParser.js';
@@ -75,11 +118,75 @@ export {
 	createDebugLogParser,
 } from './debugLogParser.js';
 
+export {
+	createNonEmptyArrayParser,
+} from './nonEmptyArrayParser.js';
+
+export {
+	createSeparatedArrayParser,
+} from './separatedArrayParser.js';
+
+export {
+	createSeparatedNonEmptyArrayParser,
+} from './separatedNonEmptyArrayParser.js';
+
+export {
+	createLookaheadParser,
+} from './lookaheadParser.js';
+
+export {
+	createNegativeLookaheadParser,
+} from './negativeLookaheadParser.js';
+
+export {
+	createElementTerminatedSequenceParser,
+} from './elementTerminatedSequenceParser.js';
+
+export {
+	createElementTerminatedSequenceArrayParser,
+} from './elementTerminatedSequenceArrayParser.js';
+
+export {
+	createElementTerminatedArrayParserUnsafe,
+} from './elementTerminatedArrayParser.js';
+
+export {
+	createSequenceTerminatedSequenceParser,
+} from './sequenceTerminatedSequenceParser.js';
+
+export {
+	createQuantifierParser,
+} from './quantifierParser.js';
+
+export {
+	createSkipToParser,
+} from './skipToParser.js';
+
+export {
+	createDebugLogInputParser,
+} from './debugLogInputParser.js';
+
+export {
+	createElementSwitchParser,
+} from './exactElementSwitchParser.js';
+
+export {
+	createParserConsumedSequenceParser,
+} from './parserConsumedSequenceParser.js';
+
 export {
 	type Unparser,
+	type UnparserResult,
 	runUnparser,
 } from './unparser.js';
 
+export {
+	type UnparserContext,
+	WriteLater,
+	WriteEarlier,
+	UnparserContextImplementation,
+} from './unparserContext.js';
+
 export {
 	createArrayUnparser,
 } from './arrayUnparser.js';
@@ -87,3 +194,7 @@ export {
 export {
 	createSequenceUnparser,
 } from './sequenceUnparser.js';
+
+export {
+	createRegExpParser,
+} from './regexpParser.js';

package/src/inputReader.test.ts

@@ -1,9 +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 { InputReaderState } from './inputReaderState.js';
+import { type InputReaderState } from './inputReaderState.js';
 
 test('inputReader', async t => {
 	const inputReader = new InputReaderImplementation(stringParserInputCompanion, (async function * () {
@@ -122,7 +121,7 @@ test('inputReader.peekSequence concurrent', async t => {
 		yield * 'abcdefgh';
 	})());
 
-	const peeks = await Promise.all([1, 2, 3].flatMap(length => [
+	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),
@@ -247,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();
@@ -292,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');
 
@@ -376,9 +389,9 @@ async function inputReaderStateToArray<Sequence>({
 	unconsumedBufferedSequences,
 	consumedBufferedSequences,
 	unbufferedSequences,
-}: InputReaderState<Sequence>): Promise<(Sequence | typeof END_OF_CONSUMED_SEQUENCES | typeof END_OF_BUFFERED_SEQUENCES)[]> {
-	const unconsumedBufferedSequencesArray = unconsumedBufferedSequences.slice();
-	const consumedBufferedSequencesArray = consumedBufferedSequences.slice();
+}: 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) {
@@ -396,43 +409,10 @@ async function inputReaderStateToArray<Sequence>({
 	];
 }
 
-for (const [
-	input,
-	position,
-	expected,
-] of [
-	[
-		[ '', 'abc', 'def', '', 'gh' ],
-		0,
-		[ END_OF_CONSUMED_SEQUENCES, 'abc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ],
-	],
-	[
-		[ '', 'abc', 'def', '', 'gh' ],
-		1,
-		[ 'a', END_OF_CONSUMED_SEQUENCES, 'bc', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ],
-	],
-	[
-		[ '', 'abc', 'def', '', 'gh' ],
-		2,
-		[ 'ab', END_OF_CONSUMED_SEQUENCES, 'c', END_OF_BUFFERED_SEQUENCES, 'def', '', 'gh' ],
-	],
-	[
-		[ '', 'abc', 'def', '', 'gh' ],
-		3,
-		[ END_OF_CONSUMED_SEQUENCES, 'def', END_OF_BUFFERED_SEQUENCES, '', 'gh' ],
-	],
-	[
-		[ '', 'abc', 'def', '', 'gh' ],
-		4,
-		[ 'd', END_OF_CONSUMED_SEQUENCES, 'ef', END_OF_BUFFERED_SEQUENCES, '', 'gh' ],
-	],
-	[
-		[ '', 'abc', 'def', '', 'gh' ],
-		8,
-		[ END_OF_CONSUMED_SEQUENCES, END_OF_BUFFERED_SEQUENCES ],
-	],
-] as const) {
-	test('inputReader.toInputReaderState ' + JSON.stringify({ input, position }), async t => {
+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;
 		})());
@@ -443,5 +423,12 @@ for (const [
 		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,7 +3,7 @@ import invariant from 'invariant';
 import { type SequenceBuffer, SequenceBufferImplementation } from './sequenceBuffer.js';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { InputReaderState } from './inputReaderState.js';
+import { type InputReaderState } from './inputReaderState.js';
 
 export type InputReader<Sequence, Element> = {
 	get position(): number;
@@ -169,9 +169,7 @@ class InputReaderLookaheadImplementation<Sequence, Element> implements InputRead
 	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;
 	}
 

package/src/inputReaderState.ts

@@ -12,7 +12,7 @@ export const inputReaderStateCompanion = {
 	}: InputReaderState<Sequence>): boolean {
 		return (
 			unconsumedBufferedSequences.length === 0
-				&& unbufferedSequences === undefined
+			&& unbufferedSequences === undefined
 		);
 	},
 

package/src/inspect.ts

@@ -6,4 +6,4 @@ export const inspect = (value: unknown) => {
 	}
 
 	return nodeInspect(value);
-}
+};

package/src/javaKeyStoreParser.test.ts

@@ -4,19 +4,17 @@ 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 javaKeyStoreStream = await fetchCid(javaKeyStoreCid);
+const javaKeyStoreMacro = test.macro({
+	title: (providedTitle, javaKeyStoreCid: string) => providedTitle ?? `javaKeyStore ${javaKeyStoreCid}`,
+	async exec(t, javaKeyStoreCid: string) {
+		const javaKeyStoreStream = await fetchCid(javaKeyStoreCid);
 
-			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, {