@futpib/parser 1.0.1 → 1.0.3

package/src/unionParser.ts

@@ -1,52 +1,74 @@
 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 { type DeriveSequenceElement } from './sequence.js';
+
+const bigintReplacer = (_key: string, value: unknown) => {
+	if (typeof value === 'bigint') {
+		return `${value}n`;
+	}
+
+	return value;
+};
 
 export const createUnionParser = <
 	Output,
 	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
 >(
-	childParsers: Array<Parser<any, Sequence, any>>,
-): Parser<Output, Sequence, unknown> => {
+	childParsers: Array<Parser<unknown, Sequence, Element>>,
+): Parser<Output, Sequence, Element> => {
 	parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
 
-	const unionParser: Parser<Output, Sequence, unknown> = async parserContext => {
-		let runningChildParserContexts: Array<ParserContext<unknown, unknown>> = [];
+	type TaskContext = {
+		childParser: Parser<unknown, Sequence, Element>;
+		childParserContext: ParserContext<Sequence, Element>;
+	};
+
+	const unionParser: Parser<Output, Sequence, Element> = async parserContext => {
+		let runningChildParserContexts: TaskContext[] = [];
 
-		const childParserResults = allSettledStream(childParsers.map(childParser => {
+		const createChildParserTask = (childParser: Parser<unknown, Sequence, Element>) => {
 			const childParserContext = parserContext.lookahead({
 				debugName: getParserName(childParser, 'anonymousUnionChild'),
 			});
 
-			runningChildParserContexts.push(childParserContext);
+			const context: TaskContext = {
+				childParser,
+				childParserContext,
+			};
+
+			runningChildParserContexts.push(context);
+
+			const getChildParserPromise = (async () => childParser(childParserContext) as Promise<Output>);
 
-			const promise = childParser(childParserContext);
+			const promise = getChildParserPromise();
 
 			return {
 				promise,
-				context: childParserContext,
+				context,
 			};
-		}));
+		};
+
+		const childParserResults = allSettledStream<Output, TaskContext>(childParsers.map(createChildParserTask));
 
 		const parserParsingFailedErrors: ParserParsingFailedError[] = [];
 		const successfulParserOutputs: Output[] = [];
-		const successfulParserContexts: Array<ParserContext<unknown, unknown>> = [];
+		const successfulTaskContexts: TaskContext[] = [];
 		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);
-				successfulParserContexts.push(childParserResult.context);
+				successfulTaskContexts.push(childParserResult.context);
 			} else {
 				const error = childParserResult.reason;
 
-				if (error instanceof ParserParsingFailedError) {
+				if (isParserParsingFailedError(error)) {
 					parserParsingFailedErrors.push(error);
 				} else {
 					throw error;
@@ -60,7 +82,7 @@ export const createUnionParser = <
 				parserImplementationInvariant(!didUnlookahead, 'Union parser unlookaheaded multiple times.');
 				didUnlookahead = true;
 				const [ runningChildParserContext ] = runningChildParserContexts;
-				runningChildParserContext.unlookahead();
+				runningChildParserContext.childParserContext.unlookahead();
 			}
 		}
 
@@ -71,8 +93,12 @@ export const createUnionParser = <
 				'Successful parser outputs, indented, separated by newlines:',
 				'%s',
 				'End of successful parser outputs.',
+				'Successful parser names, indented, separated by newlines:',
+				'%s',
+				'End of successful parser names.',
 			],
-			() => successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'),
+			() => successfulParserOutputs.map(output => '  ' + JSON.stringify(output, bigintReplacer)).join('\n'),
+			() => successfulTaskContexts.map(taskContext => '  ' + getParserName(taskContext.childParser, 'anonymousUnionChild')).join('\n'),
 		);
 
 		parserContext.invariantJoin(
@@ -81,13 +107,13 @@ export const createUnionParser = <
 			'No union child parser succeeded.',
 		);
 
-		const [ successfulParserContext ] = successfulParserContexts;
+		const [ successfulParserContext ] = successfulTaskContexts;
 
 		if (!didUnlookahead) {
-			successfulParserContext.unlookahead();
+			successfulParserContext.childParserContext.unlookahead();
 		}
 
