@futpib/parser 1.0.1 → 1.0.3

package/src/androidPackageParser.ts

@@ -0,0 +1,398 @@
+import invariant from 'invariant';
+import { createArrayParser } from './arrayParser.js';
+import { createOptionalParser } from './optionalParser.js';
+import { type Parser, setParserName } from './parser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import {
+	zip64EndOfCentralDirectoryLocatorParser,
+	zip64EndOfCentralDirectoryRecordParser,
+	zipArchiveDecryptionHeaderParser,
+	zipArchiveExtraDataRecordParser,
+	type ZipCentralDirectoryHeader,
+	zipCentralDirectoryHeaderParser,
+	type ZipEndOfCentralDirectoryRecord,
+	zipEndOfCentralDirectoryRecordParser,
+	zipFromZipSegments,
+	type ZipLocalFile,
+	zipLocalFileParser,
+} from './zipParser.js';
+import {
+	type AndroidPackageSignatureV2AdditionalAttribute, type AndroidPackageSignatureV2Digest, type AndroidPackageSignatureV2Signature, type AndroidPackageSignatureV2SignedData, type AndroidPackageSignatureV2Signer, type AndroidPackage, type AndroidPackageSigningBlock, type AndroidPackageSigningBlockPair,
+} from './androidPackage.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';
+import { createDebugLogInputParser } from './debugLogInputParser.js';
+import { createDebugLogParser } from './debugLogParser.js';
+import { createElementParser } from './elementParser.js';
+
+// https://source.android.com/docs/security/features/androidPackagesigning/v2#androidPackage-signing-block
+
+const uint32LEParser: Parser<number, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser(4),
+	array => Buffer.from(array).readUInt32LE(),
+);
+
+setParserName(uint32LEParser, 'uint32LEParser');
+
+const uint64LEParser: Parser<bigint, Uint8Array> = promiseCompose(
+	createFixedLengthSequenceParser(8),
+	array => Buffer.from(array).readBigUInt64LE(),
+);
+
+setParserName(uint64LEParser, 'uint64LEParser');
+
+const createUint32LengthPrefixedParser = <T>(createInnerParser: (length: number) => Parser<T, Uint8Array>): Parser<T, Uint8Array> => parserCreatorCompose(
+	() => uint32LEParser,
+	length => createInnerParser(length),
+)();
+
+const createUint64LengthPrefixedParser = <T>(createInnerParser: (length: bigint) => Parser<T, Uint8Array>): Parser<T, Uint8Array> => parserCreatorCompose(
+	() => uint64LEParser,
+	length => createInnerParser(length),
+)();
+
+const createUint32LengthPrefixedSliceBoundedParser = <T>(innerParser: Parser<T, Uint8Array>): Parser<T, Uint8Array> => createUint32LengthPrefixedParser(length => createSliceBoundedParser(innerParser, length));
+
+const createUint32LengthPrefixedSliceBoundedArrayParser = <T>(innerParser: Parser<T, Uint8Array>): Parser<T[], Uint8Array> => createUint32LengthPrefixedSliceBoundedParser(createArrayParser(innerParser));
+
+type AndroidPackageSigningBlockZeroPaddingPair = {
+	type: 'zeroPadding';
+	length: number;
+};
+
+const createAndroidPackageSigningBlockZeroPaddingPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockZeroPaddingPair, Uint8Array> => {
+	const androidPackageSigningBlockZeroPaddingPairInnerParser: Parser<AndroidPackageSigningBlockZeroPaddingPair, Uint8Array> = promiseCompose(
+		createTupleParser([
+			createExactSequenceParser<Uint8Array>(Buffer.from('77657242', 'hex')),
+			createFixedLengthSequenceParser(length - 4),
+		]),
+		([ _magic, zeroPadding ]) => ({ type: 'zeroPadding', length: zeroPadding.length }),
+	);
+
+	setParserName(androidPackageSigningBlockZeroPaddingPairInnerParser, 'androidPackageSigningBlockZeroPaddingPairInnerParser');
+
+	return androidPackageSigningBlockZeroPaddingPairInnerParser;
+};
+
+type AndroidPackageSigningBlockSignatureV2Pair = {
+	type: 'signatureV2';
+	signers: AndroidPackageSignatureV2Signer[];
+};
+
+const createAndroidPackageSigningBlockSignatureV2PairInnerParser = (length: number): Parser<AndroidPackageSigningBlockSignatureV2Pair, Uint8Array> => {
+	const androidPackageSigningBlockSignatureV2PairInnerParser = promiseCompose(
+		createTupleParser([
+			createExactSequenceParser<Uint8Array>(Buffer.from('1a870971', 'hex')),
+			androidPackageSignatureV2SignersParser,
+		]),
+		([ _magic, signers = [] ]) => ({ type: 'signatureV2' as const, signers }),
+	);
+
+	return setParserName(androidPackageSigningBlockSignatureV2PairInnerParser, 'androidPackageSigningBlockSignatureV2PairInnerParser');
+};
+
+type AndroidPackageSigningBlockGenericPair = {
+	type: 'generic';
+	pair: AndroidPackageSigningBlockPair;
+};
+
+const createAndroidPackageSigningBlockGenericPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockGenericPair, Uint8Array> => promiseCompose(
+	createTupleParser([
+		uint32LEParser,
+		createFixedLengthSequenceParser(length - 4),
+	]),
+	([ id, value ]) => ({ type: 'generic', pair: { id, value } }),
+);
+
+type AndroidPackageSigningBlockPairType =
+	| AndroidPackageSigningBlockZeroPaddingPair
+	| AndroidPackageSigningBlockSignatureV2Pair
+	| AndroidPackageSigningBlockGenericPair
+;
+
+const createAndroidPackageSigningBlockPairInnerParser = (length: number): Parser<AndroidPackageSigningBlockPairType, Uint8Array> => {
+	const androidPackageSigningBlockPairInnerParser: Parser<AndroidPackageSigningBlockPairType, Uint8Array> = promiseCompose(
+		createTupleParser([
+			parserContext => {
+				parserContext.invariant(
+					Number.isSafeInteger(length),
+					'Signing block length is unreasonable: %s.',
+					length,
+				);
+			},
+			createDisjunctionParser<AndroidPackageSigningBlockPairType, Uint8Array>([
+				createAndroidPackageSigningBlockZeroPaddingPairInnerParser(length),
+				createAndroidPackageSigningBlockSignatureV2PairInnerParser(length),
+				createAndroidPackageSigningBlockGenericPairInnerParser(length),
+			]),
+		]),
+		([
+			_lengthInvariant,
+			pair,
+		]) => pair,
+	);
+
+	setParserName(androidPackageSigningBlockPairInnerParser, 'androidPackageSigningBlockPairInnerParser');
+
+	return androidPackageSigningBlockPairInnerParser;
+};
+
+const androidPackageSigningBlockPairParser: Parser<AndroidPackageSigningBlockPairType, Uint8Array> = createUint64LengthPrefixedParser(length => createAndroidPackageSigningBlockPairInnerParser(Number(length)));
+
+setParserName(androidPackageSigningBlockPairParser, 'androidPackageSigningBlockPairParser');
+
+const androidPackageSigningBlockPairsParser: Parser<AndroidPackageSigningBlockPairType[], Uint8Array> = createArrayParser(androidPackageSigningBlockPairParser);
+
+export const androidPackageSigningBlockParser: Parser<AndroidPackageSigningBlock, Uint8Array> = createUint64LengthPrefixedParser(sizeOfBlock => promiseCompose(
+	createTupleParser([
+		androidPackageSigningBlockPairsParser,
+		uint64LEParser,
+		createExactSequenceParser<Uint8Array>(Buffer.from('APK Sig Block 42', 'utf8')),
+	]),
+	async ([
+		pairs,
+		sizeOfBlockRepeated,
+		_magic,
+	]): Promise<AndroidPackageSigningBlock> => {
+		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<AndroidPackageSignatureV2Digest>(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<AndroidPackageSignatureV2AdditionalAttribute>(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,
+	]): AndroidPackageSignatureV2SignedData => ({
+		digests,
+		certificates,
+		additionalAttributes,
+		zeroPaddingLength: zeroPadding.length,
+	}),
+));
+
+setParserName(androidPackageSignatureV2SignedDataParser, 'androidPackageSignatureV2SignedDataParser');
+
+const androidPackageSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(
+	createTupleParser([
+		uint32LEParser,
+		createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
+	]),
+	([
+		signatureAlgorithmId,
+		signature,
+	]): AndroidPackageSignatureV2Signature => ({
+		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,
+	]): AndroidPackageSignatureV2Signer => ({
+		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: Parser<AndroidPackage, Uint8Array> = 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 type AndroidPackageSignableSections = {
+	zipLocalFiles: ZipLocalFile[];
+	zipLocalFilesZeroPaddingLength: number;
+	androidPackageSigningBlock?: AndroidPackageSigningBlock;
+	zipCentralDirectory: ZipCentralDirectoryHeader[];
+	zipEndOfCentralDirectory: ZipEndOfCentralDirectoryRecord;
+
+	zipLocalFilesUint8Array: Uint8Array;
+	androidPackageSigningBlockUint8Array?: Uint8Array;
+	zipCentralDirectoryUint8Array: Uint8Array;
+	zipEndOfCentralDirectoryUint8Array: Uint8Array;
+};
+
+export const androidPackageSignableSectionsParser: Parser<AndroidPackageSignableSections, Uint8Array> = 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/src/androidPackageUnparser.test.ts

@@ -0,0 +1,34 @@
+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: string) => providedTitle ?? `androidPackage ${androidPackageCid}`,
+	async exec(t, androidPackageCid: string) {
+		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/src/androidPackageUnparser.ts

@@ -0,0 +1,126 @@
+import {
+	type AndroidPackageSignatureV2AdditionalAttribute, type AndroidPackageSignatureV2Digest, type AndroidPackageSignatureV2Signature, type AndroidPackageSignatureV2SignedData, type AndroidPackageSignatureV2Signer, type AndroidPackageSigningBlock,
+} from './androidPackage.js';
+import { createArrayUnparser } from './arrayUnparser.js';
+import { createSequenceUnparser } from './sequenceUnparser.js';
+import { type Unparser } from './unparser.js';
+
+const uint8ArrayUnparser = createSequenceUnparser<Uint8Array>();
+
+const uint32LEUnparser: Unparser<number, Uint8Array> = async function * (input) {
+	const buffer = Buffer.alloc(4);
+	buffer.writeUInt32LE(input);
+	yield buffer;
+};
+
+const uint64LEUnparser: Unparser<number | bigint, Uint8Array> = async function * (input) {
+	const buffer = Buffer.alloc(8);
+	buffer.writeBigUInt64LE(BigInt(input));
+	yield buffer;
+};
+
+const createUint32LengthPrefixedUnparser = <T>(innerUnparser: Unparser<T, Uint8Array>): Unparser<T, Uint8Array> => 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 = <T>(innerUnparser: Unparser<T, Uint8Array>): Unparser<T, Uint8Array> => 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: Unparser<AndroidPackageSignatureV2Digest, Uint8Array> = 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: Unparser<AndroidPackageSignatureV2AdditionalAttribute, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
+	yield * uint32LEUnparser(input.id, unparserContext);
+	yield input.value;
+});
+
+const androidPackageSignatureV2AdditionalAttributesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(androidPackageSignatureV2AdditionalAttributeUnparser));
+
+export const androidPackageSignatureV2SignedDataUnparser: Unparser<AndroidPackageSignatureV2SignedData, Uint8Array> = 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: Unparser<AndroidPackageSignatureV2Signature, Uint8Array> = 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: Unparser<AndroidPackageSignatureV2Signer, Uint8Array> = 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));
+
+type AndroidPackageSigningBlockPair = {
+	id: number;
+	value: Uint8Array | AndroidPackageSignatureV2Signer[];
+};
+
+const androidPackageSigningBlockPairUnparser: Unparser<AndroidPackageSigningBlockPair, Uint8Array> = 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: Unparser<AndroidPackageSigningBlock, Uint8Array> = 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/src/arbitrarilySlicedAsyncInterable.ts

