@futpib/parser 1.0.1 → 1.0.2

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,84 @@ 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,
@@ -373,7 +430,7 @@ const zipEndOfCentralDirectoryRecordParser_ = createTupleParser([
 	zipFileCommentParser,
 ]);
 
-setParserName(zipEndOfCentralDirectoryRecordParser_, 'endOfCentralDirectoryRecordParser_');
+setParserName(zipEndOfCentralDirectoryRecordParser_, 'zipEndOfCentralDirectoryRecordParser_');
 
 export const zipEndOfCentralDirectoryRecordParser: Parser<ZipEndOfCentralDirectoryRecord, Uint8Array> = promiseCompose(
 	zipEndOfCentralDirectoryRecordParser_,
@@ -397,6 +454,8 @@ export const zipEndOfCentralDirectoryRecordParser: Parser<ZipEndOfCentralDirecto
 	}),
 );
 
+setParserName(zipEndOfCentralDirectoryRecordParser, 'zipEndOfCentralDirectoryRecordParser');
+
 const zipParser_ = createTupleParser([
 	createArrayParser(zipLocalFileParser),
 	createOptionalParser(zipArchiveDecryptionHeaderParser),

package/src/zipUnparser.test.ts

@@ -1,24 +1,15 @@
-import { testProp } from '@fast-check/ava';
+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;
 		}
 

package/src/zipUnparser.ts

@@ -3,7 +3,7 @@ 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 } from './zipParser.js';
+import { ZipEndOfCentralDirectoryRecord, ZipLocalFileHeader } from './zipParser.js';
 import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
 
 const uint16LEUnparser: Unparser<number, Uint8Array> = async function * (uint16LE) {
@@ -66,7 +66,56 @@ export const zipEndOfCentralDirectoryRecordUnparser: Unparser<ZipEndOfCentralDir
 	yield * uint16LEPrefixedStringUnparser(zipEndOfCentralDirectoryRecord.zipFileComment, unparserContext);
 }
 
-export const zipUnparser: Unparser<Zip, Uint8Array> = async function * (zip, 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') {
@@ -100,44 +149,54 @@ export const zipUnparser: Unparser<Zip, Uint8Array> = async function * (zip, unp
 	for (const zipEntry of zip.entries) {
 		localHeaderPositionByZipEntry.set(zipEntry, unparserContext.position);
 
-		yield Buffer.from('504b0304', 'hex');
-
-		yield * uint16LEUnparser(10, unparserContext); // version needed to extract
-		yield * uint16LEUnparser(0, unparserContext); // general purpose bit flag
+		const filePath = filePathByZipEntry.get(zipEntry)!;
 
-		if (zipEntry.type === 'file') {
-			yield * zipCompressionMethodUnparser(zipEntry.compression, unparserContext);
-		} else {
-			yield * uint16LEUnparser(0, unparserContext);
-		}
+		const zipLocalFileHeader: ZipLocalFileHeader = {
+			versionNeededToExtract: 20,
+			generalPurposeBitFlag: 0,
+			compressionMethod: 'store',
+			lastModifiedFile: zipEntry.date,
+			crc32: 0,
+			compressedSize: 0,
+			uncompressedSize: 0,
+			filePath,
+			extraField: Buffer.alloc(0),
+		};
 
-		yield * dosDateTimeUnparser(zipEntry.date, unparserContext);
+		let shouldWriteDataDescriptor = false;
 
 		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);
-		}
+			zipLocalFileHeader.compressionMethod = zipEntry.compression;
+			zipLocalFileHeader.crc32 = 0; // TODO
+			zipLocalFileHeader.compressedSize = compressedContent.length;
+			zipLocalFileHeader.uncompressedSize = zipEntry.content.length;
 
-		const filePath = filePathByZipEntry.get(zipEntry)!;
+			if (dataDescriptor) {
+				shouldWriteDataDescriptor = true;
 
-		const filePathBuffer = Buffer.from(filePath, 'utf8');
-		const extraFieldBuffer = Buffer.alloc(0);
-		yield * uint16LEUnparser(filePathBuffer.length, unparserContext);
-		yield * uint16LEUnparser(extraFieldBuffer.length, unparserContext);
-		yield filePathBuffer;
-		yield extraFieldBuffer;
+				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);
+			}
 		}
 	}
 
