@futpib/parser 1.0.0 → 1.0.2

package/src/zipUnparser.ts

@@ -0,0 +1,300 @@
+import zlib from 'node:zlib';
+import { Unparser } from "./unparser.js";
+import { Zip, ZipEntry, ZipFileEntry } from "./zip.js";
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { ZipEndOfCentralDirectoryRecord, ZipLocalFileHeader } from './zipParser.js';
+import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
+
+const uint16LEUnparser: Unparser<number, Uint8Array> = async function * (uint16LE) {
+	const buffer = Buffer.alloc(2);
+	buffer.writeUInt16LE(uint16LE);
+	yield buffer;
+}
+
+const uint32LEUnparser: Unparser<number, Uint8Array> = async function * (uint32LE) {
+	const buffer = Buffer.alloc(4);
+	buffer.writeUInt32LE(uint32LE);
+	yield buffer;
+}
+
+const uint16LEPrefixedUint8ArrayUnparser: Unparser<Uint8Array, Uint8Array> = async function * (uint8Array, unparserContext) {
+	yield * uint16LEUnparser(uint8Array.length, unparserContext);
+	yield uint8Array;
+}
+
+const uint16LEPrefixedStringUnparser: Unparser<string, Uint8Array> = async function * (string, unparserContext) {
+	yield * uint16LEPrefixedUint8ArrayUnparser(Buffer.from(string, 'utf8'), unparserContext);
+}
+
+const dosDateTimeUnparser: Unparser<Date, Uint8Array> = async function * (date, unparserContext) {
+	yield * uint16LEUnparser(
+		(
+			date.getUTCSeconds() / 2
+				| date.getUTCMinutes() << 5
+				| date.getUTCHours() << 11
+		),
+		unparserContext,
+	);
+	yield * uint16LEUnparser(
+		(
+			date.getUTCDate()
+				| (date.getUTCMonth() + 1) << 5
+				| (date.getUTCFullYear() - 1980) << 9
+		),
+		unparserContext,
+	);
+}
+
+const zipCompressionMethodUnparser: Unparser<'store' | 'deflate', Uint8Array> = async function * (compressionMethod, unparserContext) {
+	if (compressionMethod === 'store') {
+		yield * uint16LEUnparser(0, unparserContext);
+	} else {
+		yield * uint16LEUnparser(8, unparserContext);
+	}
+}
+
+export const zipEndOfCentralDirectoryRecordUnparser: Unparser<ZipEndOfCentralDirectoryRecord, Uint8Array> = async function * (zipEndOfCentralDirectoryRecord, unparserContext) {
+	yield Buffer.from('504b0506', 'hex');
+	yield * uint16LEUnparser(zipEndOfCentralDirectoryRecord.numberOfThisDisk, unparserContext);
+	yield * uint16LEUnparser(zipEndOfCentralDirectoryRecord.numberOfTheDiskWithTheStartOfTheCentralDirectory, unparserContext);
+	yield * uint16LEUnparser(zipEndOfCentralDirectoryRecord.totalNumberOfEntriesInTheCentralDirectoryOnThisDisk, unparserContext);
+	yield * uint16LEUnparser(zipEndOfCentralDirectoryRecord.totalNumberOfEntriesInTheCentralDirectory, unparserContext);
+	yield * uint32LEUnparser(zipEndOfCentralDirectoryRecord.sizeOfTheCentralDirectory, unparserContext);
+	yield * uint32LEUnparser(zipEndOfCentralDirectoryRecord.offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber, unparserContext);
+
+	yield * uint16LEPrefixedStringUnparser(zipEndOfCentralDirectoryRecord.zipFileComment, unparserContext);
+}
+
+const zipDataDescriptorUnparser: Unparser<{
+	crc32: number;
+	compressedSize: number;
+	uncompressedSize: number;
+}, Uint8Array> = async function * ({
+	crc32,
+	compressedSize,
+	uncompressedSize,
+}, unparserContext) {
+	yield Buffer.from('504b0708', 'hex');
+	yield * uint32LEUnparser(crc32, unparserContext);
+	yield * uint32LEUnparser(compressedSize, unparserContext);
+	yield * uint32LEUnparser(uncompressedSize, unparserContext);
+}
+
+const zipLocalFileHeaderUnparser: Unparser<ZipLocalFileHeader, Uint8Array> = async function * ({
+	versionNeededToExtract,
+	generalPurposeBitFlag,
+	compressionMethod,
+	lastModifiedFile,
+	crc32,
+	compressedSize,
+	uncompressedSize,
+
+	filePath,
+	extraField,
+}, unparserContext) {
+	yield Buffer.from('504b0304', 'hex');
+
+	yield * uint16LEUnparser(versionNeededToExtract, unparserContext);
+	yield * uint16LEUnparser(generalPurposeBitFlag, unparserContext);
+	yield * zipCompressionMethodUnparser(compressionMethod, unparserContext);
+	yield * dosDateTimeUnparser(lastModifiedFile, unparserContext);
+	yield * uint32LEUnparser(crc32, unparserContext);
+	yield * uint32LEUnparser(compressedSize, unparserContext);
+	yield * uint32LEUnparser(uncompressedSize, unparserContext);
+
+	const filePathBuffer = Buffer.from(filePath, 'utf8');
+
+	yield * uint16LEUnparser(filePathBuffer.length, unparserContext);
+	yield * uint16LEUnparser(extraField.length, unparserContext);
+	yield filePathBuffer;
+	yield extraField;
+};
+
+export const createZipUnparser = ({
+	dataDescriptor = false,
+}: {
+	dataDescriptor?: boolean;
+} = {}): Unparser<Zip, Uint8Array> => async function * (zip, unparserContext) {
+	const compressedContentByZipFileEntry = new Map<ZipFileEntry, undefined | Promise<Uint8Array>>(
+		zip.entries.flatMap(zipEntry => {
+			if (zipEntry.type !== 'file') {
+				return [];
+			}
+
+			if (zipEntry.compression === 'store') {
+				return [[zipEntry, Promise.resolve(zipEntry.content)]];
+			}
+
+			const uncompressedContent = zipEntry.content;
+
+			const deflate = zlib.createDeflateRaw();
+			const input = Readable.from(Buffer.from(uncompressedContent));
+
+			const promise = Promise.all([
+				pipeline(input, deflate),
+				uint8ArrayAsyncIterableToUint8Array(deflate),
+			]);
+
+			return [[zipEntry, promise.then(([, compressedContent]) => compressedContent)]];
+		}),
+	);
+
+	const filePathByZipEntry = new Map<ZipEntry, string>(
+		zip.entries.map(zipEntry => [zipEntry, zipEntry.type === 'file' ? zipEntry.path : zipEntry.path + '/']),
+	);
+
+	const localHeaderPositionByZipEntry = new Map<ZipEntry, number>();
+
+	for (const zipEntry of zip.entries) {
+		localHeaderPositionByZipEntry.set(zipEntry, unparserContext.position);
+
+		const filePath = filePathByZipEntry.get(zipEntry)!;
+
+		const zipLocalFileHeader: ZipLocalFileHeader = {
+			versionNeededToExtract: 20,
+			generalPurposeBitFlag: 0,
+			compressionMethod: 'store',
+			lastModifiedFile: zipEntry.date,
+			crc32: 0,
+			compressedSize: 0,
+			uncompressedSize: 0,
+			filePath,
+			extraField: Buffer.alloc(0),
+		};
+
+		let shouldWriteDataDescriptor = false;
+
+		if (zipEntry.type === 'file') {
+			const compressedContent = await compressedContentByZipFileEntry.get(zipEntry)!;
+
+			zipLocalFileHeader.compressionMethod = zipEntry.compression;
+			zipLocalFileHeader.crc32 = 0; // TODO
+			zipLocalFileHeader.compressedSize = compressedContent.length;
+			zipLocalFileHeader.uncompressedSize = zipEntry.content.length;
+
+			if (dataDescriptor) {
+				shouldWriteDataDescriptor = true;
+
+				zipLocalFileHeader.generalPurposeBitFlag |= 0b0000_0000_0000_1000;
+				zipLocalFileHeader.crc32 = 0;
+				zipLocalFileHeader.compressedSize = 0;
+				zipLocalFileHeader.uncompressedSize = 0;
+			}
+		}
+
+		yield * zipLocalFileHeaderUnparser(zipLocalFileHeader, unparserContext);
+
+		if (zipEntry.type === 'file') {
+			const compressedContent = await compressedContentByZipFileEntry.get(zipEntry)!;
+
+			yield compressedContent;
+
+			if (shouldWriteDataDescriptor) {
+				yield * zipDataDescriptorUnparser({
+					crc32: zipLocalFileHeader.crc32,
+					compressedSize: zipLocalFileHeader.compressedSize,
+					uncompressedSize: zipLocalFileHeader.uncompressedSize,
+				}, unparserContext);
+			}
+		}
+	}
+
+	const startOfCentralDirectoryPosition = unparserContext.position;
+
+	for (const zipEntry of zip.entries) {
+		yield Buffer.from('504b0102', 'hex');
+
+		if (zipEntry.hostSystem === 'unix') {
+			yield 0; // zip specification version
+			yield 3; // host system
+		} else {
+			yield 0;
+			yield 0;
+		}
+
+		yield * uint16LEUnparser(0, unparserContext); // version needed to extract
+		yield * uint16LEUnparser(0, unparserContext); // general purpose bit flag
+
+		if (zipEntry.type === 'file') {
+			yield * zipCompressionMethodUnparser(zipEntry.compression, unparserContext);
+		} else {
+			yield * uint16LEUnparser(0, unparserContext);
+		}
+
+		yield * dosDateTimeUnparser(zipEntry.date, unparserContext);
+
+		if (zipEntry.type === 'file') {
+			const compressedContent = await compressedContentByZipFileEntry.get(zipEntry)!;
+
+			yield * uint32LEUnparser(0, unparserContext); // crc32 // TODO
+			yield * uint32LEUnparser(compressedContent.length, unparserContext);
+			yield * uint32LEUnparser(zipEntry.content.length, unparserContext);
+		} else {
+			yield * uint32LEUnparser(0, unparserContext);
+			yield * uint32LEUnparser(0, unparserContext);
+			yield * uint32LEUnparser(0, unparserContext);
+		}
+
+		const filePath = filePathByZipEntry.get(zipEntry)!;
+
+		const filePathBuffer = Buffer.from(filePath, 'utf8');
+		yield * uint16LEUnparser(filePathBuffer.length, unparserContext);
+		const extraFieldBuffer = Buffer.alloc(0);
+		yield * uint16LEUnparser(extraFieldBuffer.length, unparserContext);
+		const fileCommentBuffer = Buffer.from(zipEntry.comment, 'utf8');
+		yield * uint16LEUnparser(fileCommentBuffer.length, unparserContext);
+
+		yield * uint16LEUnparser(0, unparserContext); // disk number start
+		yield * uint16LEUnparser(0, unparserContext); // internal file attributes
+
+		if (zipEntry.hostSystem === 'unix') {
+			yield * uint32LEUnparser(
+				(
+					0
+						| (
+							zipEntry.type === 'directory'
+								? (0b0100_0000_0000_0000 << 16)
+								: (0b1000_0000_0000_0000 << 16)
+						)
+				) >>> 0,
+				unparserContext,
+			);
+		} else {
+			yield * uint32LEUnparser(
+				(
+					0
+						| (
+							zipEntry.type === 'directory'
+								? 0b0001_0000
+								: 0
+						)
+				),
+				unparserContext,
+			);
+		}
+
+		const localHeaderPosition = localHeaderPositionByZipEntry.get(zipEntry)!;
+
+		yield * uint32LEUnparser(localHeaderPosition, unparserContext);
+
+		yield filePathBuffer;
+		yield extraFieldBuffer;
+		yield fileCommentBuffer;
+	}
+
+	const endOfCentralDirectoryPosition = unparserContext.position;
+	const sizeOfTheCentralDirectory = endOfCentralDirectoryPosition - startOfCentralDirectoryPosition;
+
+	yield * zipEndOfCentralDirectoryRecordUnparser({
+		numberOfThisDisk: 0,
+		numberOfTheDiskWithTheStartOfTheCentralDirectory: 0,
+		totalNumberOfEntriesInTheCentralDirectoryOnThisDisk: zip.entries.length,
+		totalNumberOfEntriesInTheCentralDirectory: zip.entries.length,
+		sizeOfTheCentralDirectory,
+		offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber: startOfCentralDirectoryPosition,
+		zipFileComment: zip.comment,
+	}, unparserContext);
+}
+
+export const zipUnparser = createZipUnparser();

