@futpib/parser 1.0.1 → 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 { 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, uint8ArrayParserInputCompanion, {
+    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/{apkUnparser.js → androidPackageUnparser.js}

@@ -21,51 +21,51 @@ const createUint64LengthPrefixedUnparser = (innerUnparser) => async function* (i
     yield* innerUnparser(input, unparserContext);
     yield* unparserContext.writeEarlier(length, uint64LEUnparser, unparserContext.position - length.positionEnd);
 };
-const apkSignatureV2DigestUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+const androidPackageSignatureV2DigestUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
     yield* uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
     yield* uint32LEUnparser(input.digest.length, unparserContext);
     yield input.digest;
 });
-const apkSignatureV2DigestsUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2DigestUnparser));
-const apkSignatureV2CertificateUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
-const apkSignatureV2CertificatesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2CertificateUnparser));
-const apkSignatureV2AdditionalAttributeUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+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 apkSignatureV2AdditionalAttributesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2AdditionalAttributeUnparser));
-export const apkSignatureV2SignedDataUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* apkSignatureV2DigestsUnparser(input.digests, unparserContext);
-    yield* apkSignatureV2CertificatesUnparser(input.certificates, unparserContext);
-    yield* apkSignatureV2AdditionalAttributesUnparser(input.additionalAttributes, unparserContext);
+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 apkSignatureV2SignatureUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
+const androidPackageSignatureV2SignatureUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
     yield* uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
     yield* uint32LEUnparser(input.signature.length, unparserContext);
     yield input.signature;
 });
-const apkSignatureV2SignaturesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2SignatureUnparser));
-const apkSignatureV2PublicKeyUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
-const apkSignatureV2SignerUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* apkSignatureV2SignedDataUnparser(input.signedData, unparserContext);
-    yield* apkSignatureV2SignaturesUnparser(input.signatures, unparserContext);
-    yield* apkSignatureV2PublicKeyUnparser(input.publicKey, unparserContext);
+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 apkSignatureV2SignersUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2SignerUnparser));
-const apkSigningBlockPairUnparser = createUint64LengthPrefixedUnparser(async function* (input, 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* apkSignatureV2SignersUnparser(input.value, unparserContext);
+        yield* androidPackageSignatureV2SignersUnparser(input.value, unparserContext);
     }
 });