@@ -237,3 +296,5 @@ export const zipUnparser: Unparser<Zip, Uint8Array> = async function * (zip, unp
 		zipFileComment: zip.comment,
 	}, unparserContext);
 }
+
+export const zipUnparser = createZipUnparser();

package/build/apk.d.ts

@@ -1,39 +0,0 @@
-import { type Zip } from './zip.js';
-export type ApkSigningBlockPair = {
-    id: number;
-    value: Uint8Array;
-};
-export type ApkSignatureV2Digest = {
-    signatureAlgorithmId: number;
-    digest: Uint8Array;
-};
-export type ApkSignatureV2AdditionalAttribute = {
-    id: number;
-    value: Uint8Array;
-};
-export type ApkSignatureV2SignedData = {
-    digests: ApkSignatureV2Digest[];
-    certificates: Uint8Array[];
-    additionalAttributes: ApkSignatureV2AdditionalAttribute[];
-    zeroPaddingLength?: number;
-};
-export type ApkSignatureV2Signature = {
-    signatureAlgorithmId: number;
-    signature: Uint8Array;
-};
-export type ApkSignatureV2Signer = {
-    signedData: ApkSignatureV2SignedData;
-    signatures: ApkSignatureV2Signature[];
-    publicKey: Uint8Array;
-};
-export type ApkSignatureV2 = {
-    signers: ApkSignatureV2Signer[];
-};
-export type ApkSigningBlock = {
-    pairs: ApkSigningBlockPair[];
-    signatureV2?: ApkSignatureV2;
-    zeroPaddingLength?: number;
-};
-export type Apk = Zip & {
-    signingBlock?: ApkSigningBlock;
-};

package/build/apkParser.d.ts

@@ -1,16 +0,0 @@
-import { type Parser } from './parser.js';
-import { ZipCentralDirectoryHeader, ZipEndOfCentralDirectoryRecord, ZipLocalFile } from './zipParser.js';
-import { type Apk, type ApkSigningBlock } from './apk.js';
-export declare const apkSigningBlockParser: Parser<ApkSigningBlock, Uint8Array>;
-export declare const apkParser: Parser<Apk, Uint8Array>;
-export type ApkSignableSections = {
-    zipLocalFiles: ZipLocalFile[];
-    apkSigningBlock?: ApkSigningBlock;
-    zipCentralDirectory: ZipCentralDirectoryHeader[];
-    zipEndOfCentralDirectory: ZipEndOfCentralDirectoryRecord;
-    zipLocalFilesUint8Array: Uint8Array;
-    apkSigningBlockUint8Array?: Uint8Array;
-    zipCentralDirectoryUint8Array: Uint8Array;
-    zipEndOfCentralDirectoryUint8Array: Uint8Array;
-};
-export declare const apkSignableSectionsParser: Parser<ApkSignableSections, Uint8Array>;

package/build/apkParser.js

