@futpib/parser 1.0.0 → 1.0.1

package/build/zipParser.test.js

@@ -1,17 +1,12 @@
 import { testProp } from '@fast-check/ava';
 import { arbitraryZipStream } from './arbitraryZipStream.js';
 import { zipParser } from './zipParser.js';
-import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
-async function* readableStreamToUint8ArrayAsyncIterator(stream) {
-    for await (const chunk of stream) {
-        yield chunk;
-    }
-}
 testProp('zip', [
     arbitraryZipStream,
 ], async (t, [zip, zipStream]) => {
-    const actual = await runParser(zipParser, readableStreamToUint8ArrayAsyncIterator(zipStream), uint8ArrayInputCompanion, {
+    const actual = await runParser(zipParser, zipStream, uint8ArrayParserInputCompanion, {
         errorJoinMode: 'all',
     });
     actual.entries.sort((a, b) => a.path.localeCompare(b.path));

package/build/zipUnparser.d.ts

@@ -0,0 +1,5 @@
+import { Unparser } from "./unparser.js";
+import { Zip } from "./zip.js";
+import { ZipEndOfCentralDirectoryRecord } from './zipParser.js';
+export declare const zipEndOfCentralDirectoryRecordUnparser: Unparser<ZipEndOfCentralDirectoryRecord, Uint8Array>;
+export declare const zipUnparser: Unparser<Zip, Uint8Array>;

package/build/zipUnparser.js

@@ -0,0 +1,171 @@
+import zlib from 'node:zlib';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
+const uint16LEUnparser = async function* (uint16LE) {
+    const buffer = Buffer.alloc(2);
+    buffer.writeUInt16LE(uint16LE);
+    yield buffer;
+};
+const uint32LEUnparser = async function* (uint32LE) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32LE(uint32LE);
+    yield buffer;
+};
+const uint16LEPrefixedUint8ArrayUnparser = async function* (uint8Array, unparserContext) {
+    yield* uint16LEUnparser(uint8Array.length, unparserContext);
+    yield uint8Array;
+};
+const uint16LEPrefixedStringUnparser = async function* (string, unparserContext) {
+    yield* uint16LEPrefixedUint8ArrayUnparser(Buffer.from(string, 'utf8'), unparserContext);
+};
+const dosDateTimeUnparser = async function* (date, unparserContext) {
+    yield* uint16LEUnparser((date.getUTCSeconds() / 2
+        | date.getUTCMinutes() << 5
+        | date.getUTCHours() << 11), unparserContext);
+    yield* uint16LEUnparser((date.getUTCDate()
+        | (date.getUTCMonth() + 1) << 5
+        | (date.getUTCFullYear() - 1980) << 9), unparserContext);
+};
+const zipCompressionMethodUnparser = async function* (compressionMethod, unparserContext) {
+    if (compressionMethod === 'store') {
+        yield* uint16LEUnparser(0, unparserContext);
+    }
+    else {
+        yield* uint16LEUnparser(8, unparserContext);
+    }
+};
+export const zipEndOfCentralDirectoryRecordUnparser = async function* (zipEndOfCentralDirectoryRecord, unparserContext) {
+    yield Buffer.from('504b0506', 'hex');
+    yield* uint16LEUnparser(zipEndOfCentralDirectoryRecord.numberOfThisDisk, unparserContext);
+    yield* uint16LEUnparser(zipEndOfCentralDirectoryRecord.numberOfTheDiskWithTheStartOfTheCentralDirectory, unparserContext);
+    yield* uint16LEUnparser(zipEndOfCentralDirectoryRecord.totalNumberOfEntriesInTheCentralDirectoryOnThisDisk, unparserContext);
+    yield* uint16LEUnparser(zipEndOfCentralDirectoryRecord.totalNumberOfEntriesInTheCentralDirectory, unparserContext);
+    yield* uint32LEUnparser(zipEndOfCentralDirectoryRecord.sizeOfTheCentralDirectory, unparserContext);
+    yield* uint32LEUnparser(zipEndOfCentralDirectoryRecord.offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber, unparserContext);
+    yield* uint16LEPrefixedStringUnparser(zipEndOfCentralDirectoryRecord.zipFileComment, unparserContext);
+};
+export const zipUnparser = async function* (zip, unparserContext) {
+    const compressedContentByZipFileEntry = new Map(zip.entries.flatMap(zipEntry => {
+        if (zipEntry.type !== 'file') {
+            return [];
+        }
+        if (zipEntry.compression === 'store') {
+            return [[zipEntry, Promise.resolve(zipEntry.content)]];
+        }
+        const uncompressedContent = zipEntry.content;
+        const deflate = zlib.createDeflateRaw();
+        const input = Readable.from(Buffer.from(uncompressedContent));
+        const promise = Promise.all([
+            pipeline(input, deflate),
+            uint8ArrayAsyncIterableToUint8Array(deflate),
+        ]);
+        return [[zipEntry, promise.then(([, compressedContent]) => compressedContent)]];
+    }));
+    const filePathByZipEntry = new Map(zip.entries.map(zipEntry => [zipEntry, zipEntry.type === 'file' ? zipEntry.path : zipEntry.path + '/']));
+    const localHeaderPositionByZipEntry = new Map();
+    for (const zipEntry of zip.entries) {
+        localHeaderPositionByZipEntry.set(zipEntry, unparserContext.position);
+        yield Buffer.from('504b0304', 'hex');
+        yield* uint16LEUnparser(10, unparserContext); // version needed to extract
+        yield* uint16LEUnparser(0, unparserContext); // general purpose bit flag
+        if (zipEntry.type === 'file') {
+            yield* zipCompressionMethodUnparser(zipEntry.compression, unparserContext);
+        }
+        else {
+            yield* uint16LEUnparser(0, unparserContext);
+        }
+        yield* dosDateTimeUnparser(zipEntry.date, unparserContext);
+        if (zipEntry.type === 'file') {
+            const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
+            yield* uint32LEUnparser(0, unparserContext); // crc32 // TODO
+            yield* uint32LEUnparser(compressedContent.length, unparserContext);
+            yield* uint32LEUnparser(zipEntry.content.length, unparserContext);
+        }
+        else {
+            yield* uint32LEUnparser(0, unparserContext);
+            yield* uint32LEUnparser(0, unparserContext);
+            yield* uint32LEUnparser(0, unparserContext);
+        }
+        const filePath = filePathByZipEntry.get(zipEntry);
+        const filePathBuffer = Buffer.from(filePath, 'utf8');
+        const extraFieldBuffer = Buffer.alloc(0);
+        yield* uint16LEUnparser(filePathBuffer.length, unparserContext);
+        yield* uint16LEUnparser(extraFieldBuffer.length, unparserContext);
+        yield filePathBuffer;
+        yield extraFieldBuffer;
+        if (zipEntry.type === 'file') {
+            const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
+            yield compressedContent;
+        }
+    }
+    const startOfCentralDirectoryPosition = unparserContext.position;
+    for (const zipEntry of zip.entries) {
+        yield Buffer.from('504b0102', 'hex');
+        if (zipEntry.hostSystem === 'unix') {
+            yield 0; // zip specification version
+            yield 3; // host system
+        }
+        else {
+            yield 0;
+            yield 0;
+        }
+        yield* uint16LEUnparser(0, unparserContext); // version needed to extract
+        yield* uint16LEUnparser(0, unparserContext); // general purpose bit flag
+        if (zipEntry.type === 'file') {
+            yield* zipCompressionMethodUnparser(zipEntry.compression, unparserContext);
+        }
+        else {
+            yield* uint16LEUnparser(0, unparserContext);
+        }
+        yield* dosDateTimeUnparser(zipEntry.date, unparserContext);
+        if (zipEntry.type === 'file') {
+            const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
+            yield* uint32LEUnparser(0, unparserContext); // crc32 // TODO
+            yield* uint32LEUnparser(compressedContent.length, unparserContext);
+            yield* uint32LEUnparser(zipEntry.content.length, unparserContext);
+        }
+        else {
+            yield* uint32LEUnparser(0, unparserContext);
+            yield* uint32LEUnparser(0, unparserContext);
+            yield* uint32LEUnparser(0, unparserContext);
+        }
+        const filePath = filePathByZipEntry.get(zipEntry);
+        const filePathBuffer = Buffer.from(filePath, 'utf8');
+        yield* uint16LEUnparser(filePathBuffer.length, unparserContext);
+        const extraFieldBuffer = Buffer.alloc(0);
+        yield* uint16LEUnparser(extraFieldBuffer.length, unparserContext);
+        const fileCommentBuffer = Buffer.from(zipEntry.comment, 'utf8');
+        yield* uint16LEUnparser(fileCommentBuffer.length, unparserContext);
+        yield* uint16LEUnparser(0, unparserContext); // disk number start
+        yield* uint16LEUnparser(0, unparserContext); // internal file attributes
+        if (zipEntry.hostSystem === 'unix') {
+            yield* uint32LEUnparser((0
+                | (zipEntry.type === 'directory'
+                    ? (0b0100_0000_0000_0000 << 16)
+                    : (0b1000_0000_0000_0000 << 16))) >>> 0, unparserContext);
+        }
+        else {
+            yield* uint32LEUnparser((0
+                | (zipEntry.type === 'directory'
+                    ? 0b0001_0000
+                    : 0)), unparserContext);
+        }
+        const localHeaderPosition = localHeaderPositionByZipEntry.get(zipEntry);
+        yield* uint32LEUnparser(localHeaderPosition, unparserContext);
+        yield filePathBuffer;
+        yield extraFieldBuffer;
+        yield fileCommentBuffer;
+    }
+    const endOfCentralDirectoryPosition = unparserContext.position;
+    const sizeOfTheCentralDirectory = endOfCentralDirectoryPosition - startOfCentralDirectoryPosition;
+    yield* zipEndOfCentralDirectoryRecordUnparser({
+        numberOfThisDisk: 0,
+        numberOfTheDiskWithTheStartOfTheCentralDirectory: 0,
+        totalNumberOfEntriesInTheCentralDirectoryOnThisDisk: zip.entries.length,
+        totalNumberOfEntriesInTheCentralDirectory: zip.entries.length,
+        sizeOfTheCentralDirectory,
+        offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber: startOfCentralDirectoryPosition,
+        zipFileComment: zip.comment,
+    }, unparserContext);
+};

package/build/zipUnparser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/zipUnparser.test.js

@@ -0,0 +1,80 @@
+import { testProp } from '@fast-check/ava';
+import { temporaryFile } from 'tempy';
+import { execa } from 'execa';
+import fsPromises from 'node:fs/promises';
+import { runUnparser } from './unparser.js';
+import { zipUnparser } from './zipUnparser.js';
+import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
+import { runParser } from './parser.js';
+import { zipParser } from './zipParser.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { arbitraryZip } from './arbitraryZip.js';
+async function hasExecutable(executable) {
+    const hasExecutable = execa(executable).then(() => true, () => false);
+    if (!hasExecutable) {
+        console.warn(`Executable %o not found`, executable);
+    }
+    return hasExecutable;
+}
+const hasZipinfoPromise = hasExecutable('zipinfo');
+const has7zPromise = hasExecutable('7z');
+async function zipinfo(zipFilePath) {
+    const { stdout } = await execa('zipinfo', [
+        '-v',
+        zipFilePath,
+    ], {
+        reject: false,
+    });
+    return {
+        isEmptyZipfile: stdout.endsWith('Empty zipfile.'),
+    };
+}
+async function _7zList(zipFilePath) {
+    const { stdout } = await execa('7z', [
+        'l',
+        zipFilePath,
+    ], {
+        reject: false,
+    });
+    if (/Errors: \d+$/.test(stdout)) {
+        throw new Error(`7z reports errors: ${stdout}`);
+    }
+    return {
+        isEmptyZipfile: false, // TODO
+    };
+}
+testProp('zip', [
+    arbitraryZip,
+], async (t, zip) => {
+    const actualStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
+    const actual = await runParser(zipParser, actualStream, uint8ArrayParserInputCompanion);
+    const isDeepEqual = t.deepEqual(actual, zip);
+    if (!isDeepEqual) {
+        return;
+    }
+    const hasZipinfo = await hasZipinfoPromise;
+    const has7z = await has7zPromise;
+    if (!hasZipinfo && !has7z) {
+        return;
+    }
+    const temporaryFilePath = temporaryFile({
+        extension: 'zip',
+    });
+    const zipStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
+    await fsPromises.writeFile(temporaryFilePath, zipStream);
+    if (has7z) {
+        const { isEmptyZipfile, } = await _7zList(temporaryFilePath);
+        if (isEmptyZipfile) {
+            t.deepEqual(actual.entries, [], '7z reports the zipfile as empty, but it has entries');
+        }
+    }
+    if (hasZipinfo) {
+        const { isEmptyZipfile, } = await zipinfo(temporaryFilePath);
+        if (isEmptyZipfile) {
+            t.deepEqual(actual.entries.filter(entry => entry.type === 'file'), [], 'zipinfo reports the zipfile as empty, but it has file entries');
+        }
+    }
+    await fsPromises.unlink(temporaryFilePath);
+}, {
+    verbose: true,
+});

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@futpib/parser",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "build/index.js",
   "license": "GPL-3.0-only",
   "type": "module",
   "scripts": {
     "dev": "tsc --watch",
     "build": "tsc",
-    "test": "xo && c8 ava",
+    "test": "c8 ava",
     "prepack": "yarn build"
   },
   "homepage": "https://github.com/futpib/parser",
@@ -30,9 +30,11 @@
     "c8": "^10.1.2",
     "coveralls": "^3.1.1",
     "eslint-config-xo-typescript-overrides": "^1.6.1",
+    "execa": "^9.5.2",
     "fast-check": "^3.23.1",
     "invariant": "^2.2.4",
     "jszip": "^3.10.1",
+    "tempy": "^3.1.0",
     "type-fest": "^4.29.0",
     "typescript": "^5.7.2",
     "xo": "^0.59.3"

package/src/apk.ts

@@ -1,14 +1,46 @@
-import { Zip } from './zip.js';
+import { type Zip } from './zip.js';
 
 export type ApkSigningBlockPair = {
 	id: number;
 	value: Uint8Array;
 };
 
-export type ApkSigningBlock = {
+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;
-	signatureV2?: unknown;
+};
+
+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 & {

package/src/apkParser.test.ts

@@ -1,5 +1,5 @@
 import test from 'ava';
-import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
 import { apkParser } from './apkParser.js';
 
@@ -14,7 +14,7 @@ for (const apkCid of [
 
 			const apkStream = apkResponse.body!;
 
-			const actual = await runParser(apkParser, apkStream, uint8ArrayInputCompanion, {
+			const actual = await runParser(apkParser, apkStream, uint8ArrayParserInputCompanion, {
 				errorJoinMode: 'all',
 			});