@futpib/parser 1.0.0 → 1.0.2

package/build/allSettledStream.js

@@ -1,21 +1,39 @@
+import { promiseSettled } from "./promiseSettled.js";
 export function allSettledStream(tasks) {
+    let cancelled = false;
     return new ReadableStream({
-        async start(controller) {
+        start(controller) {
+            const startStack = ((new Error('allSettledStream ReadableStream start stack holder').stack ?? '')
+                .split('\n')
+                .slice(1)
+                .join('\n'));
+            const allSettledStreamTaskAwaiter = async ({ promise, context, }) => {
+                const promiseSettledResult = await promiseSettled(promise);
+                if (promiseSettledResult.status === 'rejected'
+                    && promiseSettledResult.reason instanceof Error
+                    && promiseSettledResult.reason.stack) {
+                    promiseSettledResult.reason.stack += `\n${startStack}`;
+                }
+                settledCount++;
+                if (cancelled) {
+                    return;
+                }
+                const allSettedStreamResult = {
+                    ...promiseSettledResult,
+                    context,
+                };
+                controller.enqueue(allSettedStreamResult);
+                if (settledCount === tasks.length) {
+                    controller.close();
+                }
+            };
             let settledCount = 0;
-            for (const { promise, context } of tasks) {
-                (async () => {
-                    const [promiseSettledResult] = await Promise.allSettled([promise]);
-                    settledCount++;
-                    const allSettedStreamResult = {
-                        ...promiseSettledResult,
-                        context,
-                    };
-                    controller.enqueue(allSettedStreamResult);
-                    if (settledCount === tasks.length) {
-                        controller.close();
-                    }
-                })();
+            for (const task of tasks) {
+                allSettledStreamTaskAwaiter(task);
             }
         },
+        cancel() {
+            cancelled = true;
+        },
     });
 }

package/build/allSettledStream.test.js

@@ -54,3 +54,35 @@ test('allSettledStream', async (t) => {
     t.snapshot(results);
     t.is(results.length, 8);
 });
+test('allSettledStream reader cancel', async (t) => {
+    const stream = allSettledStream([
+        10,
+        20,
+        0,
+        40,
+        30,
+    ].map((delay) => ({
+        promise: new Promise((resolve) => {
+            setTimeout(() => {
+                resolve(delay);
+            }, delay);
+        }),
+        context: delay,
+    })));
+    const results = [];
+    for await (const value of stream) {
+        results.push(value);
+        if (value.context === 30) {
+            break;
+        }
+    }
+    await new Promise(resolve => {
+        setTimeout(resolve, 50);
+    });
+    stream.cancel();
+    for await (const value of stream) {
+        t.fail();
+        results.push(value);
+    }
+    t.deepEqual(results.map(({ context }) => context), [0, 10, 20, 30]);
+});

package/build/androidPackage.d.ts

@@ -0,0 +1,39 @@
+import { type Zip } from './zip.js';
+export type AndroidPackageSigningBlockPair = {
+    id: number;
+    value: Uint8Array;
+};
+export type AndroidPackageSignatureV2Digest = {
+    signatureAlgorithmId: number;
+    digest: Uint8Array;
+};
+export type AndroidPackageSignatureV2AdditionalAttribute = {
+    id: number;
+    value: Uint8Array;
+};
+export type AndroidPackageSignatureV2SignedData = {
+    digests: AndroidPackageSignatureV2Digest[];
+    certificates: Uint8Array[];
+    additionalAttributes: AndroidPackageSignatureV2AdditionalAttribute[];
+    zeroPaddingLength?: number;
+};
+export type AndroidPackageSignatureV2Signature = {
+    signatureAlgorithmId: number;
+    signature: Uint8Array;
+};
+export type AndroidPackageSignatureV2Signer = {
+    signedData: AndroidPackageSignatureV2SignedData;
+    signatures: AndroidPackageSignatureV2Signature[];
+    publicKey: Uint8Array;
+};
+export type AndroidPackageSignatureV2 = {
+    signers: AndroidPackageSignatureV2Signer[];
+};
+export type AndroidPackageSigningBlock = {
+    pairs: AndroidPackageSigningBlockPair[];
+    signatureV2?: AndroidPackageSignatureV2;
+    zeroPaddingLength?: number;
+};
+export type AndroidPackage = Zip & {
+    signingBlock?: AndroidPackageSigningBlock;
+};

package/build/androidPackageParser.d.ts

@@ -0,0 +1,17 @@
+import { type Parser } from './parser.js';
+import { ZipCentralDirectoryHeader, ZipEndOfCentralDirectoryRecord, ZipLocalFile } from './zipParser.js';
+import { type AndroidPackage, type AndroidPackageSigningBlock } from './androidPackage.js';
+export declare const androidPackageSigningBlockParser: Parser<AndroidPackageSigningBlock, Uint8Array>;
+export declare const androidPackageParser: Parser<AndroidPackage, Uint8Array>;
+export type AndroidPackageSignableSections = {
+    zipLocalFiles: ZipLocalFile[];
+    zipLocalFilesZeroPaddingLength: number;
+    androidPackageSigningBlock?: AndroidPackageSigningBlock;
+    zipCentralDirectory: ZipCentralDirectoryHeader[];
+    zipEndOfCentralDirectory: ZipEndOfCentralDirectoryRecord;
+    zipLocalFilesUint8Array: Uint8Array;
+    androidPackageSigningBlockUint8Array?: Uint8Array;
+    zipCentralDirectoryUint8Array: Uint8Array;
+    zipEndOfCentralDirectoryUint8Array: Uint8Array;
+};
+export declare const androidPackageSignableSectionsParser: Parser<AndroidPackageSignableSections, Uint8Array>;

package/build/androidPackageParser.js

@@ -0,0 +1,183 @@
+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/androidPackagesigning/v2#androidPackage-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 createAndroidPackageSigningBlockZeroPaddingPairInnerParser = (length) => {
+    const androidPackageSigningBlockZeroPaddingPairInnerParser = promiseCompose(createTupleParser([
+        createExactSequenceParser(Buffer.from('77657242', 'hex')),
+        createFixedLengthSequenceParser(length - 4),
+    ]), ([_magic, zeroPadding]) => ({ type: 'zeroPadding', length: zeroPadding.length }));
+    setParserName(androidPackageSigningBlockZeroPaddingPairInnerParser, 'androidPackageSigningBlockZeroPaddingPairInnerParser');
+    return androidPackageSigningBlockZeroPaddingPairInnerParser;
+};
+const createAndroidPackageSigningBlockSignatureV2PairInnerParser = (length) => {
+    const androidPackageSigningBlockSignatureV2PairInnerParser = promiseCompose(createTupleParser([
+        createExactSequenceParser(Buffer.from('1a870971', 'hex')),
+        androidPackageSignatureV2SignersParser,
+    ]), ([_magic, signers = []]) => ({ type: 'signatureV2', signers }));
+    return setParserName(androidPackageSigningBlockSignatureV2PairInnerParser, 'androidPackageSigningBlockSignatureV2PairInnerParser');
+};
+const createAndroidPackageSigningBlockGenericPairInnerParser = (length) => promiseCompose(createTupleParser([
+    uint32LEParser,
+    createFixedLengthSequenceParser(length - 4),
+]), ([id, value]) => ({ type: 'generic', pair: { id, value } }));
+const createAndroidPackageSigningBlockPairInnerParser = (length) => {
+    const androidPackageSigningBlockPairInnerParser = promiseCompose(createTupleParser([
+        parserContext => {
+            parserContext.invariant(Number.isSafeInteger(length), 'Signing block length is unreasonable: %s.', length);
+        },
+        createDisjunctionParser([
+            createAndroidPackageSigningBlockZeroPaddingPairInnerParser(length),
+            createAndroidPackageSigningBlockSignatureV2PairInnerParser(length),
+            createAndroidPackageSigningBlockGenericPairInnerParser(length),
+        ]),
+    ]), ([_lengthInvariant, pair,]) => pair);
+    setParserName(androidPackageSigningBlockPairInnerParser, 'androidPackageSigningBlockPairInnerParser');
+    return androidPackageSigningBlockPairInnerParser;
+};
+const androidPackageSigningBlockPairParser = createUint64LengthPrefixedParser(length => createAndroidPackageSigningBlockPairInnerParser(Number(length)));
+setParserName(androidPackageSigningBlockPairParser, 'androidPackageSigningBlockPairParser');
+const androidPackageSigningBlockPairsParser = createArrayParser(androidPackageSigningBlockPairParser);
+export const androidPackageSigningBlockParser = createUint64LengthPrefixedParser(sizeOfBlock => promiseCompose(createTupleParser([
+    androidPackageSigningBlockPairsParser,
+    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 androidPackageSignatureV2DigestParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
+    uint32LEParser,
+    createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
+]), ([signatureAlgorithmId, digest]) => ({ signatureAlgorithmId, digest })));
+const androidPackageSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2DigestParser);
+setParserName(androidPackageSignatureV2DigestsParser, 'androidPackageSignatureV2DigestsParser');
+const androidPackageSignatureV2CertificateParser = createUint32LengthPrefixedParser(certificateLength => createFixedLengthSequenceParser(certificateLength));
+setParserName(androidPackageSignatureV2CertificateParser, 'androidPackageSignatureV2CertificateParser');
+const androidPackageSignatureV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2CertificateParser);
+setParserName(androidPackageSignatureV2CertificatesParser, 'androidPackageSignatureV2CertificatesParser');
+const androidPackageSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
+    uint32LEParser,
+    createFixedLengthSequenceParser(pairLength - 4),
+]), ([id, value]) => ({ id, value })));
+setParserName(androidPackageSignatureV2AdditionalAttributeParser, 'androidPackageSignatureV2AdditionalAttributeParser');
+const androidPackageSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2AdditionalAttributeParser);
+setParserName(androidPackageSignatureV2AdditionalAttributesParser, 'androidPackageSignatureV2AdditionalAttributesParser');
+const androidPackageSignatureV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
+    androidPackageSignatureV2DigestsParser,
+    androidPackageSignatureV2CertificatesParser,
+    androidPackageSignatureV2AdditionalAttributesParser,
+    createArrayParser(createExactElementParser(0)),
+]), ([digests, certificates, additionalAttributes, zeroPadding,]) => ({
+    digests,
+    certificates,
+    additionalAttributes,
+    zeroPaddingLength: zeroPadding.length,
+})));
+setParserName(androidPackageSignatureV2SignedDataParser, 'androidPackageSignatureV2SignedDataParser');
+const androidPackageSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(createTupleParser([
+    uint32LEParser,
+    createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
+]), ([signatureAlgorithmId, signature,]) => ({
+    signatureAlgorithmId,
+    signature,
+})));
+const androidPackageSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2SignatureParser);
+setParserName(androidPackageSignatureV2SignaturesParser, 'androidPackageSignatureV2SignaturesParser');
+const androidPackageSignatureV2PublicKeyParser = createUint32LengthPrefixedParser(publicKeyLength => createFixedLengthSequenceParser(publicKeyLength));
+setParserName(androidPackageSignatureV2PublicKeyParser, 'androidPackageSignatureV2PublicKeyParser');
+const androidPackageSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
+    androidPackageSignatureV2SignedDataParser,
+    androidPackageSignatureV2SignaturesParser,
+    androidPackageSignatureV2PublicKeyParser,
+]), ([signedData, signatures = [], publicKey,]) => ({
+    signedData,
+    signatures,
+    publicKey,
+})));
+setParserName(androidPackageSignatureV2SignerParser, 'androidPackageSignatureV2SignerParser');
+const androidPackageSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(androidPackageSignatureV2SignerParser);
+setParserName(androidPackageSignatureV2SignersParser, 'androidPackageSignatureV2SignersParser');
+const androidPackageParser_ = createTupleParser([
+    createArrayParser(zipLocalFileParser),
+    createOptionalParser(zipArchiveDecryptionHeaderParser),
+    createOptionalParser(zipArchiveExtraDataRecordParser),
+    createOptionalParser(androidPackageSigningBlockParser),
+    createArrayParser(zipCentralDirectoryHeaderParser),
+    createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
+    createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
+    zipEndOfCentralDirectoryRecordParser,
+]);
+setParserName(androidPackageParser_, 'androidPackageParser_');
+export const androidPackageParser = promiseCompose(androidPackageParser_, async ([zipLocalFiles, zipArchiveDecryptionHeader, zipArchiveExtraDataRecord, androidPackageSigningBlock, zipCentralDirectoryHeaders, zip64EndOfCentralDirectoryRecord, zip64EndOfCentralDirectoryLocator, zipEndOfCentralDirectoryRecord,]) => {
+    const zip = await zipFromZipSegments({
+        zipLocalFiles,
+        zipCentralDirectoryHeaders,
+        zipEndOfCentralDirectoryRecord,
+    });
+    return {
+        ...zip,
+        signingBlock: androidPackageSigningBlock,
+    };
+});
+setParserName(androidPackageParser, 'androidPackageParser');
+export const androidPackageSignableSectionsParser = promiseCompose(createTupleParser([
+    createParserConsumedSequenceParser(createTupleParser([
+        createArrayParser(zipLocalFileParser),
+        createOptionalParser(zipArchiveDecryptionHeaderParser),
+        createOptionalParser(zipArchiveExtraDataRecordParser),
+    ])),
+    createArrayParser(createExactElementParser(0)),
+    createOptionalParser(createParserConsumedSequenceParser(androidPackageSigningBlockParser)),
+    createParserConsumedSequenceParser(createTupleParser([
+        createArrayParser(zipCentralDirectoryHeaderParser),
+        createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
+        createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
+    ])),
+    createParserConsumedSequenceParser(zipEndOfCentralDirectoryRecordParser),
+]), async ([[[zipLocalFiles,], zipLocalFilesUint8Array,], zipLocalFilesZeroPadding, [androidPackageSigningBlock = undefined, androidPackageSigningBlockUint8Array = undefined,] = [], [[zipCentralDirectory,], zipCentralDirectoryUint8Array,], [zipEndOfCentralDirectory, zipEndOfCentralDirectoryUint8Array,],]) => ({
+    zipLocalFiles,
+    zipLocalFilesZeroPaddingLength: zipLocalFilesZeroPadding.length,
+    androidPackageSigningBlock,
+    zipCentralDirectory,
+    zipEndOfCentralDirectory,
+    zipLocalFilesUint8Array,
+    androidPackageSigningBlockUint8Array,
+    zipCentralDirectoryUint8Array,
+    zipEndOfCentralDirectoryUint8Array,
+}));
+setParserName(androidPackageSignableSectionsParser, 'androidPackageSignableSectionsParser');