-		successfulParserContext.dispose();
+		successfulParserContext.childParserContext.dispose();
 
 		const [ successfulParserOutput ] = successfulParserOutputs;
 

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

@@ -18,6 +18,8 @@ import {
 	type ZipFileEntry,
 } from './zip.js';
 import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createSequenceTerminatedSequenceParser } from './sequenceTerminatedSequenceParser.js';
 
 // https://pkwaredownloads.blob.core.windows.net/pem/APPNOTE.txt
 
@@ -65,7 +67,7 @@ const zipCompressionMethodParser: Parser<ZipCompression, Uint8Array> = promiseCo
 	},
 );
 
-type ZipLocalFileHeader = {
+export type ZipLocalFileHeader = {
 	versionNeededToExtract: number;
 	generalPurposeBitFlag: number;
 	compressionMethod: ZipCompression;
@@ -78,8 +80,10 @@ type ZipLocalFileHeader = {
 	extraField: Uint8Array;
 };
 
+const zipLocalFileHeaderSignatureParser = createExactSequenceParser<Uint8Array>(Buffer.from('504b0304', 'hex'));
+
 const zipLocalFileHeaderParser_ = createTupleParser([
-	createExactSequenceParser<Uint8Array>(Buffer.from('504b0304', 'hex')),
+	zipLocalFileHeaderSignatureParser,
 	uint16LEParser,
 	uint16LEParser,
 	zipCompressionMethodParser,
@@ -133,31 +137,76 @@ const zipEncryptionHeaderParser: Parser<unknown, Uint8Array> = async parserConte
 	parserContext.invariant(false, 'Not implemented');
 };
 
-const zipDataDescriptorParser: Parser<unknown, Uint8Array> = createTupleParser([
-	// FIXME: optional in spec
-	// createOptionalParser(createExactSequenceParser<Uint8Array>(Buffer.from('504b0708', 'hex'))),
-	createExactSequenceParser<Uint8Array>(Buffer.from('504b0708', 'hex')),
-	uint32LEParser,
-	uint32LEParser,
-	uint32LEParser,
-]);
+type ZipDataDescriptor = {
+	crc32: number;
+	compressedSize: number;
+	uncompressedSize: number;
+};
+
+const zipDataDescriptorSignature: Uint8Array = Buffer.from('504b0708', 'hex');
+const zipDataDescriptorSignatureParser = createExactSequenceParser<Uint8Array>(zipDataDescriptorSignature);
+
+const zipDataDescriptorParser: Parser<ZipDataDescriptor, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createNegativeLookaheadParser(zipLocalFileHeaderSignatureParser),
+		// FIXME: optional in spec
+		// createOptionalParser(zipDataDescriptorSignatureParser),
+		zipDataDescriptorSignatureParser,
+		uint32LEParser,
+		uint32LEParser,
+		uint32LEParser,
+	]),
+	([
+		_notZipLocalFileHeaderSignature,
+		_zipDataDescriptorSignature,
+		crc32,
+		compressedSize,
+		uncompressedSize,
+	]) => ({
+		crc32,
+		compressedSize,
+		uncompressedSize,
+	}),
+);
+
+setParserName(zipDataDescriptorParser, 'zipDataDescriptorParser');
 
 export type ZipLocalFile = {
 	zipLocalFileHeader: ZipLocalFileHeader;
 	zipEncryptionHeader: unknown;
 	compressedData: Uint8Array;
-	zipDataDescriptor: unknown;
+	zipDataDescriptor: undefined | ZipDataDescriptor;
 };
 
 export const zipLocalFileParser: Parser<ZipLocalFile, Uint8Array> = promiseCompose(
 	parserCreatorCompose(
 		() => zipLocalFileHeaderParser,
-		zipLocalFileHeader => createTupleParser([
-			async () => zipLocalFileHeader,
-			createOptionalParser(zipEncryptionHeaderParser),
-			createFixedLengthSequenceParser(zipLocalFileHeader.compressedSize),
-			createOptionalParser(zipDataDescriptorParser),
-		]),
+		zipLocalFileHeader => {
+			const sizeInDataDescriptor = Boolean(zipLocalFileHeader.generalPurposeBitFlag & 0b0000_0000_0000_1000
+				&& zipLocalFileHeader.crc32 === 0
+				&& zipLocalFileHeader.compressedSize === 0
+				&& zipLocalFileHeader.uncompressedSize === 0);
+
+			return createTupleParser([
+				async () => zipLocalFileHeader,
+				createOptionalParser(zipEncryptionHeaderParser),
+				(
+					sizeInDataDescriptor
+						? createSequenceTerminatedSequenceParser(
+							zipDataDescriptorSignature,
+							{
+								consumeTerminator: false,
+							},
+						)
+						: createFixedLengthSequenceParser(zipLocalFileHeader.compressedSize)
+				),
+				(
+					sizeInDataDescriptor
+						? (<T>(parser: T): T => parser)
+						: createOptionalParser
+				)(zipDataDescriptorParser),
+			]);
+		},
 	)(),
 	([
 		zipLocalFileHeader,
@@ -200,7 +249,7 @@ const zipVersionMadeByParser: Parser<ZipVersionMadeBy, Uint8Array> = promiseComp
 
 type ZipExternalFileAttributes = {
 	directory: boolean;
-}
+};
 
 const dosExternalFileAttributesParser: Parser<ZipExternalFileAttributes, Uint8Array> = promiseCompose(
 	uint32LEParser,
@@ -373,7 +422,7 @@ const zipEndOfCentralDirectoryRecordParser_ = createTupleParser([
 	zipFileCommentParser,
 ]);
 
-setParserName(zipEndOfCentralDirectoryRecordParser_, 'endOfCentralDirectoryRecordParser_');
+setParserName(zipEndOfCentralDirectoryRecordParser_, 'zipEndOfCentralDirectoryRecordParser_');
 
 export const zipEndOfCentralDirectoryRecordParser: Parser<ZipEndOfCentralDirectoryRecord, Uint8Array> = promiseCompose(
 	zipEndOfCentralDirectoryRecordParser_,
@@ -397,6 +446,8 @@ export const zipEndOfCentralDirectoryRecordParser: Parser<ZipEndOfCentralDirecto
 	}),
 );
 
+setParserName(zipEndOfCentralDirectoryRecordParser, 'zipEndOfCentralDirectoryRecordParser');
+
 const zipParser_ = createTupleParser([
 	createArrayParser(zipLocalFileParser),
 	createOptionalParser(zipArchiveDecryptionHeaderParser),
@@ -440,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,24 +1,15 @@
-import { testProp } from '@fast-check/ava';
+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 { zipUnparser } from './zipUnparser.js';
+import { createZipUnparser } from './zipUnparser.js';
 import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
 import { runParser } from './parser.js';
 import { zipParser } from './zipParser.js';
 import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { arbitraryZip } from './arbitraryZip.js';
-
-async function hasExecutable(executable: string) {
-	const hasExecutable = execa(executable).then(() => true, () => false);
-
-	if (!hasExecutable) {
-		console.warn(`Executable %o not found`, executable);
-	}
-
-	return hasExecutable;
-}
+import { hasExecutable } from './hasExecutable.js';
 
 const hasZipinfoPromise = hasExecutable('zipinfo');
 const has7zPromise = hasExecutable('7z');
@@ -57,21 +48,30 @@ testProp(
 	'zip',
 	[
 		arbitraryZip,
+		fc.record({
+			dataDescriptor: fc.boolean(),
+		}),
 	],
-	async (t, zip) => {
-		const actualStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
-		const actual = await runParser(zipParser, actualStream, uint8ArrayParserInputCompanion);
+	async (t, zip, options) => {
+		const zipUnparser = createZipUnparser(options);
 
-		const isDeepEqual = t.deepEqual(actual, zip);
+		{
+			const zipStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
 
-		if (!isDeepEqual) {
-			return;
+			await fsPromises.writeFile('/tmp/zip.zip', zipStream);
 		}
 
+		const actualStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
+		const actual = await runParser(zipParser, actualStream, uint8ArrayParserInputCompanion);
+
+		t.deepEqual(actual, zip);
+
 		const hasZipinfo = await hasZipinfoPromise;
 		const has7z = await has7zPromise;
 
 		if (!hasZipinfo && !has7z) {
+			t.pass('no zipinfo or 7z, skipping zipfile check');
+
 			return;
 		}