@futpib/parser 1.0.2 → 1.0.3

package/src/stringFromAsyncIterable.ts

@@ -0,0 +1,9 @@
+export async function stringFromAsyncIterable(asyncIterable: AsyncIterable<string>) {
+	let string = '';
+
+	for await (const chunk of asyncIterable) {
+		string += chunk;
+	}
+
+	return string;
+}

package/src/terminatedArrayParser.test.ts

@@ -2,7 +2,7 @@ import test from 'ava';
 import * as fc from 'fast-check';
 import { testProp } from '@fast-check/ava';
 import { createTerminatedArrayParser, createTerminatedArrayParserNaive, createTerminatedArrayParserUnsafe } from './terminatedArrayParser.js';
-import { Parser, runParser } from './parser.js';
+import { type Parser, runParser } from './parser.js';
 import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { HighResolutionTotalTimer } from './highResolutionTimer.js';
 import { createElementParser } from './elementParser.js';
@@ -64,7 +64,7 @@ testProp(
 
 		if (
 			result.status === 'rejected'
-				&& naiveResult.status === 'rejected'
+			&& naiveResult.status === 'rejected'
 		) {
 			result.reason.message = 'REDACTED';
 			naiveResult.reason.message = 'REDACTED';
@@ -96,10 +96,10 @@ testProp.serial(
 					})
 					.map(string => ({
 						string,
-						terminator: string.slice(0 - terminatorLength)
+						terminator: string.slice(0 - terminatorLength),
 					}))
 					.filter(({ string, terminator }) => string.split(terminator).length === 2)
-			))
+			)),
 	],
 	async (t, { string, terminator }) => {
 		const terminatedArrayParserNaive = createTerminatedArrayParserNaive(
@@ -138,7 +138,7 @@ testProp.serial(
 			};
 		};
 
-		const actualNaive = await naiveTotalTimer.measureAsync(() => runParser(
+		const actualNaive = await naiveTotalTimer.measureAsync(async () => runParser(
 			createTestWrapperParser(terminatedArrayParserNaive),
 			string,
 			stringParserInputCompanion,
@@ -146,7 +146,7 @@ testProp.serial(
 
 		t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
 
-		const actual = await optimizedTotalTimer.measureAsync(() => runParser(
+		const actual = await optimizedTotalTimer.measureAsync(async () => runParser(
 			createTestWrapperParser(terminatedArrayParser),
 			string,
 			stringParserInputCompanion,
@@ -164,7 +164,7 @@ test.serial(
 	t => {
 		t.true(
 			optimizedTotalTimer.time * 1n < naiveTotalTimer.time,
-			`Naive: ${naiveTotalTimer.time / 1000000n}ms, Optimized: ${optimizedTotalTimer.time / 1000000n}ms`,
+			`Naive: ${naiveTotalTimer.time / 1_000_000n}ms, Optimized: ${optimizedTotalTimer.time / 1_000_000n}ms`,
 		);
 	},
 );
@@ -184,10 +184,10 @@ testProp.serial(
 					})
 					.map(string => ({
 						string,
-						terminator: string.slice(0 - terminatorLength)
+						terminator: string.slice(0 - terminatorLength),
 					}))
 					.filter(({ string, terminator }) => string.split(terminator).length === 2)
-			))
+			)),
 	],
 	async (t, { string, terminator }) => {
 		const terminatedArrayParserNaive = createTerminatedArrayParserNaive(
@@ -234,7 +234,7 @@ testProp.serial(
 
 		t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
 
-		const actual = await unsafeTotalTimer.measureAsync(() => runParser(
+		const actual = await unsafeTotalTimer.measureAsync(async () => runParser(
 			createTestWrapperParser(terminatedArrayParserUnsafe),
 			string,
 			stringParserInputCompanion,
@@ -252,7 +252,7 @@ test.serial(
 	t => {
 		t.true(
 			unsafeTotalTimer.time * 1n < naiveTotalTimer.time,
-			`Naive: ${naiveTotalTimer.time / 1000000n}ms, Unsafe: ${unsafeTotalTimer.time / 1000000n}ms`,
+			`Naive: ${naiveTotalTimer.time / 1_000_000n}ms, Unsafe: ${unsafeTotalTimer.time / 1_000_000n}ms`,
 		);
 	},
 );

package/src/terminatedArrayParser.ts

@@ -1,13 +1,11 @@
 import { getParserName, type Parser, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createUnionParser } from './unionParser.js';
 
 class Terminated<T> {
-	constructor(
-		public readonly value: T,
-	) {}
+	constructor(public readonly value: T) {}
 }
 
 export const createTerminatedArrayParserNaive = <ElementOutput, TerminatorOutput, Sequence>(
@@ -78,7 +76,7 @@ export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Seq
 						getParserName(terminatorParser, 'anonymousTerminator'),
 					);
 				} catch (error) {
-					if (!(error instanceof ParserParsingFailedError)) {
+					if (!(isParserParsingFailedError(error))) {
 						throw error;
 					}
 				} finally {
@@ -89,7 +87,7 @@ export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Seq
 
 				return [ elements, terminatorValue ];
 			} catch (error) {
-				if (!(error instanceof ParserParsingFailedError)) {
+				if (!(isParserParsingFailedError(error))) {
 					throw error;
 				}
 			} finally {
@@ -126,7 +124,7 @@ export const createTerminatedArrayParserUnsafe = <ElementOutput, TerminatorOutpu
 
 				return [ elements, terminatorValue ];
 			} catch (error) {
-				if (!(error instanceof ParserParsingFailedError)) {
+				if (!(isParserParsingFailedError(error))) {
 					throw error;
 				}
 			} finally {

package/src/toAsyncIterator.ts

@@ -1,15 +1,15 @@
-import invariant from "invariant";
+import invariant from 'invariant';
 
-function isAsyncIterable<T>(value: any): value is AsyncIterable<T> {
-	return value && typeof value[Symbol.asyncIterator] === 'function';
+function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T> {
+	return typeof value === 'object' && value !== null && Symbol.asyncIterator in value && typeof (value as Record<symbol, unknown>)[Symbol.asyncIterator] === 'function';
 }
 
-function isIterable<T>(value: any): value is Iterable<T> {
-	return value && typeof value[Symbol.iterator] === 'function';
+function isIterable<T>(value: unknown): value is Iterable<T> {
+	return typeof value === 'object' && value !== null && Symbol.iterator in value && typeof (value as Record<symbol, unknown>)[Symbol.iterator] === 'function';
 }
 
-function isIterator<T>(value: any): value is Iterator<T> {
-	return value && typeof value.next === 'function';
+function isIterator<T>(value: unknown): value is Iterator<T> {
+	return typeof value === 'object' && value !== null && 'next' in value && typeof (value as Record<string, unknown>).next === 'function';
 }
 
 function iteratorToAsyncIterator<T>(iterator: Iterator<T>): AsyncIterator<T> {
@@ -24,7 +24,7 @@ export function toAsyncIterator<T>(value: AsyncIterator<T> | AsyncIterable<T> |
 		|| value instanceof Uint8Array
 	) {
 		return (async function * () {
-			yield value as any;
+			yield value as T;
 		})();
 	}
 

package/src/uint8Array.ts

@@ -1,10 +1,9 @@
 
-export async function uint8ArrayAsyncIterableToUint8Array(
-	uint8ArrayAsyncIterable: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
-): Promise<Uint8Array> {
+export async function uint8ArrayAsyncIterableToUint8Array(uint8ArrayAsyncIterable: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): Promise<Uint8Array> {
 	const chunks: Uint8Array[] = [];
 	for await (const chunk of uint8ArrayAsyncIterable) {
 		chunks.push(chunk);
 	}
+
 	return Buffer.concat(chunks);
 }

package/src/unionParser.test.ts

@@ -1,6 +1,6 @@
 import test from 'ava';
 import { createUnionParser } from './unionParser.js';
-import { Parser, runParser, setParserName } from './parser.js';
+import { type Parser, runParser, setParserName } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createArrayParser } from './arrayParser.js';
 import { createExactElementParser } from './exactElementParser.js';
@@ -31,34 +31,32 @@ test('union of union of union', async t => {
 });
 
 test('sync and async child parsers', async t => {
-	const parser = createArrayParser(
-		createUnionParser<string, string>([
-			async parserContext => {
-				parserContext.invariant(
-					parserContext.position % 2 === 0,
-					'Expected an even position.',
-				);
+	const parser = createArrayParser(createUnionParser<string, string>([
+		async parserContext => {
+			parserContext.invariant(
+				parserContext.position % 2 === 0,
+				'Expected an even position.',
+			);
 
-				return parserContext.read(0);
-			},
-			parserContext => {
-				parserContext.invariant(
-					parserContext.position % 2 === 1,
-					'Expected an odd position.',
-				);
+			return parserContext.read(0);
+		},
+		parserContext => {
+			parserContext.invariant(
+				parserContext.position % 2 === 1,
+				'Expected an odd position.',
+			);
 
-				parserContext.skip(1);
+			parserContext.skip(1);
 
-				return String.fromCodePoint('A'.codePointAt(0)! + parserContext.position - 1);
-			},
-		]),
-	);
+			return String.fromCodePoint('A'.codePointAt(0)! + parserContext.position - 1);
+		},
+	]));
 
 	const result = await runParser(parser, 'a?c?', stringParserInputCompanion, {
 		errorJoinMode: 'all',
 	});
 
-	t.deepEqual(result, 'aBcD'.split(''));
+	t.deepEqual(result, [ ...'aBcD' ]);
 });
 
 test('multiple parsers succeeded error', async t => {
@@ -70,8 +68,9 @@ test('multiple parsers succeeded error', async t => {
 	const error = await t.throwsAsync(runParser(parser, 'foo', stringParserInputCompanion, {
 		errorJoinMode: 'all',
 	}), {
-		instanceOf: ParserError,
-	});
+		any: true,
+		name: 'ParserImplementationInvariantError',
+	}) as ParserError;
 
 	t.true(error.message.includes('foo'));
 	t.true(error.message.includes('foo1'));

package/src/unionParser.ts

@@ -1,9 +1,9 @@
 import { allSettledStream } from './allSettledStream.js';
 import { getParserName, setParserName, type Parser } from './parser.js';
 import { type ParserContext } from './parserContext.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { DeriveSequenceElement } from './sequence.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 const bigintReplacer = (_key: string, value: unknown) => {
 	if (typeof value === 'bigint') {
@@ -23,8 +23,8 @@ export const createUnionParser = <
 	parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
 
 	type TaskContext = {
-		childParser: Parser<unknown, Sequence, Element>,
-		childParserContext: ParserContext<Sequence, Element>,
+		childParser: Parser<unknown, Sequence, Element>;
+		childParserContext: ParserContext<Sequence, Element>;
 	};
 
 	const unionParser: Parser<Output, Sequence, Element> = async parserContext => {
@@ -60,9 +60,7 @@ export const createUnionParser = <
 		let didUnlookahead = false;
 
 		for await (const childParserResult of childParserResults) {
-			runningChildParserContexts = runningChildParserContexts.filter(
-				runningChildParserContext => runningChildParserContext !== childParserResult.context,
-			);
+			runningChildParserContexts = runningChildParserContexts.filter(runningChildParserContext => runningChildParserContext !== childParserResult.context);
 
 			if (childParserResult.status === 'fulfilled') {
 				successfulParserOutputs.push(childParserResult.value);
@@ -70,7 +68,7 @@ export const createUnionParser = <
 			} else {
 				const error = childParserResult.reason;
 
-				if (error instanceof ParserParsingFailedError) {
+				if (isParserParsingFailedError(error)) {
 					parserParsingFailedErrors.push(error);
 				} else {
 					throw error;

package/src/unparser.test.ts

@@ -1,8 +1,8 @@
 import test from 'ava';
 import * as fc from 'fast-check';
-import { runUnparser, Unparser } from './unparser.js';
-import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
 import { testProp } from '@fast-check/ava';
+import { runUnparser, type Unparser } from './unparser.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
 
 test('writeLater', async t => {
 	const stringToBeWrittenBefore = 'before writeLater\n';
@@ -16,7 +16,7 @@ test('writeLater', async t => {
 	let actualPositionBFromWithinWriteLater: number | undefined;
 
 	const unparser: Unparser<void, string> = async function * (_input, unparserContext) {
-		yield stringToBeWrittenBefore
+		yield stringToBeWrittenBefore;
 
 		expectedPositionA = unparserContext.position;
 
@@ -127,19 +127,13 @@ test('writeLater deep', async t => {
 testProp(
 	'writeLater positions and lengths',
 	[
-		fc.array(
-			fc.oneof(
-				fc.array(
-					fc.oneof(
-						fc.array(
-							fc.string(),
-						),
-						fc.string(),
-					),
-				),
+		fc.array(fc.oneof(
+			fc.array(fc.oneof(
+				fc.array(fc.string()),
 				fc.string(),
-			),
-		),
+			)),
+			fc.string(),
+		)),
 	],
 	async (t, stringArray3) => {
 		const numberUnparser: Unparser<number, string> = async function * (input, unparserContext) {
@@ -148,12 +142,10 @@ testProp(
 
 		const createLengthPrefixedUnparser = <T>(
 			unparser: Unparser<T, string>,
-		): Unparser<T, string> => {
-			return async function * (input, unparserContext) {
-				const length = yield * unparserContext.writeLater(8);
-				yield * unparser(input, unparserContext);
-				yield * unparserContext.writeEarlier(length, numberUnparser, unparserContext.position - length.positionEnd);
-			};
+		): Unparser<T, string> => async function * (input, unparserContext) {
+			const length = yield * unparserContext.writeLater(8);
+			yield * unparser(input, unparserContext);
+			yield * unparserContext.writeEarlier(length, numberUnparser, unparserContext.position - length.positionEnd);
 		};
 
 		const unparser0: Unparser<string, string> = createLengthPrefixedUnparser(async function * (input, unparserContext) {
@@ -166,23 +158,15 @@ testProp(
 			}
 		});
 
-		const unparser2: Unparser<(string | string[])[], string> = createLengthPrefixedUnparser(async function * (input, unparserContext) {
+		const unparser2: Unparser<Array<string | string[]>, string> = createLengthPrefixedUnparser(async function * (input, unparserContext) {
 			for (const stringArray2 of input) {
-				if (typeof stringArray2 === 'string') {
-					yield * unparser0(stringArray2, unparserContext);
-				} else {
-					yield * unparser1(stringArray2, unparserContext);
-				}
+				yield * (typeof stringArray2 === 'string' ? unparser0(stringArray2, unparserContext) : unparser1(stringArray2, unparserContext));
 			}
 		});
 
-		const unparser3: Unparser<(string | (string | string[])[])[], string> = createLengthPrefixedUnparser(async function * (input, unparserContext) {
+		const unparser3: Unparser<Array<string | Array<string | string[]>>, string> = createLengthPrefixedUnparser(async function * (input, unparserContext) {
 			for (const stringArray3 of input) {
-				if (typeof stringArray3 === 'string') {
-					yield * unparser0(stringArray3, unparserContext);
-				} else {
-					yield * unparser2(stringArray3, unparserContext);
-				}
+				yield * (typeof stringArray3 === 'string' ? unparser0(stringArray3, unparserContext) : unparser2(stringArray3, unparserContext));
 			}
 		});
 
@@ -196,7 +180,7 @@ testProp(
 
 		const actualString = strings.join('');
 
-		type DeepArray<T> = T | DeepArray<T>[];
+		type DeepArray<T> = T | Array<DeepArray<T>>;
 
 		function getExpectedString(stringArray: DeepArray<string>): string {
 			let expectedString = stringArray;

package/src/unparser.ts

@@ -1,8 +1,10 @@
-import invariant from "invariant";
-import { DeriveSequenceElement } from "./sequence.js";
-import { UnparserContext, UnparserContextImplementation, WriteEarlier, WriteLater } from "./unparserContext.js";
-import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
-import { unparserImplementationInvariant } from "./unparserImplementationInvariant.js";
+import invariant from 'invariant';
+import { type DeriveSequenceElement } from './sequence.js';
+import {
+	type UnparserContext, UnparserContextImplementation, WriteEarlier, WriteLater,
+} from './unparserContext.js';
+import { type UnparserOutputCompanion } from './unparserOutputCompanion.js';
+import { unparserImplementationInvariant } from './unparserImplementationInvariant.js';
 
 type UnparserIterableValue<Sequence, Element> =
 	| Sequence
@@ -49,7 +51,7 @@ async function * elementsToSequences<
 	for await (const value of values) {
 		if (
 			value instanceof WriteLater
-				|| value instanceof WriteEarlier
+			|| value instanceof WriteEarlier
 		) {
 			if (elements.length > 0) {
 				const sequence = unparserOutputCompanion.from(elements);
@@ -91,7 +93,9 @@ function wrapUnparserResult<Sequence, Element>(
 			unparserResult,
 			unparserOutputCompanion,
 		),
-		value => unparserContext.handleYield(value),
+		value => {
+			unparserContext.handleYield(value);
+		},
 	);
 }
 
@@ -119,7 +123,7 @@ export async function * runUnparser<
 	type PushOutput = (value: Sequence | WriteLater<Sequence, Element>) => void;
 	type FinishOutput = () => void;
 
-	const iteratorStack: [ Iterator, PushOutput, FinishOutput ][] = [
+	const iteratorStack: Array<[ Iterator, PushOutput, FinishOutput ]> = [
 		[
 			valuesWithoutElements[Symbol.asyncIterator](),
 			value => outputQueue.push(value),
@@ -130,7 +134,7 @@ export async function * runUnparser<
 	while (true) {
 		while (
 			outputQueue.length > 0
-				&& !(outputQueue[0] instanceof WriteLater)
+			&& !(outputQueue[0] instanceof WriteLater)
 		) {
 			yield outputQueue.shift() as Sequence;
 		}

package/src/unparserContext.ts

@@ -1,9 +1,8 @@
-/* eslint-disable prefer-arrow-callback */
 
-import { Unparser, UnparserResult } from "./unparser.js";
-import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
-import { unparserImplementationInvariant } from "./unparserImplementationInvariant.js";
-import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
+import { type Unparser, type UnparserResult } from './unparser.js';
+import { type UnparserOutputCompanion } from './unparserOutputCompanion.js';
+import { unparserImplementationInvariant } from './unparserImplementationInvariant.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
 export type UnparserContext<Sequence, Element> = {
 	get position(): number;
@@ -19,7 +18,7 @@ export type UnparserContext<Sequence, Element> = {
 export class WriteLater<Sequence, Element> extends Error {
 	name = 'WriteLater';
 
-	constructor (
+	constructor(
 		private readonly _position: number,
 		private readonly _length: number,
 	) {
@@ -105,13 +104,10 @@ export class UnparserContextImplementation<Sequence, Element> implements Unparse
 		);
 	}
 
-	handleYield(
-		value:
-			| Sequence
-			| WriteLater<Sequence, Element>
-			| WriteEarlier<Sequence, Element>
-		,
-	) {
+	handleYield(value:
+		| Sequence
+		| WriteLater<Sequence, Element>
+		| WriteEarlier<Sequence, Element>) {
 		if (value instanceof WriteEarlier) {
 			return;
 		}

package/src/unparserError.ts

@@ -1,5 +1,6 @@
+import { NormalLazyMessageError } from "./lazyMessageError.js";
 
-export class UnparserError extends Error {
+export class UnparserError extends NormalLazyMessageError {
 	name = 'UnparserError';
 }
 

package/src/unparserImplementationInvariant.ts

@@ -1,6 +1,6 @@
 import { UnparserImplementationInvariantError } from './unparserError.js';
 import { type Falsy, customInvariant, type ValueOrAccessor } from './customInvariant.js';
 
-export function unparserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
+export function unparserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy> {
 	return customInvariant(UnparserImplementationInvariantError, value, format, ...formatArguments);
 }

package/src/unparserOutputCompanion.ts

@@ -1,4 +1,4 @@
-import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from "./parserInputCompanion.js";
+import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 
 export type UnparserOutputCompanion<Sequence, Element> = {
 	is(value: unknown): value is Sequence;

package/src/zip.ts

@@ -1,9 +1,7 @@
 
 export type ZipCompression =
 	| 'store'
-	| 'deflate'
-;
-
+	| 'deflate';
 export type ZipEntryAttributes = {
 };
 
@@ -27,9 +25,7 @@ export type ZipDirectoryEntry = ZipEntryCommon & {
 
 export type ZipEntry =
 	| ZipFileEntry
-	| ZipDirectoryEntry
-;
-
+	| ZipDirectoryEntry;
 export type Zip = {
 	comment: string;
 	entries: ZipEntry[];

package/src/zipParser.ts

@@ -144,17 +144,13 @@ type ZipDataDescriptor = {
 };
 
 const zipDataDescriptorSignature: Uint8Array = Buffer.from('504b0708', 'hex');
-const zipDataDescriptorSignatureParser = createExactSequenceParser<Uint8Array>(
-	zipDataDescriptorSignature
-);
+const zipDataDescriptorSignatureParser = createExactSequenceParser<Uint8Array>(zipDataDescriptorSignature);
 
 const zipDataDescriptorParser: Parser<ZipDataDescriptor, Uint8Array> = promiseCompose(
 	createTupleParser([
-		createNegativeLookaheadParser(
-			zipLocalFileHeaderSignatureParser,
-		),
+		createNegativeLookaheadParser(zipLocalFileHeaderSignatureParser),
 		// FIXME: optional in spec
-		//createOptionalParser(zipDataDescriptorSignatureParser),
+		// createOptionalParser(zipDataDescriptorSignatureParser),
 		zipDataDescriptorSignatureParser,
 		uint32LEParser,
 		uint32LEParser,
@@ -186,12 +182,10 @@ export const zipLocalFileParser: Parser<ZipLocalFile, Uint8Array> = promiseCompo
 	parserCreatorCompose(
 		() => zipLocalFileHeaderParser,
 		zipLocalFileHeader => {
-			const sizeInDataDescriptor = Boolean(
-				zipLocalFileHeader.generalPurposeBitFlag & 0b0000_0000_0000_1000
-					&& zipLocalFileHeader.crc32 === 0
-					&& zipLocalFileHeader.compressedSize === 0
-					&& zipLocalFileHeader.uncompressedSize === 0
-			);
+			const sizeInDataDescriptor = Boolean(zipLocalFileHeader.generalPurposeBitFlag & 0b0000_0000_0000_1000
+				&& zipLocalFileHeader.crc32 === 0
+				&& zipLocalFileHeader.compressedSize === 0
+				&& zipLocalFileHeader.uncompressedSize === 0);
 
 			return createTupleParser([
 				async () => zipLocalFileHeader,
@@ -210,9 +204,7 @@ export const zipLocalFileParser: Parser<ZipLocalFile, Uint8Array> = promiseCompo
 					sizeInDataDescriptor
 						? (<T>(parser: T): T => parser)
 						: createOptionalParser
-				)(
-					zipDataDescriptorParser
-				),
+				)(zipDataDescriptorParser),
 			]);
 		},
 	)(),
@@ -257,7 +249,7 @@ const zipVersionMadeByParser: Parser<ZipVersionMadeBy, Uint8Array> = promiseComp
 
 type ZipExternalFileAttributes = {
 	directory: boolean;
-}
+};
 
 const dosExternalFileAttributesParser: Parser<ZipExternalFileAttributes, Uint8Array> = promiseCompose(
 	uint32LEParser,
@@ -499,7 +491,7 @@ export async function zipEntriesFromZipSegments({
 
 		const isDirectory = (
 			centralDirectoryHeader.externalFileAttributes.directory
-				|| commonFields.path.endsWith('/')
+			|| commonFields.path.endsWith('/')
 		);
 
 		if (isDirectory) {

package/src/zipUnparser.test.ts

@@ -1,7 +1,7 @@
+import fsPromises from 'node:fs/promises';
 import { fc, testProp } from '@fast-check/ava';
 import { temporaryFile } from 'tempy';
 import { execa } from 'execa';
-import fsPromises from 'node:fs/promises';
 import { runUnparser } from './unparser.js';
 import { createZipUnparser } from './zipUnparser.js';
 import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';