package/build/apk.d.ts

@@ -1,13 +0,0 @@
-import { Zip } from './zip.js';
-export type ApkSigningBlockPair = {
-    id: number;
-    value: Uint8Array;
-};
-export type ApkSigningBlock = {
-    zeroPaddingLength?: number;
-    signatureV2?: unknown;
-    pairs: ApkSigningBlockPair[];
-};
-export type Apk = Zip & {
-    signingBlock?: ApkSigningBlock;
-};

package/build/apkParser.d.ts

@@ -1,3 +0,0 @@
-import { Parser } from "./parser.js";
-import { Apk } from "./apk.js";
-export declare const apkParser: Parser<Apk, Uint8Array>;

package/build/apkParser.js

@@ -1,135 +0,0 @@
-import { createArrayParser } from "./arrayParser.js";
-import { createOptionalParser } from "./optionalParser.js";
-import { setParserName } from "./parser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createTupleParser } from "./tupleParser.js";
-import { zip64EndOfCentralDirectoryLocatorParser, zip64EndOfCentralDirectoryRecordParser, zipArchiveDecryptionHeaderParser, zipArchiveExtraDataRecordParser, zipCentralDirectoryHeaderParser, zipEndOfCentralDirectoryRecordParser, zipFromZipSegments, zipLocalFileParser } from "./zipParser.js";
-import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
-import { parserCreatorCompose } from "./parserCreatorCompose.js";
-import { createExactSequenceParser } from "./exactSequenceParser.js";
-import { createSliceBoundedParser } from "./sliceBoundedParser.js";
-import { createDisjunctionParser } from "./disjunctionParser.js";
-import invariant from "invariant";
-import { createExactElementParser } from "./exactElementParser.js";
-// https://source.android.com/docs/security/features/apksigning/v2#apk-signing-block
-const uint32LEParser = promiseCompose(createFixedLengthSequenceParser(4), array => Buffer.from(array).readUInt32LE());
-setParserName(uint32LEParser, 'uint32LEParser');
-const uint64LEParser = promiseCompose(createFixedLengthSequenceParser(8), array => Buffer.from(array).readBigUInt64LE());
-setParserName(uint64LEParser, 'uint64LEParser');
-const createUint32LengthPrefixedParser = (createInnerParser) => parserCreatorCompose(() => uint32LEParser, length => createInnerParser(length))();
-const createUint64LengthPrefixedParser = (createInnerParser) => parserCreatorCompose(() => uint64LEParser, length => createInnerParser(length))();
-const createUint32LengthPrefixedSliceBoundedParser = (innerParser) => createUint32LengthPrefixedParser(length => createSliceBoundedParser(innerParser, length));
-const createUint32LengthPrefixedSliceBoundedArrayParser = (innerParser) => createUint32LengthPrefixedSliceBoundedParser(createArrayParser(innerParser));
-const createApkSigningBlockZeroPaddingPairInnerParser = (length) => promiseCompose(createTupleParser([
-    createExactSequenceParser(Buffer.from('77657242', 'hex')),
-    createFixedLengthSequenceParser(length - 4),
-]), ([_magic, zeroPadding]) => ({ type: 'zeroPadding', length: zeroPadding.length }));
-const createApkSigningBlockSignatureV2PairInnerParser = (length) => {
-    const apkSigningBlockSignatureV2PairInnerParser = promiseCompose(createTupleParser([
-        createExactSequenceParser(Buffer.from('1a870971', 'hex')),
-        apkSignatureSchemeV2SignersParser,
-    ]), ([_magic, signers = []]) => ({ type: 'signatureV2', signers }));
-    return setParserName(apkSigningBlockSignatureV2PairInnerParser, 'apkSigningBlockSignatureV2PairInnerParser');
-};
-const createApkSigningBlockGenericPairInnerParser = (length) => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createFixedLengthSequenceParser(length - 4),
-]), ([id, value]) => ({ type: 'generic', pair: { id, value } }));
-const createApkSigningBlockPairInnerParser = (length) => createDisjunctionParser([
-    createApkSigningBlockZeroPaddingPairInnerParser(length),
-    createApkSigningBlockSignatureV2PairInnerParser(length),
-    createApkSigningBlockGenericPairInnerParser(length),
-]);
-const apkSigningBlockPairParser = createUint64LengthPrefixedParser(length => createApkSigningBlockPairInnerParser(Number(length)));
-setParserName(apkSigningBlockPairParser, 'apkSigningBlockPairParser');
-const apkSigningBlockPairsParser = createArrayParser(apkSigningBlockPairParser);
-const apkSigningBlockParser = createUint64LengthPrefixedParser(sizeOfBlock => promiseCompose(createTupleParser([
-    apkSigningBlockPairsParser,
-    uint64LEParser,
-    createExactSequenceParser(Buffer.from('APK Sig Block 42', 'utf8')),
-]), async ([pairs, sizeOfBlockRepeated, _magic]) => {
-    invariant(sizeOfBlock === sizeOfBlockRepeated, 'Size of block mismatch: %s !== %s.', sizeOfBlock, sizeOfBlockRepeated);
-    const zeroPaddingPair = pairs.find(pair => pair.type === 'zeroPadding');
-    const signatureV2Pair = pairs.find(pair => pair.type === 'signatureV2');
-    const genericPairs = (pairs
-        .filter(pair => (pair !== zeroPaddingPair
-        && pair !== signatureV2Pair))
-        .map(pair => {
-        invariant(pair.type === 'generic', 'Expected generic pair, got %s.', pair.type);
-        return pair.pair;
-    }));
-    return {
-        zeroPaddingLength: zeroPaddingPair?.length,
-        signatureV2: signatureV2Pair?.signers,
-        pairs: genericPairs,
-    };
-}));
-const apkSignatureSchemeV2DigestParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
-]), ([signatureAlgorithmId, digest]) => ({ signatureAlgorithmId, digest })));
-const apkSignatureSchemeV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2DigestParser);
-const apkSignatureSchemeV2CertificateParser = createUint32LengthPrefixedParser(certificateLength => createFixedLengthSequenceParser(certificateLength));
-const apkSignatureSchemeV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2CertificateParser);
-const apkSignatureSchemeV2AdditionalAttributeParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createFixedLengthSequenceParser(pairLength - 4),
-]), ([id, value]) => ({ id, value })));
-const apkSignatureSchemeV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2AdditionalAttributeParser);
-const apkSignatureSchemeV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    apkSignatureSchemeV2DigestsParser,
-    apkSignatureSchemeV2CertificatesParser,
-    createOptionalParser(apkSignatureSchemeV2AdditionalAttributesParser),
-    createArrayParser(createExactElementParser(0)),
-]), ([digests = [], certificates = [], additionalAttributes = [],]) => ({
-    digests,
-    certificates,
-    additionalAttributes,
-})));
-setParserName(apkSignatureSchemeV2SignedDataParser, 'apkSignatureSchemeV2SignedDataParser');
-const apkSignatureSchemeV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
-]), ([signatureAlgorithmId, signature,]) => ({
-    signatureAlgorithmId,
-    signature,
-})));
-const apkSignatureSchemeV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2SignatureParser);
-setParserName(apkSignatureSchemeV2SignaturesParser, 'apkSignatureSchemeV2SignaturesParser');
-const apkSignatureSchemeV2PublicKeyParser = createUint32LengthPrefixedParser(publicKeyLength => createFixedLengthSequenceParser(publicKeyLength));
-setParserName(apkSignatureSchemeV2PublicKeyParser, 'apkSignatureSchemeV2PublicKeyParser');
-const apkSignatureSchemeV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    apkSignatureSchemeV2SignedDataParser,
-    apkSignatureSchemeV2SignaturesParser,
-    apkSignatureSchemeV2PublicKeyParser,
-]), ([signedData, signatures = [], publicKey]) => ({
-    signedData,
-    signatures,
-    publicKey,
-})));
-setParserName(apkSignatureSchemeV2SignerParser, 'apkSignatureSchemeV2SignerParser');
-const apkSignatureSchemeV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2SignerParser);
-setParserName(apkSignatureSchemeV2SignersParser, 'apkSignatureSchemeV2SignersParser');
-const apkParser_ = createTupleParser([
-    createArrayParser(zipLocalFileParser),
-    createOptionalParser(zipArchiveDecryptionHeaderParser),
-    createOptionalParser(zipArchiveExtraDataRecordParser),
-    createOptionalParser(apkSigningBlockParser),
-    createArrayParser(zipCentralDirectoryHeaderParser),
-    createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
-    createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
-    zipEndOfCentralDirectoryRecordParser,
-]);
-setParserName(apkParser_, 'apkParser_');
-export const apkParser = promiseCompose(apkParser_, async ([zipLocalFiles, zipArchiveDecryptionHeader, zipArchiveExtraDataRecord, apkSigningBlock, zipCentralDirectoryHeaders, zip64EndOfCentralDirectoryRecord, zip64EndOfCentralDirectoryLocator, zipEndOfCentralDirectoryRecord,]) => {
-    const zip = await zipFromZipSegments({
-        zipLocalFiles,
-        zipCentralDirectoryHeaders,
-        zipEndOfCentralDirectoryRecord,
-    });
-    return {
-        ...zip,
-        signingBlock: apkSigningBlock,
-    };
-});
-setParserName(apkParser, 'apkParser');

