@futpib/parser 1.0.1 → 1.0.2

package/build/zipFile.d.ts

@@ -1,32 +0,0 @@
-export type ZipStoreCompression = {
-    type: 'store';
-};
-export type ZipDeflateCompression = {
-    type: 'deflate';
-    level: number;
-};
-export type ZipCompression = ZipStoreCompression | ZipDeflateCompression;
-export type ZipFileEntry = {
-    type: 'file';
-    name: string;
-    date: Date;
-    comment: Uint8Array;
-    unixPermissions: number;
-    dosPermissions: number;
-    compression: ZipCompression;
-    content: Uint8Array;
-};
-export type ZipDirectoryEntry = {
-    type: 'directory';
-    name: string;
-    date: Date;
-    comment: Uint8Array;
-    unixPermissions: number;
-    dosPermissions: number;
-    entries: ZipEntry[];
-};
-export type ZipEntry = ZipFileEntry | ZipDirectoryEntry;
-export type ZipFile = {
-    root: ZipDirectoryEntry;
-    comment: Uint8Array;
-};

package/build/zipFileEntry.d.ts

@@ -1,6 +0,0 @@
-export type ZipFileEntry = {
-    type: 'file';
-    name: string;
-    date: Date;
-    content: Uint8Array;
-};

package/src/apk.ts

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

package/src/apkParser.ts