@@ -1,7 +1,7 @@
-import { inspect } from 'node:util';
 import * as fc from 'fast-check';
 import { type Arbitrary } from 'fast-check';
 import invariant from 'invariant';
+import { inspect } from './inspect.js';
 
 function concat<Sliceable extends string | Uint8Array>(slices: Sliceable[]): Sliceable {
 	const firstSlice = slices.at(0);
@@ -23,9 +23,14 @@ function equals<Sliceable extends string | Uint8Array>(a: Sliceable, b: Sliceabl
 
 export function arbitrarilySlicedAsyncIterable<Sliceable extends string | Uint8Array>(
 	arbitrarySliceable: Arbitrary<Sliceable>,
+	{
+		minSlices = 1,
+	}: {
+		minSlices?: number;
+	} = {},
 ): Arbitrary<[ Sliceable, AsyncIterable<Sliceable> ]> {
 	return (
-		fc.tuple(arbitrarySliceable, fc.array(fc.nat(), { minLength: 1 }))
+		fc.tuple(arbitrarySliceable, fc.array(fc.nat(), { minLength: Math.max(1, minSlices) }))
 			.map(([ sliceable, sliceSizes ]) => {
 				let start = 0;
 

package/src/arbitrarilySlicedAsyncInterator.ts

@@ -1,19 +1,19 @@
 import { type Arbitrary } from 'fast-check';
 import { arbitrarilySlicedAsyncIterable } from './arbitrarilySlicedAsyncInterable.js';
 
-export function arbitrarilySlicedAsyncIterator<Sliceable extends string | Uint8Array>(
-	arbitrarySliceable: Arbitrary<Sliceable>,
-): Arbitrary<[ Sliceable, AsyncIterator<Sliceable> ]> {
+export function arbitrarilySlicedAsyncIterator<Sliceable extends string | Uint8Array>(arbitrarySliceable: Arbitrary<Sliceable>): Arbitrary<[ Sliceable, AsyncIterator<Sliceable> ]> {
 	return (
 		arbitrarilySlicedAsyncIterable(arbitrarySliceable)
 			.map(([ sliceable, asyncIterable ]) => {
 				const asyncIterator_ = asyncIterable[Symbol.asyncIterator]();
 
+				const asyncIterableWithTag = asyncIterable as AsyncIterable<Sliceable> & { [Symbol.toStringTag]?: string };
+
 				const asyncIterator = {
 					next: asyncIterator_.next.bind(asyncIterator_),
 					return: asyncIterator_.return?.bind(asyncIterator_),
 					throw: asyncIterator_.throw?.bind(asyncIterator_),
-					[Symbol.toStringTag]: 'ArbitrarilySlicedAsyncIterator ' + (asyncIterable as any)[Symbol.toStringTag],
+					[Symbol.toStringTag]: 'ArbitrarilySlicedAsyncIterator ' + (asyncIterableWithTag[Symbol.toStringTag] ?? ''),
 				};
 
 				return [