package/build/arbitraryDosDate.d.ts

@@ -1,2 +0,0 @@
-import * as fc from 'fast-check';
-export declare const arbitraryDosDateTime: fc.Arbitrary<Date>;

package/build/arbitraryDosDate.js

@@ -1,8 +0,0 @@
-import * as fc from 'fast-check';
-export const arbitraryDosDateTime = fc.date({
-    min: new Date(Date.UTC(1980, 0, 1)),
-    max: new Date(Date.UTC(2099, 11, 31)),
-}).map(date => {
-    date.setMilliseconds(0);
-    return date;
-});

package/build/arbitraryZipEntry.d.ts

@@ -1,3 +0,0 @@
-import * as fc from 'fast-check';
-import { ZipDirectoryEntry, ZipFileEntry } from './zip.js';
-export declare const arbitraryZipEntry: fc.Arbitrary<ZipFileEntry | ZipDirectoryEntry>;

package/build/arbitraryZipEntry.js

@@ -1,26 +0,0 @@
-import * as fc from 'fast-check';
-export const arbitraryZipEntry = fc.letrec((tie) => ({
-    entry: fc.oneof(fc.record({
-        type: fc.constant('file'),
-        name: fc.string({ minLength: 1 }),
-        date: fc.date(),
-        comment: fc.uint8Array(),
-        unixPermissions: fc.integer(),
-        dosPermissions: fc.integer(),
-        compression: fc.oneof(fc.record({
-            type: fc.constant('store'),
-        }), fc.record({
-            type: fc.constant('deflate'),
-            level: fc.nat({ max: 9 }),
-        })),
-        content: fc.uint8Array(),
-    }), fc.record({
-        type: fc.constant('directory'),
-        name: fc.string({ minLength: 1 }),
-        date: fc.date(),
-        comment: fc.uint8Array(),
-        unixPermissions: fc.integer(),
-        dosPermissions: fc.integer(),
-        entries: fc.array(tie('entry')),
-    })),
-})).entry;