@@ -1,392 +0,0 @@
-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,
-    ZipCentralDirectoryHeader,
-	zipCentralDirectoryHeaderParser,
-    ZipEndOfCentralDirectoryRecord,
-	zipEndOfCentralDirectoryRecordParser,
-	zipFromZipSegments,
-    ZipLocalFile,
-	zipLocalFileParser,
-} from './zipParser.js';
-import { ApkSignatureV2AdditionalAttribute, ApkSignatureV2Digest, ApkSignatureV2Signature, ApkSignatureV2SignedData, ApkSignatureV2Signer, type Apk, type ApkSigningBlock, type ApkSigningBlockPair } from './apk.js';
-import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
-import { parserCreatorCompose } from './parserCreatorCompose.js';
-import { createExactSequenceParser } from './exactSequenceParser.js';
-import { createSliceBoundedParser } from './sliceBoundedParser.js';
-import { createDisjunctionParser } from './disjunctionParser.js';
-import { createExactElementParser } from './exactElementParser.js';
-import { createParserConsumedSequenceParser } from './parserConsumedSequenceParser.js';
-
-// https://source.android.com/docs/security/features/apksigning/v2#apk-signing-block
-
-const uint32LEParser: 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 ApkSigningBlockZeroPaddingPair = {
-	type: 'zeroPadding';
-	length: number;
-};
-
-const createApkSigningBlockZeroPaddingPairInnerParser = (length: number): Parser<ApkSigningBlockZeroPaddingPair, Uint8Array> => promiseCompose(
-	createTupleParser([
-		createExactSequenceParser<Uint8Array>(Buffer.from('77657242', 'hex')),
-		createFixedLengthSequenceParser(length - 4),
-	]),
-	([ _magic, zeroPadding ]) => ({ type: 'zeroPadding', length: zeroPadding.length }),
-);
-
-type ApkSigningBlockSignatureV2Pair = {
-	type: 'signatureV2';
-	signers: ApkSignatureV2Signer[];
-};
-
-const createApkSigningBlockSignatureV2PairInnerParser = (length: number): Parser<ApkSigningBlockSignatureV2Pair, Uint8Array> => {
-	const apkSigningBlockSignatureV2PairInnerParser = promiseCompose(
-		createTupleParser([
-			createExactSequenceParser<Uint8Array>(Buffer.from('1a870971', 'hex')),
-			apkSignatureV2SignersParser,
-		]),
-		([ _magic, signers = [] ]) => ({ type: 'signatureV2' as const, signers }),
-	);
-
-	return setParserName(apkSigningBlockSignatureV2PairInnerParser, 'apkSigningBlockSignatureV2PairInnerParser');
-};
-
-type ApkSigningBlockGenericPair = {
-	type: 'generic';
-	pair: ApkSigningBlockPair;
-};
-
-const createApkSigningBlockGenericPairInnerParser = (length: number): Parser<ApkSigningBlockGenericPair, Uint8Array> => promiseCompose(
-	createTupleParser([
-		uint32LEParser,
-		createFixedLengthSequenceParser(length - 4),
-	]),
-	([ id, value ]) => ({ type: 'generic', pair: { id, value } }),
-);
-
-type ApkSigningBlockPairType =
-	| ApkSigningBlockZeroPaddingPair
-	| ApkSigningBlockSignatureV2Pair
-	| ApkSigningBlockGenericPair
-;
-
-const createApkSigningBlockPairInnerParser = (length: number): Parser<ApkSigningBlockPairType, Uint8Array> => createDisjunctionParser([
-	createApkSigningBlockZeroPaddingPairInnerParser(length),
-	createApkSigningBlockSignatureV2PairInnerParser(length),
-	createApkSigningBlockGenericPairInnerParser(length),
-]);
-
-const apkSigningBlockPairParser: Parser<ApkSigningBlockPairType, Uint8Array> = createUint64LengthPrefixedParser(
-	length => createApkSigningBlockPairInnerParser(Number(length)),
-);
-
-setParserName(apkSigningBlockPairParser, 'apkSigningBlockPairParser');
-
-const apkSigningBlockPairsParser: Parser<ApkSigningBlockPairType[], Uint8Array> = createArrayParser(apkSigningBlockPairParser);
-
-export const apkSigningBlockParser: Parser<ApkSigningBlock, Uint8Array> = createUint64LengthPrefixedParser(
-	sizeOfBlock => promiseCompose(
-		createTupleParser([
-			apkSigningBlockPairsParser,
-			uint64LEParser,
-			createExactSequenceParser<Uint8Array>(Buffer.from('APK Sig Block 42', 'utf8')),
-		]),
-		async ([ pairs, sizeOfBlockRepeated, _magic ]): Promise<ApkSigningBlock> => {
-			invariant(sizeOfBlock === sizeOfBlockRepeated, 'Size of block mismatch: %s !== %s.', sizeOfBlock, sizeOfBlockRepeated);
-
-			const zeroPaddingPair = pairs.find(pair => pair.type === 'zeroPadding');
-			const signatureV2Pair = pairs.find(pair => pair.type === 'signatureV2');
-
-			const genericPairs = (
-				pairs
-					.filter(pair => (
-						pair !== zeroPaddingPair
-							&& pair !== signatureV2Pair
-					))
-					.map(pair => {
-						invariant(pair.type === 'generic', 'Expected generic pair, got %s.', pair.type);
-						return pair.pair;
-					})
-			);
-
-			return {
-				zeroPaddingLength: zeroPaddingPair?.length,
-				signatureV2: signatureV2Pair ? {
-					signers: signatureV2Pair?.signers,
-				} : undefined,
-				pairs: genericPairs,
-			};
-		},
-	),
-);
-
-const apkSignatureV2DigestParser = createUint32LengthPrefixedParser<ApkSignatureV2Digest>(
-	pairLength => promiseCompose(
-		createTupleParser([
-			uint32LEParser,
-			createUint32LengthPrefixedParser(
-				digestLength => createFixedLengthSequenceParser(digestLength),
-			),
-		]),
-		([ signatureAlgorithmId, digest ]) => ({ signatureAlgorithmId, digest }),
-	),
-);
-
-const apkSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureV2DigestParser,
-);
-
-const apkSignatureV2CertificateParser = createUint32LengthPrefixedParser(
-	certificateLength => createFixedLengthSequenceParser(certificateLength),
-);
-
-const apkSignatureV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureV2CertificateParser,
-);
-
-const apkSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser<ApkSignatureV2AdditionalAttribute>(
-	pairLength => promiseCompose(
-		createTupleParser([
-			uint32LEParser,
-			createFixedLengthSequenceParser(pairLength - 4),
-		]),
-		([ id, value ]) => ({ id, value }),
-	),
-);
-
-setParserName(apkSignatureV2AdditionalAttributeParser, 'apkSignatureV2AdditionalAttributeParser');
-
-const apkSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureV2AdditionalAttributeParser,
-);
-
-setParserName(apkSignatureV2AdditionalAttributesParser, 'apkSignatureV2AdditionalAttributesParser');
-
-const apkSignatureV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(
-	promiseCompose(
-		createTupleParser([
-			apkSignatureV2DigestsParser,
-			apkSignatureV2CertificatesParser,
-			apkSignatureV2AdditionalAttributesParser,
-			createArrayParser(createExactElementParser(0)),
-		]),
-		([
-			digests,
-			certificates,
-			additionalAttributes,
-			zeroPadding,
-		]): ApkSignatureV2SignedData => ({
-			digests,
-			certificates,
-			additionalAttributes,
-			zeroPaddingLength: zeroPadding.length,
-		}),
-	),
-);
-
-setParserName(apkSignatureV2SignedDataParser, 'apkSignatureV2SignedDataParser');
-
-const apkSignatureV2SignatureParser = createUint32LengthPrefixedParser(
-	signatureLength => promiseCompose(
-		createTupleParser([
-			uint32LEParser,
-			createUint32LengthPrefixedParser(
-				signatureLength => createFixedLengthSequenceParser(signatureLength),
-			),
-		]),
-		([
-			signatureAlgorithmId,
-			signature,
-		]): ApkSignatureV2Signature => ({
-			signatureAlgorithmId,
-			signature,
-		}),
-	),
-);
-
-const apkSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureV2SignatureParser,
-);
-
-setParserName(apkSignatureV2SignaturesParser, 'apkSignatureV2SignaturesParser');
-
-const apkSignatureV2PublicKeyParser = createUint32LengthPrefixedParser(
-	publicKeyLength => createFixedLengthSequenceParser(publicKeyLength),
-);
-
-setParserName(apkSignatureV2PublicKeyParser, 'apkSignatureV2PublicKeyParser');
-
-const apkSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(
-	promiseCompose(
-		createTupleParser([
-			apkSignatureV2SignedDataParser,
-			apkSignatureV2SignaturesParser,
-			apkSignatureV2PublicKeyParser,
-		]),
-		([
-			signedData,
-			signatures = [],
-			publicKey,
-		]): ApkSignatureV2Signer => ({
-			signedData,
-			signatures,
-			publicKey,
-		}),
-	),
-);
-
-setParserName(apkSignatureV2SignerParser, 'apkSignatureV2SignerParser');
-
-const apkSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(
-	apkSignatureV2SignerParser,
-);
-
-setParserName(apkSignatureV2SignersParser, 'apkSignatureV2SignersParser');
-
-const apkParser_ = createTupleParser([
-	createArrayParser(zipLocalFileParser),
-	createOptionalParser(zipArchiveDecryptionHeaderParser),
-	createOptionalParser(zipArchiveExtraDataRecordParser),
-	createOptionalParser(apkSigningBlockParser),
-	createArrayParser(zipCentralDirectoryHeaderParser),
-	createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
-	createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
-	zipEndOfCentralDirectoryRecordParser,
-]);
-
-setParserName(apkParser_, 'apkParser_');
-
-export const apkParser: Parser<Apk, Uint8Array> = promiseCompose(
-	apkParser_,
-	async ([
-		zipLocalFiles,
-		zipArchiveDecryptionHeader,
-		zipArchiveExtraDataRecord,
-		apkSigningBlock,
-		zipCentralDirectoryHeaders,
-		zip64EndOfCentralDirectoryRecord,
-		zip64EndOfCentralDirectoryLocator,
-		zipEndOfCentralDirectoryRecord,
-	]) => {
-		const zip = await zipFromZipSegments({
-			zipLocalFiles,
-			zipCentralDirectoryHeaders,
-			zipEndOfCentralDirectoryRecord,
-		});
-
-		return {
-			...zip,
-			signingBlock: apkSigningBlock,
-		};
-	},
-);
-
-setParserName(apkParser, 'apkParser');
-
-export type ApkSignableSections = {
-	zipLocalFiles: ZipLocalFile[];
-	apkSigningBlock?: ApkSigningBlock;
-	zipCentralDirectory: ZipCentralDirectoryHeader[];
-	zipEndOfCentralDirectory: ZipEndOfCentralDirectoryRecord;
-
-	zipLocalFilesUint8Array: Uint8Array;
-	apkSigningBlockUint8Array?: Uint8Array;
-	zipCentralDirectoryUint8Array: Uint8Array;
-	zipEndOfCentralDirectoryUint8Array: Uint8Array;
-}
-
-export const apkSignableSectionsParser: Parser<ApkSignableSections, Uint8Array> = promiseCompose(
-	createTupleParser([
-		createParserConsumedSequenceParser(
-			createTupleParser([
-				createArrayParser(zipLocalFileParser),
-				createOptionalParser(zipArchiveDecryptionHeaderParser),
-				createOptionalParser(zipArchiveExtraDataRecordParser),
-			]),
-		),
-		createOptionalParser(
-			createParserConsumedSequenceParser(
-				apkSigningBlockParser
-			),
-		),
-		createParserConsumedSequenceParser(
-			createTupleParser([
-				createArrayParser(zipCentralDirectoryHeaderParser),
-				createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
-				createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
-			]),
-		),
-		createParserConsumedSequenceParser(
-			zipEndOfCentralDirectoryRecordParser,
-		),
-	]),
-	async ([
-		[
-			[
-				zipLocalFiles,
-			],
-			zipLocalFilesUint8Array,
-		],
-		[
-			apkSigningBlock = undefined,
-			apkSigningBlockUint8Array = undefined,
-		] = [],
-		[
-			[
-				zipCentralDirectory,
-			],
-			zipCentralDirectoryUint8Array,
-		],
-		[
-			zipEndOfCentralDirectory,
-			zipEndOfCentralDirectoryUint8Array,
-		],
-	]) => ({
-		zipLocalFiles,
-		apkSigningBlock,
-		zipCentralDirectory,
-		zipEndOfCentralDirectory,
-
-		zipLocalFilesUint8Array,
-		apkSigningBlockUint8Array,
-		zipCentralDirectoryUint8Array,
-		zipEndOfCentralDirectoryUint8Array,
-	}),
-);