package/build/{apkParser.test.js → androidPackageParser.test.js}

@@ -1,15 +1,15 @@
 import test from 'ava';
-import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
-import { apkParser } from './apkParser.js';
-for (const apkCid of [
+import { androidPackageParser } from './androidPackageParser.js';
+import { fetchCid } from './fetchCid.js';
+for (const androidPackageCid of [
     'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu',
     'bafkreidqycbgrtp7ywhevsgtm464dqpamxsijpaqfcfz2k3ymc3wrzsb5m',
 ]) {
-    test('apk ' + apkCid, async (t) => {
-        const apkResponse = await fetch('https://ipfs.io/ipfs/' + apkCid);
-        const apkStream = apkResponse.body;
-        const actual = await runParser(apkParser, apkStream, uint8ArrayInputCompanion, {
+    test('androidPackage ' + androidPackageCid, async (t) => {
+        const androidPackageStream = await fetchCid(androidPackageCid);
+        const actual = await runParser(androidPackageParser, androidPackageStream, uint8ArrayParserInputCompanion, {
             errorJoinMode: 'all',
         });
         for (const entry of actual.entries) {

package/build/androidPackageUnparser.d.ts

@@ -0,0 +1,4 @@
+import { AndroidPackageSignatureV2SignedData, AndroidPackageSigningBlock } from "./androidPackage.js";
+import { Unparser } from "./unparser.js";
+export declare const androidPackageSignatureV2SignedDataUnparser: Unparser<AndroidPackageSignatureV2SignedData, Uint8Array>;
+export declare const androidPackageSigningBlockUnparser: Unparser<AndroidPackageSigningBlock, Uint8Array>;

package/build/androidPackageUnparser.js

@@ -0,0 +1,90 @@
+import { createArrayUnparser } from "./arrayUnparser.js";
+import { createSequenceUnparser } from "./sequenceUnparser.js";
+const uint8ArrayUnparser = createSequenceUnparser();
+const uint32LEUnparser = async function* (input) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32LE(input);
+    yield buffer;
+};
+const uint64LEUnparser = async function* (input) {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigUInt64LE(BigInt(input));
+    yield buffer;
+};
+const createUint32LengthPrefixedUnparser = (innerUnparser) => async function* (input, unparserContext) {
+    const length = yield* unparserContext.writeLater(4);
+    yield* innerUnparser(input, unparserContext);
+    yield* unparserContext.writeEarlier(length, uint32LEUnparser, unparserContext.position - length.positionEnd);
+};
+const createUint64LengthPrefixedUnparser = (innerUnparser) => async function* (input, unparserContext) {
+    const length = yield* unparserContext.writeLater(8);
+    yield* innerUnparser(input, unparserContext);
+    yield* unparserContext.writeEarlier(length, uint64LEUnparser, unparserContext.position - length.positionEnd);
+};
+const androidPackageSignatureV2DigestUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+    yield* uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
+    yield* uint32LEUnparser(input.digest.length, unparserContext);
+    yield input.digest;
+});
+const androidPackageSignatureV2DigestsUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2DigestUnparser));
+const androidPackageSignatureV2CertificateUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
+const androidPackageSignatureV2CertificatesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2CertificateUnparser));
+const androidPackageSignatureV2AdditionalAttributeUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+    yield* uint32LEUnparser(input.id, unparserContext);
+    yield input.value;
+});
+const androidPackageSignatureV2AdditionalAttributesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2AdditionalAttributeUnparser));
+export const androidPackageSignatureV2SignedDataUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+    yield* androidPackageSignatureV2DigestsUnparser(input.digests, unparserContext);
+    yield* androidPackageSignatureV2CertificatesUnparser(input.certificates, unparserContext);
+    yield* androidPackageSignatureV2AdditionalAttributesUnparser(input.additionalAttributes, unparserContext);
+    if (input.zeroPaddingLength) {
+        yield Buffer.alloc(input.zeroPaddingLength);
+    }
+});
+const androidPackageSignatureV2SignatureUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+    yield* uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
+    yield* uint32LEUnparser(input.signature.length, unparserContext);
+    yield input.signature;
+});
+const androidPackageSignatureV2SignaturesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2SignatureUnparser));
+const androidPackageSignatureV2PublicKeyUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
+const androidPackageSignatureV2SignerUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+    yield* androidPackageSignatureV2SignedDataUnparser(input.signedData, unparserContext);
+    yield* androidPackageSignatureV2SignaturesUnparser(input.signatures, unparserContext);
+    yield* androidPackageSignatureV2PublicKeyUnparser(input.publicKey, unparserContext);
+});
+const androidPackageSignatureV2SignersUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2SignerUnparser));
+const androidPackageSigningBlockPairUnparser = createUint64LengthPrefixedUnparser(async function* (input, unparserContext) {
+    yield* uint32LEUnparser(input.id, unparserContext);
+    if (input.value instanceof Uint8Array) {
+        yield input.value;
+    }
+    else {
+        yield* androidPackageSignatureV2SignersUnparser(input.value, unparserContext);
+    }
+});
+const androidPackageSigningBlockPairsUnparser = createArrayUnparser(androidPackageSigningBlockPairUnparser);
+export const androidPackageSigningBlockUnparser = async function* (input, unparserContext) {
+    const pairs = [
+        ...input.pairs,
+        ...(input.signatureV2 ? [
+            {
+                id: 0x7109871a,
+                value: input.signatureV2.signers,
+            },
+        ] : []),
+        ...(input.zeroPaddingLength ? [
+            {
+                id: 0x42726577,
+                value: Buffer.alloc(input.zeroPaddingLength),
+            },
+        ] : []),
+    ];
+    const sizeOfBlockWriteLater = yield* unparserContext.writeLater(8);
+    yield* androidPackageSigningBlockPairsUnparser(pairs, unparserContext);
+    const sizeOfBlock = unparserContext.position - sizeOfBlockWriteLater.position + 16;
+    yield* uint64LEUnparser(sizeOfBlock, unparserContext);
+    yield* unparserContext.writeEarlier(sizeOfBlockWriteLater, uint64LEUnparser, sizeOfBlock);
+    yield Buffer.from('APK Sig Block 42', 'utf8');
+};