-const apkSigningBlockPairsUnparser = createArrayUnparser(apkSigningBlockPairUnparser);
-export const apkSigningBlockUnparser = async function* (input, unparserContext) {
+const androidPackageSigningBlockPairsUnparser = createArrayUnparser(androidPackageSigningBlockPairUnparser);
+export const androidPackageSigningBlockUnparser = async function* (input, unparserContext) {
     const pairs = [
         ...input.pairs,
         ...(input.signatureV2 ? [
@@ -82,7 +82,7 @@ export const apkSigningBlockUnparser = async function* (input, unparserContext)
         ] : []),
     ];
     const sizeOfBlockWriteLater = yield* unparserContext.writeLater(8);
-    yield* apkSigningBlockPairsUnparser(pairs, unparserContext);
+    yield* androidPackageSigningBlockPairsUnparser(pairs, unparserContext);
     const sizeOfBlock = unparserContext.position - sizeOfBlockWriteLater.position + 16;
     yield* uint64LEUnparser(sizeOfBlock, unparserContext);
     yield* unparserContext.writeEarlier(sizeOfBlockWriteLater, uint64LEUnparser, sizeOfBlock);

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/arrayParser.test.js

@@ -1,9 +1,9 @@
 import test from 'ava';
 import { createArrayParser } from './arrayParser.js';
-import { runParser } from './parser.js';
+import { runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 test('does not loop forever with a child parser that does not consume anything', async (t) => {
     const parser = createArrayParser(async () => undefined);
-    const result = await runParser(parser, 'foo', stringParserInputCompanion);
-    t.deepEqual(result, []);
+    const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+    t.deepEqual(output, []);
 });

package/build/backsmali.d.ts

@@ -0,0 +1 @@
+export declare function baksmaliClass(dexStream: AsyncIterable<Uint8Array>, smaliFilePath: string): Promise<string>;

package/build/backsmali.js

@@ -0,0 +1,22 @@
+import fs from 'node:fs/promises';
+import { execa } from 'execa';
+import { temporaryDirectory, temporaryFile } from 'tempy';
+import path from 'node:path';
+export async function baksmaliClass(dexStream, smaliFilePath) {
+    const inputFilePath = temporaryFile();
+    const outputDirectoryPath = temporaryDirectory();
+    await fs.writeFile(inputFilePath, dexStream);
+    await execa('baksmali', [
+        'disassemble',
+        '--classes', 'L' + smaliFilePath + ';',
+        '--output', outputDirectoryPath,
+        inputFilePath,
+    ]);
+    await fs.unlink(inputFilePath);
+    const smaliFilePath_ = path.join(outputDirectoryPath, smaliFilePath + '.smali');
+    const smali = await fs.readFile(smaliFilePath_, 'utf8');
+    await fs.rm(outputDirectoryPath, {
+        recursive: true,
+    });
+    return smali;
+}

package/build/bsonParser.js

@@ -1,5 +1,4 @@
 import { getParserName, setParserName } from './parser.js';
-import { invariantDefined } from './invariantDefined.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
@@ -18,8 +17,11 @@ const elementParser = createElementParser();
 const nullByteParser = createExactElementParser(0);
 const cstringParser = promiseCompose(createTerminatedArrayParser(parserCreatorCompose(() => elementParser, (byte) => async (parserContext) => parserContext.invariant(byte, 'Expected non-null byte'))(), nullByteParser), ([sequence]) => Buffer.from(sequence).toString('utf8'));
 const doubleParser = promiseCompose(buffer8Parser, buffer => buffer.readDoubleLE(0));
+setParserName(doubleParser, 'doubleParser');
 const int32Parser = promiseCompose(buffer4Parser, buffer => buffer.readInt32LE(0));
+setParserName(int32Parser, 'int32Parser');
 const uint32Parser = promiseCompose(buffer4Parser, buffer => buffer.readUInt32LE(0));
+setParserName(uint32Parser, 'uint32Parser');
 const createFixedLengthStringParser = (length) => promiseCompose(createFixedLengthBufferParser(length), buffer => buffer.toString('utf8'));
 const createFixedLengthNullTerminatedStringParser = (lengthWihoutNullTerminator) => promiseCompose(createTupleParser([
     createFixedLengthStringParser(lengthWihoutNullTerminator),
@@ -29,12 +31,14 @@ const bsonStringParser = async (parserContext) => {
     const stringSize = await uint32Parser(parserContext);
     return createFixedLengthNullTerminatedStringParser(stringSize - 1)(parserContext);
 };
+setParserName(bsonStringParser, 'bsonStringParser');
 const bsonArrayParser = promiseCompose(createTupleParser([
     createSkipParser(4),
     createParserAccessorParser(() => bsonElementListParser),
 ]), ([_, elements]) => elements.map(([_, value]) => value));
+setParserName(bsonArrayParser, 'bsonArrayParser');
 const bsonBooleanParser = async (parserContext) => {
-    const booleanValue = invariantDefined(await parserContext.read(0), 'Unexpected end of input');
+    const booleanValue = await parserContext.read(0);
     return booleanValue === 1;
 };
 const int8Parser = promiseCompose(buffer1Parser, buffer => buffer.readInt8(0));

package/build/customInvariant.d.ts

@@ -1,4 +1,4 @@
 import { type Constructor } from 'type-fest';
 export type Falsy = '' | 0 | false | undefined;
 export type ValueOrAccessor<T> = T | (() => T);
-export declare function customInvariant<T>(ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+export declare function customInvariant<T>(ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: (unknown | (() => unknown))[]): Exclude<T, Falsy>;