@@ -1,164 +0,0 @@
-import invariant from 'invariant';
-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 { createExactElementParser } from './exactElementParser.js';
-import { createParserConsumedSequenceParser } from './parserConsumedSequenceParser.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')),
-        apkSignatureV2SignersParser,
-    ]), ([_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);
-export 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: signatureV2Pair?.signers,
-        } : undefined,
-        pairs: genericPairs,
-    };
-}));
-const apkSignatureV2DigestParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
-]), ([signatureAlgorithmId, digest]) => ({ signatureAlgorithmId, digest })));
-const apkSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2DigestParser);
-const apkSignatureV2CertificateParser = createUint32LengthPrefixedParser(certificateLength => createFixedLengthSequenceParser(certificateLength));
-const apkSignatureV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2CertificateParser);
-const apkSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createFixedLengthSequenceParser(pairLength - 4),
-]), ([id, value]) => ({ id, value })));
-setParserName(apkSignatureV2AdditionalAttributeParser, 'apkSignatureV2AdditionalAttributeParser');
-const apkSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2AdditionalAttributeParser);
-setParserName(apkSignatureV2AdditionalAttributesParser, 'apkSignatureV2AdditionalAttributesParser');
-const apkSignatureV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    apkSignatureV2DigestsParser,
-    apkSignatureV2CertificatesParser,
-    apkSignatureV2AdditionalAttributesParser,
-    createArrayParser(createExactElementParser(0)),
-]), ([digests, certificates, additionalAttributes, zeroPadding,]) => ({
-    digests,
-    certificates,
-    additionalAttributes,
-    zeroPaddingLength: zeroPadding.length,
-})));
-setParserName(apkSignatureV2SignedDataParser, 'apkSignatureV2SignedDataParser');
-const apkSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
-]), ([signatureAlgorithmId, signature,]) => ({
-    signatureAlgorithmId,
-    signature,
-})));
-const apkSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2SignatureParser);
-setParserName(apkSignatureV2SignaturesParser, 'apkSignatureV2SignaturesParser');
-const apkSignatureV2PublicKeyParser = createUint32LengthPrefixedParser(publicKeyLength => createFixedLengthSequenceParser(publicKeyLength));
-setParserName(apkSignatureV2PublicKeyParser, 'apkSignatureV2PublicKeyParser');
-const apkSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    apkSignatureV2SignedDataParser,
-    apkSignatureV2SignaturesParser,
-    apkSignatureV2PublicKeyParser,
-]), ([signedData, signatures = [], publicKey,]) => ({
-    signedData,
-    signatures,
-    publicKey,
-})));
-setParserName(apkSignatureV2SignerParser, 'apkSignatureV2SignerParser');
-const apkSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2SignerParser);
-setParserName(apkSignatureV2SignersParser, 'apkSignatureV2SignersParser');
-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');
-export const apkSignableSectionsParser = promiseCompose(createTupleParser([
-    createParserConsumedSequenceParser(createTupleParser([
-        createArrayParser(zipLocalFileParser),
-        createOptionalParser(zipArchiveDecryptionHeaderParser),
-        createOptionalParser(zipArchiveExtraDataRecordParser),
-    ])),
-    createOptionalParser(createParserConsumedSequenceParser(apkSigningBlockParser)),
-    createParserConsumedSequenceParser(createTupleParser([
-        createArrayParser(zipCentralDirectoryHeaderParser),
-        createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
-        createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
-    ])),
-    createParserConsumedSequenceParser(zipEndOfCentralDirectoryRecordParser),
-]), async ([[[zipLocalFiles,], zipLocalFilesUint8Array,], [apkSigningBlock = undefined, apkSigningBlockUint8Array = undefined,] = [], [[zipCentralDirectory,], zipCentralDirectoryUint8Array,], [zipEndOfCentralDirectory, zipEndOfCentralDirectoryUint8Array,],]) => ({
-    zipLocalFiles,
-    apkSigningBlock,
-    zipCentralDirectory,
-    zipEndOfCentralDirectory,
-    zipLocalFilesUint8Array,
-    apkSigningBlockUint8Array,
-    zipCentralDirectoryUint8Array,
-    zipEndOfCentralDirectoryUint8Array,
-}));

package/build/apkUnparser.d.ts

@@ -1,4 +0,0 @@
-import { ApkSignatureV2SignedData, ApkSigningBlock } from "./apk.js";
-import { Unparser } from "./unparser.js";
-export declare const apkSignatureV2SignedDataUnparser: Unparser<ApkSignatureV2SignedData, Uint8Array>;
-export declare const apkSigningBlockUnparser: Unparser<ApkSigningBlock, Uint8Array>;

package/build/apkUnparser.test.js

@@ -1,26 +0,0 @@
-import test from 'ava';
-import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
-import { runParser } from './parser.js';
-import { apkParser, apkSigningBlockParser } from './apkParser.js';
-import { runUnparser } from './unparser.js';
-import { apkSigningBlockUnparser } from './apkUnparser.js';
-import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
-import invariant from 'invariant';
-for (const apkCid of [
-    'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu',
-]) {
-    test('apk ' + apkCid, async (t) => {
-        const apkResponse = await fetch('https://ipfs.io/ipfs/' + apkCid);
-        const apkStream = apkResponse.body;
-        const apk = await runParser(apkParser, apkStream, uint8ArrayParserInputCompanion, {
-            errorJoinMode: 'all',
-        });
-        const apkSigningBlock = apk.signingBlock;
-        invariant(apkSigningBlock, 'APK has no signing block');
-        const apkSigningBlockStream = runUnparser(apkSigningBlockUnparser, apkSigningBlock, uint8ArrayUnparserOutputCompanion);
-        const actual = await runParser(apkSigningBlockParser, apkSigningBlockStream, uint8ArrayParserInputCompanion, {
-            errorJoinMode: 'all',
-        });
-        t.deepEqual(actual, apkSigningBlock);
-    });
-}

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>;