package/build/androidPackageUnparser.test.js

@@ -0,0 +1,26 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { androidPackageParser, androidPackageSigningBlockParser } from './androidPackageParser.js';
+import { runUnparser } from './unparser.js';
+import { androidPackageSigningBlockUnparser } from './androidPackageUnparser.js';
+import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
+import invariant from 'invariant';
+import { fetchCid } from './fetchCid.js';
+for (const androidPackageCid of [
+    'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu',
+]) {
+    test('androidPackage ' + androidPackageCid, async (t) => {
+        const androidPackageStream = await fetchCid(androidPackageCid);
+        const androidPackage = await runParser(androidPackageParser, androidPackageStream, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        const androidPackageSigningBlock = androidPackage.signingBlock;
+        invariant(androidPackageSigningBlock, 'APK has no signing block');
+        const androidPackageSigningBlockStream = runUnparser(androidPackageSigningBlockUnparser, androidPackageSigningBlock, uint8ArrayUnparserOutputCompanion);
+        const actual = await runParser(androidPackageSigningBlockParser, androidPackageSigningBlockStream, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        t.deepEqual(actual, androidPackageSigningBlock);
+    });
+}

package/build/arbitrarilySlicedAsyncInterable.d.ts

@@ -1,2 +1,4 @@
 import { type Arbitrary } from 'fast-check';
-export declare function arbitrarilySlicedAsyncIterable<Sliceable extends string | Uint8Array>(arbitrarySliceable: Arbitrary<Sliceable>): Arbitrary<[Sliceable, AsyncIterable<Sliceable>]>;
+export declare function arbitrarilySlicedAsyncIterable<Sliceable extends string | Uint8Array>(arbitrarySliceable: Arbitrary<Sliceable>, { minSlices, }?: {
+    minSlices?: number;
+}): Arbitrary<[Sliceable, AsyncIterable<Sliceable>]>;

package/build/arbitrarilySlicedAsyncInterable.js

@@ -1,6 +1,6 @@
-import { inspect } from 'node:util';
 import * as fc from 'fast-check';
 import invariant from 'invariant';
+import { inspect } from './inspect.js';
 function concat(slices) {
     const firstSlice = slices.at(0);
     if (firstSlice instanceof Uint8Array) {
@@ -14,8 +14,8 @@ function equals(a, b) {
     }
     return a === b;
 }
-export function arbitrarilySlicedAsyncIterable(arbitrarySliceable) {
-    return (fc.tuple(arbitrarySliceable, fc.array(fc.nat(), { minLength: 1 }))
+export function arbitrarilySlicedAsyncIterable(arbitrarySliceable, { minSlices = 1, } = {}) {
+    return (fc.tuple(arbitrarySliceable, fc.array(fc.nat(), { minLength: Math.max(1, minSlices) }))
         .map(([sliceable, sliceSizes]) => {
         let start = 0;
         const slices = sliceSizes.map(sliceSize => {

package/build/arbitraryFileSystemEntry.js

@@ -1,5 +1,5 @@
 import * as fc from 'fast-check';
-export const arbitraryFileSystemEntry = fc.letrec((tie) => ({
+export const arbitraryFileSystemEntry = fc.letrec(tie => ({
     entry: fc.oneof(fc.record({
         type: fc.constant('file'),
         name: fc.string(),

package/build/arbitraryZip.d.ts

@@ -1,5 +1,5 @@
 import * as fc from 'fast-check';
-import { ZipEntry } from './zip.js';
+import { type ZipEntry } from './zip.js';
 export declare const arbitraryZip: fc.Arbitrary<{
     comment: string;
     entries: ZipEntry[];

package/build/arbitraryZip.js

@@ -1,8 +1,6 @@
 import * as fc from 'fast-check';
-import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
-import { createArbitraryZipPermissions } from './arbitraryZipPermissions.js';
 import invariant from 'invariant';
-const DOS_DIRECTORY_FLAG = 0b00010000;
+import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
 const arbitraryPath = fc.string({ minLength: 1 }).filter(path => {
     const pathSegments = path.split('/');
     const pathHasEmptySegments = pathSegments.some(segment => segment.length === 0);
@@ -16,7 +14,10 @@ const createArbitraryZipEntry = (platform) => fc.oneof(fc.record({
     path: arbitraryPath,
     date: arbitraryDosDateTime,
     comment: fc.string(),
-    permissions: createArbitraryZipPermissions(platform),
+    hostSystem: fc.constant(platform),
+    attributes: fc.record({
+        directory: fc.constant(false),
+    }),
     compression: fc.oneof(fc.constant('store'), fc.constant('deflate')),
     content: fc.uint8Array(),
 }).filter(zipFileEntry => {
@@ -24,23 +25,16 @@ const createArbitraryZipEntry = (platform) => fc.oneof(fc.record({
         && zipFileEntry.compression === 'deflate') {
         return false;
     }
-    if (zipFileEntry.permissions.type === 'dos'
-        && zipFileEntry.permissions.dosPermissions & DOS_DIRECTORY_FLAG) {
-        return false;
-    }
     return true;
 }), fc.record({
     type: fc.constant('directory'),
     path: arbitraryPath,
     date: arbitraryDosDateTime,
     comment: fc.string(),
-    permissions: createArbitraryZipPermissions(platform),
-}).filter(zipDirectoryEntry => {
-    if (zipDirectoryEntry.permissions.type === 'dos'
-        && !(zipDirectoryEntry.permissions.dosPermissions & DOS_DIRECTORY_FLAG)) {
-        return false;
-    }
-    return true;
+    hostSystem: fc.constant(platform),
+    attributes: fc.record({
+        directory: fc.constant(false),
+    }),
 }));
 const createArbitraryZipEntries = (platform) => (fc
     .array(createArbitraryZipEntry(platform))
@@ -70,10 +64,10 @@ const createArbitraryZipEntries = (platform) => (fc
                     path: directoryPath,
                     date: entry.date,
                     comment: '',
-                    permissions: entry.permissions.type === 'dos' ? {
-                        type: 'dos',
-                        dosPermissions: entry.permissions.dosPermissions | DOS_DIRECTORY_FLAG,
-                    } : entry.permissions,
+                    hostSystem: platform,
+                    attributes: {
+                        directory: true,
+                    },
                 });
                 seenDirectoryPaths.add(directoryPath);
             }

package/build/arbitraryZipPermissions.d.ts

@@ -1,8 +1 @@
-import * as fc from 'fast-check';
-export declare const createArbitraryZipPermissions: (type: "unix" | "dos") => fc.Arbitrary<{
-    type: "unix";
-    unixPermissions: number;
-}> | fc.Arbitrary<{
-    type: "dos";
-    dosPermissions: number;
-}>;
+export {};

package/build/arbitraryZipPermissions.js

@@ -1,16 +1 @@
-import * as fc from 'fast-check';
-const arbitraryZipUnixPermissions = fc.record({
-    type: fc.constant('unix'),
-    unixPermissions: (fc.nat({ max: 0b0000000111111111 })
-        .filter((unixPermissions) => unixPermissions > 0)),
-});
-const arbitraryZipDosPermissions = fc.record({
-    type: fc.constant('dos'),
-    dosPermissions: (fc.nat({ max: 0b00111111 })),
-});
-export const createArbitraryZipPermissions = (type) => {
-    if (type === 'unix') {
-        return arbitraryZipUnixPermissions;
-    }
-    return arbitraryZipDosPermissions;
-};
+export {};

package/build/arbitraryZipStream.d.ts

@@ -1,4 +1,4 @@
-import { ZipEntry } from './zip.js';
+import { type ZipEntry } from './zip.js';
 export declare const arbitraryZipStream: import("fast-check").Arbitrary<readonly [{
     comment: string;
     entries: ZipEntry[];

package/build/arbitraryZipStream.js

@@ -4,8 +4,8 @@ function addZipEntryToZip(zip, zipEntry) {
     const options = {
         comment: zipEntry.comment,
         date: zipEntry.date,
-        unixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
-        dosPermissions: zipEntry.permissions.type === 'dos' ? zipEntry.permissions.dosPermissions : undefined,
+        // unixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
+        // dosPermissions: zipEntry.permissions.type === 'dos' ? zipEntry.permissions.dosPermissions : undefined,
     };
     if (zipEntry.type === 'file') {
         zip.file(zipEntry.path, zipEntry.content, {
@@ -30,7 +30,7 @@ export const arbitraryZipStream = arbitraryZip.map(zip => {
     const zipInternalStream = jsZip.generateInternalStream({
         type: 'uint8array',
         comment: zip.comment,
-        platform: zip.entries.at(0)?.permissions.type.toUpperCase(),
+        platform: zip.entries.at(0)?.hostSystem.toUpperCase(),
     });
     const zipStream = new ReadableStream({
         start(controller) {

package/build/arrayParser.d.ts

@@ -1,2 +1,2 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 export declare const createArrayParser: <ElementOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>) => Parser<ElementOutput[], Sequence>;