package/src/apkUnparser.test.ts

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

package/src/apkUnparser.ts

@@ -1,120 +0,0 @@
-import { ApkSignatureV2AdditionalAttribute, ApkSignatureV2Digest, ApkSignatureV2Signature, ApkSignatureV2SignedData, ApkSignatureV2Signer, ApkSigningBlock } from "./apk.js";
-import { createArrayUnparser } from "./arrayUnparser.js";
-import { createSequenceUnparser } from "./sequenceUnparser.js";
-import { 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 apkSignatureV2DigestUnparser: Unparser<ApkSignatureV2Digest, Uint8Array> = 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: Unparser<ApkSignatureV2AdditionalAttribute, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
-	yield * uint32LEUnparser(input.id, unparserContext);
-	yield input.value;
-});
-
-const apkSignatureV2AdditionalAttributesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2AdditionalAttributeUnparser));
-
-export const apkSignatureV2SignedDataUnparser: Unparser<ApkSignatureV2SignedData, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
-	yield * apkSignatureV2DigestsUnparser(input.digests, unparserContext);
-	yield * apkSignatureV2CertificatesUnparser(input.certificates, unparserContext);
-	yield * apkSignatureV2AdditionalAttributesUnparser(input.additionalAttributes, unparserContext);
-	if (input.zeroPaddingLength) {
-		yield Buffer.alloc(input.zeroPaddingLength);
-	}
-});
-
-const apkSignatureV2SignatureUnparser: Unparser<ApkSignatureV2Signature, Uint8Array> = 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: Unparser<ApkSignatureV2Signer, Uint8Array> = createUint32LengthPrefixedUnparser(async function * (input, unparserContext) {
-	yield * apkSignatureV2SignedDataUnparser(input.signedData, unparserContext);
-	yield * apkSignatureV2SignaturesUnparser(input.signatures, unparserContext);
-	yield * apkSignatureV2PublicKeyUnparser(input.publicKey, unparserContext);
-});
-
-const apkSignatureV2SignersUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2SignerUnparser));
-
-type ApkSigningBlockPair = {
-	id: number;
-	value: Uint8Array | ApkSignatureV2Signer[];
-};
-
-const apkSigningBlockPairUnparser: Unparser<ApkSigningBlockPair, Uint8Array> = createUint64LengthPrefixedUnparser(async function * (input, unparserContext) {
-	yield * uint32LEUnparser(input.id, unparserContext);
-	if (input.value instanceof Uint8Array) {
-		yield input.value;
-	} else {
-		yield * apkSignatureV2SignersUnparser(input.value, unparserContext);
-	}
-});
-
-const apkSigningBlockPairsUnparser = createArrayUnparser(apkSigningBlockPairUnparser);
-
-export const apkSigningBlockUnparser: Unparser<ApkSigningBlock, Uint8Array> = 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 * apkSigningBlockPairsUnparser(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/invariantDefined.ts

@@ -1,6 +0,0 @@
-import invariant from 'invariant';
-
-export function invariantDefined<T>(value: T, format: string, ...extra: any[]): Exclude<T, undefined> {
-	invariant(value !== undefined, format, ...extra);
-	return value as any;
-}

package/src/invariantIdentity.ts

@@ -1,8 +0,0 @@
-import invariant from 'invariant';
-
-type Falsy = '' | 0 | false | undefined ;
-
-export function invariantIdentity<T>(value: T, format: string, ...extra: any[]): Exclude<T, Falsy> {
-	invariant(value, format, ...extra);
-	return value as any;
-}