package/build/createDisjunctionParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createDisjunctionParser: <Output, Sequence>(childParsers: Parser<any, Sequence, any>[]) => Parser<Output, Sequence, unknown>;

package/build/createDisjunctionParser.js

@@ -1,47 +0,0 @@
-import { ParserParsingFailedError } from './parserError.js';
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { parserParsingInvariant } from './parserParsingInvariant.js';
-function getParserName(parser) {
-    return parser.name || 'anonymousDisjunctionChild';
-}
-export const createDisjunctionParser = (childParsers) => {
-    parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
-    const disjunctionParser = async (parserContext) => {
-        const parserParsingFailedErrors = [];
-        for (const childParser of childParsers) {
-            const childParserContext = parserContext.lookahead(getParserName(childParser));
-            const [childParserResult] = await Promise.allSettled([childParser(childParserContext)]);
-            if (childParserResult.status === 'fulfilled') {
-                const successfulParserOutput = childParserResult.value;
-                childParserContext.unlookahead();
-                childParserContext.dispose();
-                return successfulParserOutput;
-            }
-            else {
-                const error = childParserResult.reason;
-                if (error instanceof ParserParsingFailedError) {
-                    parserParsingFailedErrors.push(error);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        parserParsingInvariant(false, [
-            'No disjunction child parser succeeded.',
-            'Parsing errors, indented, separated by newlines:',
-            '%s',
-            'End of parsing errors.',
-        ], parserParsingFailedErrors
-            .flatMap(error => error.stack?.split('\n'))
-            .map(line => '  ' + line)
-            .join('\n'));
-    };
-    const name = [
-        '(',
-        ...childParsers.map(getParserName).join('|'),
-        ')',
-    ].join('');
-    Object.defineProperty(disjunctionParser, 'name', { value: name });
-    return disjunctionParser;
-};

package/build/createExactParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createExactParser: <InputChunk>(inputChunk: InputChunk) => Parser<InputChunk, InputChunk, unknown>;

package/build/createExactParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createExactParser = (inputChunk) => {
-    parserImplementationInvariant(length > 0, 'Length must be positive.');
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/createSequentialUnionParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createDisjunctionParser: <Output, Sequence>(childParsers: Parser<any, Sequence, any>[]) => Parser<Output, Sequence, unknown>;

package/build/createSequentialUnionParser.js

@@ -1,69 +0,0 @@
-import { ParserParsingFailedError } from './parserError.js';
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { parserParsingInvariant } from './parserParsingInvariant.js';
-function getParserName(parser) {
-    return parser.name || 'anonymousSequentialUnionChild';
-}
-export const createDisjunctionParser = (childParsers) => {
-    parserImplementationInvariant(childParsers.length > 0, 'SequentialUnion parser must have at least one child parser.');
-    const sequentialUnionParser = async (parserContext) => {
-        let runningChildParserContexts = [];
-        const childParserResults = (async function* () {
-            for (const childParser of childParsers) {
-                const childParserContext = parserContext.lookahead(getParserName(childParser));
-                runningChildParserContexts.push(childParserContext);
-                const [promiseSettledResult] = await Promise.allSettled([childParser(childParserContext)]);
-                yield {
-                    ...promiseSettledResult,
-                    context: childParserContext,
-                };
-            }
-        })();
-        const parserParsingFailedErrors = [];
-        const successfulParserOutputs = [];
-        const successfulParserContexts = [];
-        for await (const childParserResult of childParserResults) {
-            runningChildParserContexts = runningChildParserContexts.filter(runningChildParserContext => runningChildParserContext !== childParserResult.context);
-            if (childParserResult.status === 'fulfilled') {
-                successfulParserOutputs.push(childParserResult.value);
-                successfulParserContexts.push(childParserResult.context);
-            }
-            else {
-                const error = childParserResult.reason;
-                if (error instanceof ParserParsingFailedError) {
-                    parserParsingFailedErrors.push(error);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        parserImplementationInvariant(successfulParserOutputs.length <= 1, [
-            'Multiple sequentialUnion child parsers succeeded.',
-            'Successful parser outputs, indented, separated by newlines:',
-            '%s',
-            'End of successful parser outputs.',
-        ], successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'));
-        parserParsingInvariant(successfulParserOutputs.length === 1, [
-            'No sequentialUnion child parser succeeded.',
-            'Parsing errors, indented, separated by newlines:',
-            '%s',
-            'End of parsing errors.',
-        ], parserParsingFailedErrors
-            .flatMap(error => error.stack?.split('\n'))
-            .map(line => '  ' + line)
-            .join('\n'));
-        const [successfulParserContext] = successfulParserContexts;
-        successfulParserContext.unlookahead();
-        successfulParserContext.dispose();
-        const [successfulParserOutput] = successfulParserOutputs;
-        return successfulParserOutput;
-    };
-    const name = [
-        '(',
-        ...childParsers.map(getParserName).join('|'),
-        ')',
-    ].join('');
-    Object.defineProperty(sequentialUnionParser, 'name', { value: name });
-    return sequentialUnionParser;
-};

package/build/fixedLengthChunkParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createFixedLengthParser: <InputChunk>(length: number) => Parser<InputChunk, InputChunk, unknown>;

package/build/fixedLengthChunkParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createFixedLengthParser = (length) => {
-    parserImplementationInvariant(length > 0, 'Length must be positive.');
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/fixedLengthParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createFixedLengthSequenceParser: <Sequence>(length: number) => Parser<Sequence, Sequence, unknown>;