@futpib/parser 1.0.1 → 1.0.3

package/.yarnrc.yml

@@ -4,4 +4,4 @@ enableGlobalCache: false
 
 nodeLinker: node-modules
 
-yarnPath: .yarn/releases/yarn-4.5.3.cjs
+yarnPath: .yarn/releases/yarn-4.9.4.cjs

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 { type ZipCentralDirectoryHeader, type ZipEndOfCentralDirectoryRecord, type 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,185 @@
+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/androidPackageParser.test.js

@@ -0,0 +1,22 @@
+import test from 'ava';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { androidPackageParser } from './androidPackageParser.js';
+import { fetchCid } from './fetchCid.js';
+const androidPackageMacro = test.macro({
+    title: (providedTitle, androidPackageCid) => providedTitle ?? `androidPackage ${androidPackageCid}`,
+    async exec(t, androidPackageCid) {
+        const androidPackageStream = await fetchCid(androidPackageCid);
+        const actual = await runParser(androidPackageParser, androidPackageStream, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        for (const entry of actual.entries) {
+            if (entry.type === 'file') {
+                entry.content = new Uint8Array([entry.content.length]);
+            }
+        }
+        t.snapshot(actual);
+    },
+});
+test(androidPackageMacro, 'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu');
+test(androidPackageMacro, 'bafkreidqycbgrtp7ywhevsgtm464dqpamxsijpaqfcfz2k3ymc3wrzsb5m');

package/build/androidPackageUnparser.d.ts

@@ -0,0 +1,4 @@
+import { type AndroidPackageSignatureV2SignedData, type AndroidPackageSigningBlock } from './androidPackage.js';
+import { type 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,94 @@
+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: 0x71_09_87_1A,
+                    value: input.signatureV2.signers,
+                },
+            ]
+            : []),
+        ...(input.zeroPaddingLength
+            ? [
+                {
+                    id: 0x42_72_65_77,
+                    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 invariant from 'invariant';
+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 { fetchCid } from './fetchCid.js';
+const androidPackageUnparserMacro = test.macro({
+    title: (providedTitle, androidPackageCid) => providedTitle ?? `androidPackage ${androidPackageCid}`,
+    async exec(t, androidPackageCid) {
+        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);
+    },
+});
+test(androidPackageUnparserMacro, 'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu');

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/arbitrarilySlicedAsyncInterator.js

@@ -3,11 +3,12 @@ export function arbitrarilySlicedAsyncIterator(arbitrarySliceable) {
     return (arbitrarilySlicedAsyncIterable(arbitrarySliceable)
         .map(([sliceable, asyncIterable]) => {
         const asyncIterator_ = asyncIterable[Symbol.asyncIterator]();
+        const asyncIterableWithTag = asyncIterable;
         const asyncIterator = {
             next: asyncIterator_.next.bind(asyncIterator_),
             return: asyncIterator_.return?.bind(asyncIterator_),
             throw: asyncIterator_.throw?.bind(asyncIterator_),
-            [Symbol.toStringTag]: 'ArbitrarilySlicedAsyncIterator ' + asyncIterable[Symbol.toStringTag],
+            [Symbol.toStringTag]: 'ArbitrarilySlicedAsyncIterator ' + (asyncIterableWithTag[Symbol.toStringTag] ?? ''),
         };
         return [
             sliceable,

package/build/arbitraryDalvikBytecode.d.ts

@@ -0,0 +1,4 @@
+import * as fc from 'fast-check';
+import { type DalvikBytecode, type DalvikBytecodeOperation } from './dalvikBytecodeParser.js';
+export declare const arbitraryDalvikBytecodeOperation: fc.Arbitrary<DalvikBytecodeOperation>;
+export declare const arbitraryDalvikBytecode: fc.Arbitrary<DalvikBytecode>;