@futpib/parser 1.0.0

package/build/zipParser.d.ts

@@ -0,0 +1,70 @@
+import { Parser } from "./parser.js";
+import { Zip, ZipCompression, ZipEntry } from "./zip.js";
+type ZipLocalFileHeader = {
+    versionNeededToExtract: number;
+    generalPurposeBitFlag: number;
+    compressionMethod: ZipCompression;
+    lastModFile: Date;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    fileName: string;
+    extraField: Uint8Array;
+};
+type ZipLocalFile = {
+    zipLocalFileHeader: ZipLocalFileHeader;
+    zipEncryptionHeader: unknown;
+    compressedData: Uint8Array;
+    zipDataDescriptor: unknown;
+};
+export declare const zipLocalFileParser: Parser<ZipLocalFile, Uint8Array>;
+export declare const zipArchiveDecryptionHeaderParser: Parser<unknown, Uint8Array>;
+export declare const zipArchiveExtraDataRecordParser: Parser<unknown, Uint8Array>;
+type ZipVersionMadeBy = {
+    hostSystem: number;
+    zipSpecificationVersion: number;
+};
+type ZipCentralDirectoryHeader = {
+    versionMadeBy: ZipVersionMadeBy;
+    versionNeededToExtract: number;
+    generalPurposeBitFlag: number;
+    compressionMethod: ZipCompression;
+    lastModFile: Date;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    diskNumberStart: number;
+    internalFileAttributes: number;
+    externalFileAttributes: number;
+    relativeOffsetOfLocalHeader: number;
+    fileName: string;
+    extraField: Uint8Array;
+    fileComment: string;
+};
+export declare const zipCentralDirectoryHeaderParser: Parser<ZipCentralDirectoryHeader, Uint8Array>;
+export declare const zip64EndOfCentralDirectoryRecordParser: Parser<unknown, Uint8Array>;
+export declare const zip64EndOfCentralDirectoryLocatorParser: Parser<unknown, Uint8Array>;
+type ZipEndOfCentralDirectoryRecord = {
+    numberOfThisDisk: number;
+    numberOfTheDiskWithTheStartOfTheCentralDirectory: number;
+    totalNumberOfEntriesInTheCentralDirectoryOnThisDisk: number;
+    totalNumberOfEntriesInTheCentralDirectory: number;
+    sizeOfTheCentralDirectory: number;
+    offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber: number;
+    zipFileComment: string;
+};
+export declare const zipEndOfCentralDirectoryRecordParser: Parser<ZipEndOfCentralDirectoryRecord, Uint8Array>;
+export declare function zipEntriesFromZipSegments({ zipLocalFiles, zipCentralDirectoryHeaders, }: {
+    zipLocalFiles: ZipLocalFile[];
+    zipCentralDirectoryHeaders: ZipCentralDirectoryHeader[];
+}): Promise<ZipEntry[]>;
+export declare function zipFromZipSegments({ zipLocalFiles, zipCentralDirectoryHeaders, zipEndOfCentralDirectoryRecord, }: {
+    zipLocalFiles: ZipLocalFile[];
+    zipCentralDirectoryHeaders: ZipCentralDirectoryHeader[];
+    zipEndOfCentralDirectoryRecord: ZipEndOfCentralDirectoryRecord;
+}): Promise<{
+    comment: string;
+    entries: ZipEntry[];
+}>;
+export declare const zipParser: Parser<Zip, Uint8Array>;
+export {};

package/build/zipParser.js

@@ -0,0 +1,255 @@
+import invariant from "invariant";
+import zlib from "node:zlib";
+import { createArrayParser } from "./arrayParser.js";
+import { createExactSequenceParser } from "./exactSequenceParser.js";
+import { setParserName } from "./parser.js";
+import { createTupleParser } from "./tupleParser.js";
+import { promiseCompose } from "./promiseCompose.js";
+import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
+import { createOptionalParser } from "./optionalParser.js";
+import { parserCreatorCompose } from "./parserCreatorCompose.js";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+// https://pkwaredownloads.blob.core.windows.net/pem/APPNOTE.txt
+const uint16LEParser = promiseCompose(createFixedLengthSequenceParser(2), array => Buffer.from(array).readUInt16LE());
+setParserName(uint16LEParser, 'uint16LEParser');
+const uint32LEParser = promiseCompose(createFixedLengthSequenceParser(4), array => Buffer.from(array).readUInt32LE());
+setParserName(uint32LEParser, 'uint32LEParser');
+const dosDateTimeParser = promiseCompose(createTupleParser([
+    uint16LEParser,
+    uint16LEParser,
+]), ([time, date]) => new Date(Date.UTC(1980 + ((date >> 9) & 0x7f), ((date >> 5) & 0xf) - 1, date & 0x1f, (time >> 11) & 0x1f, (time >> 5) & 0x3f, (time & 0x1f) * 2)));
+const zipCompressionMethodParser = promiseCompose(uint16LEParser, compressionMethod => {
+    if (compressionMethod === 0) {
+        return 'store';
+    }
+    if (compressionMethod === 8) {
+        return 'deflate';
+    }
+    invariant(false, 'Unsupported compression method %s', compressionMethod);
+});
+const zipLocalFileHeaderParser_ = createTupleParser([
+    createExactSequenceParser(Buffer.from('504b0304', 'hex')),
+    uint16LEParser,
+    uint16LEParser,
+    zipCompressionMethodParser,
+    dosDateTimeParser,
+    uint32LEParser,
+    uint32LEParser,
+    uint32LEParser,
+    parserCreatorCompose(() => createTupleParser([
+        uint16LEParser,
+        uint16LEParser,
+    ]), ([fileNameLength, extraFieldLength,]) => createTupleParser([
+        createFixedLengthSequenceParser(fileNameLength),
+        createFixedLengthSequenceParser(extraFieldLength),
+    ]))(),
+]);
+setParserName(zipLocalFileHeaderParser_, 'zipLocalFileHeaderParser_');
+const zipLocalFileHeaderParser = promiseCompose(zipLocalFileHeaderParser_, ([_zipLocalFileHeaderSignature, versionNeededToExtract, generalPurposeBitFlag, compressionMethod, lastModFile, crc32, compressedSize, uncompressedSize, [fileName, extraField],]) => ({
+    versionNeededToExtract,
+    generalPurposeBitFlag,
+    compressionMethod,
+    lastModFile,
+    crc32,
+    compressedSize,
+    uncompressedSize,
+    fileName: Buffer.from(fileName).toString('utf8'),
+    extraField,
+}));
+const zipEncryptionHeaderParser = async (parserContext) => {
+    parserContext.invariant(false, 'Not implemented');
+};
+const zipDataDescriptorParser = createTupleParser([
+    // FIXME: optional in spec
+    // createOptionalParser(createExactSequenceParser<Uint8Array>(Buffer.from('504b0708', 'hex'))),
+    createExactSequenceParser(Buffer.from('504b0708', 'hex')),
+    uint32LEParser,
+    uint32LEParser,
+    uint32LEParser,
+]);
+export const zipLocalFileParser = promiseCompose(parserCreatorCompose(() => zipLocalFileHeaderParser, (zipLocalFileHeader) => createTupleParser([
+    async () => zipLocalFileHeader,
+    createOptionalParser(zipEncryptionHeaderParser),
+    createFixedLengthSequenceParser(zipLocalFileHeader.compressedSize),
+    createOptionalParser(zipDataDescriptorParser),
+]))(), ([zipLocalFileHeader, zipEncryptionHeader, compressedData, zipDataDescriptor,]) => ({
+    zipLocalFileHeader,
+    zipEncryptionHeader,
+    compressedData,
+    zipDataDescriptor,
+}));
+setParserName(zipLocalFileParser, 'zipEntryParser');
+export const zipArchiveDecryptionHeaderParser = async (parserContext) => {
+    parserContext.invariant(false, 'Not implemented %s', await parserContext.peek(0));
+};
+export const zipArchiveExtraDataRecordParser = async (parserContext) => {
+    parserContext.invariant(false, 'Not implemented');
+};
+const zipVersionMadeByParser = promiseCompose(createFixedLengthSequenceParser(2), async ([zipSpecificationVersion, hostSystem,]) => ({
+    hostSystem,
+    zipSpecificationVersion,
+}));
+const zipCentralDirectoryHeaderParser_ = createTupleParser([
+    createExactSequenceParser(Buffer.from('504b0102', 'hex')),
+    zipVersionMadeByParser,
+    uint16LEParser,
+    uint16LEParser,
+    zipCompressionMethodParser,
+    dosDateTimeParser,
+    uint32LEParser,
+    uint32LEParser,
+    uint32LEParser,
+    parserCreatorCompose(() => createTupleParser([
+        uint16LEParser,
+        uint16LEParser,
+        uint16LEParser,
+        uint16LEParser,
+        uint16LEParser,
+        uint32LEParser,
+        uint32LEParser,
+    ]), ([fileNameLength, extraFieldLength, fileCommentLength, diskNumberStart, internalFileAttributes, externalFileAttributes, relativeOffsetOfLocalHeader,]) => createTupleParser([
+        createFixedLengthSequenceParser(fileNameLength),
+        createFixedLengthSequenceParser(extraFieldLength),
+        createFixedLengthSequenceParser(fileCommentLength),
+        async () => diskNumberStart,
+        async () => internalFileAttributes,
+        async () => externalFileAttributes,
+        async () => relativeOffsetOfLocalHeader,
+    ]))(),
+]);
+setParserName(zipCentralDirectoryHeaderParser_, 'centralDirectoryHeaderParser_');
+export const zipCentralDirectoryHeaderParser = promiseCompose(zipCentralDirectoryHeaderParser_, ([_centralDirectoryHeaderSignature, versionMadeBy, versionNeededToExtract, generalPurposeBitFlag, compressionMethod, lastModFile, crc32, compressedSize, uncompressedSize, [fileName, extraField, fileComment, diskNumberStart, internalFileAttributes, externalFileAttributes, relativeOffsetOfLocalHeader,],]) => ({
+    versionMadeBy,
+    versionNeededToExtract,
+    generalPurposeBitFlag,
+    compressionMethod,
+    lastModFile,
+    crc32,
+    compressedSize,
+    uncompressedSize,
+    diskNumberStart,
+    internalFileAttributes,
+    externalFileAttributes,
+    relativeOffsetOfLocalHeader,
+    fileName: Buffer.from(fileName).toString('utf8'),
+    extraField,
+    fileComment: Buffer.from(fileComment).toString('utf8'),
+}));
+export const zip64EndOfCentralDirectoryRecordParser = async (parserContext) => {
+    parserContext.invariant(false, 'Not implemented');
+};
+export const zip64EndOfCentralDirectoryLocatorParser = async (parserContext) => {
+    parserContext.invariant(false, 'Not implemented');
+};
+const zipFileCommentParser = promiseCompose(parserCreatorCompose(() => uint16LEParser, length => createFixedLengthSequenceParser(length))(), uint8Array => Buffer.from(uint8Array).toString('utf8'));
+const zipEndOfCentralDirectoryRecordParser_ = createTupleParser([
+    createExactSequenceParser(Buffer.from('504b0506', 'hex')),
+    uint16LEParser,
+    uint16LEParser,
+    uint16LEParser,
+    uint16LEParser,
+    uint32LEParser,
+    uint32LEParser,
+    zipFileCommentParser,
+]);
+setParserName(zipEndOfCentralDirectoryRecordParser_, 'endOfCentralDirectoryRecordParser_');
+export const zipEndOfCentralDirectoryRecordParser = promiseCompose(zipEndOfCentralDirectoryRecordParser_, ([_endOfCentralDirectoryRecordSignature, numberOfThisDisk, numberOfTheDiskWithTheStartOfTheCentralDirectory, totalNumberOfEntriesInTheCentralDirectoryOnThisDisk, totalNumberOfEntriesInTheCentralDirectory, sizeOfTheCentralDirectory, offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber, zipFileComment,]) => ({
+    numberOfThisDisk,
+    numberOfTheDiskWithTheStartOfTheCentralDirectory,
+    totalNumberOfEntriesInTheCentralDirectoryOnThisDisk,
+    totalNumberOfEntriesInTheCentralDirectory,
+    sizeOfTheCentralDirectory,
+    offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber,
+    zipFileComment,
+}));
+const zipParser_ = createTupleParser([
+    createArrayParser(zipLocalFileParser),
+    createOptionalParser(zipArchiveDecryptionHeaderParser),
+    createOptionalParser(zipArchiveExtraDataRecordParser),
+    createArrayParser(zipCentralDirectoryHeaderParser),
+    createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
+    createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
+    zipEndOfCentralDirectoryRecordParser,
+]);
+setParserName(zipParser_, 'zipParser_');
+export async function zipEntriesFromZipSegments({ zipLocalFiles, zipCentralDirectoryHeaders, }) {
+    const decompressPromises = [];
+    const entries = await Promise.all(zipLocalFiles.map(async (zipLocalFile, index) => {
+        const { zipLocalFileHeader, compressedData, zipDataDescriptor, zipEncryptionHeader, } = zipLocalFile;
+        const centralDirectoryHeader = zipCentralDirectoryHeaders.at(index);
+        invariant(centralDirectoryHeader, 'Central directory header not found for local file %s', index);
+        let isDosDirectory = false;
+        let permissions = {
+            type: 'unix',
+            unixPermissions: 0,
+        };
+        if (centralDirectoryHeader.versionMadeBy.hostSystem === 0) {
+            isDosDirectory = (centralDirectoryHeader.externalFileAttributes & 0b00010000) !== 0;
+            permissions = {
+                type: 'dos',
+                dosPermissions: centralDirectoryHeader.externalFileAttributes & 0b00111111,
+            };
+        }
+        if (centralDirectoryHeader.versionMadeBy.hostSystem === 3) {
+            permissions = {
+                type: 'unix',
+                unixPermissions: (centralDirectoryHeader.externalFileAttributes >> 16) & 0b111111111,
+            };
+        }
+        const commonFields = {
+            path: zipLocalFileHeader.fileName,
+            comment: centralDirectoryHeader.fileComment,
+            date: zipLocalFileHeader.lastModFile,
+            permissions,
+        };
+        const isDirectory = isDosDirectory || commonFields.path.endsWith('/');
+        if (isDirectory) {
+            return {
+                ...commonFields,
+                type: 'directory',
+                path: commonFields.path.slice(0, -1),
+            };
+        }
+        const fileEntry = {
+            ...commonFields,
+            type: 'file',
+            content: compressedData,
+            compression: zipLocalFileHeader.compressionMethod,
+        };
+        if (fileEntry.content.length && fileEntry.compression === 'deflate') {
+            const deflate = zlib.createInflateRaw();
+            const input = Readable.from(Buffer.from(compressedData));
+            const [_, buffer] = await Promise.all([
+                pipeline(input, deflate),
+                (async () => {
+                    const chunks = [];
+                    for await (const chunk of deflate) {
+                        chunks.push(chunk);
+                    }
+                    return Buffer.concat(chunks);
+                })(),
+            ]);
+            fileEntry.content = Uint8Array.from(buffer);
+        }
+        return fileEntry;
+    }));
+    await Promise.all(decompressPromises);
+    return entries;
+}
+export async function zipFromZipSegments({ zipLocalFiles, zipCentralDirectoryHeaders, zipEndOfCentralDirectoryRecord, }) {
+    const entries = await zipEntriesFromZipSegments({
+        zipLocalFiles,
+        zipCentralDirectoryHeaders,
+    });
+    return {
+        comment: zipEndOfCentralDirectoryRecord.zipFileComment,
+        entries,
+    };
+}
+export const zipParser = promiseCompose(zipParser_, async ([zipLocalFiles, zipArchiveDecryptionHeader, zipArchiveExtraDataRecords, zipCentralDirectoryHeaders, zip64EndOfCentralDirectoryRecord, zip64EndOfCentralDirectoryLocator, zipEndOfCentralDirectoryRecord,]) => zipFromZipSegments({
+    zipLocalFiles,
+    zipCentralDirectoryHeaders,
+    zipEndOfCentralDirectoryRecord,
+}));
+setParserName(zipParser, 'zipParser');

package/build/zipParser.test.d.ts

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

package/build/zipParser.test.js

@@ -0,0 +1,22 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryZipStream } from './arbitraryZipStream.js';
+import { zipParser } from './zipParser.js';
+import { uint8ArrayInputCompanion } from './inputCompanion.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, {
+        errorJoinMode: 'all',
+    });
+    actual.entries.sort((a, b) => a.path.localeCompare(b.path));
+    zip.entries.sort((a, b) => a.path.localeCompare(b.path));
+    t.deepEqual(actual, zip);
+}, {
+    verbose: true,
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@futpib/parser",
+  "version": "1.0.0",
+  "main": "build/index.js",
+  "license": "GPL-3.0-only",
+  "type": "module",
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc",
+    "test": "xo && c8 ava",
+    "prepack": "yarn build"
+  },
+  "homepage": "https://github.com/futpib/parser",
+  "ava": {
+    "typescript": {
+      "rewritePaths": {
+        "src/": "build/"
+      },
+      "compile": false
+    },
+    "verbose": true
+  },
+  "devDependencies": {
+    "@ava/typescript": "^5.0.0",
+    "@fast-check/ava": "^2.0.1",
+    "@types/invariant": "^2.2.37",
+    "@types/node": "^22.10.1",
+    "ava": "^6.2.0",
+    "bson": "^6.10.0",
+    "c8": "^10.1.2",
+    "coveralls": "^3.1.1",
+    "eslint-config-xo-typescript-overrides": "^1.6.1",
+    "fast-check": "^3.23.1",
+    "invariant": "^2.2.4",
+    "jszip": "^3.10.1",
+    "type-fest": "^4.29.0",
+    "typescript": "^5.7.2",
+    "xo": "^0.59.3"
+  },
+  "xo": {
+    "extends": [
+      "eslint-config-xo-typescript-overrides"
+    ],
+    "rules": {
+      "ava/no-ignored-test-files": "off"
+    }
+  },
+  "packageManager": "yarn@4.5.3",
+  "dependencies": {
+    "p-mutex": "^0.1.0"
+  }
+}

package/readme.md

@@ -0,0 +1,17 @@
+# parser
+
+> parser
+
+[![Coverage Status](https://coveralls.io/repos/github/futpib/parser/badge.svg?branch=master)](https://coveralls.io/github/futpib/parser?branch=master)
+
+## Example
+
+```js
+// parser
+```
+
+## Install
+
+```
+yarn add --dev @futpib/parser
+```

package/renovate.json

@@ -0,0 +1,6 @@
+{
+  "extends": [
+    "config:recommended"
+  ],
+  "rangeStrategy": "replace"
+}

package/src/allSettledStream.test.ts

@@ -0,0 +1,59 @@
+import test from 'ava';
+import { allSettledStream } from './allSettledStream.js';
+
+test('allSettledStream', async t => {
+	const stream = allSettledStream<number, number | string>([
+		{
+			delay: 10,
+			context: 1,
+		},
+		{
+			delay: 10,
+			context: 'a',
+		},
+		{
+			delay: 20,
+			context: 2,
+		},
+		{
+			delay: 20,
+			context: 'b',
+		},
+		{
+			delay: 0,
+			context: 3,
+		},
+		{
+			delay: 0,
+			context: 'c',
+		},
+		{
+			delay: 40,
+			context: 4,
+		},
+		{
+			delay: 40,
+			context: 'd',
+		},
+	].map(({ delay, context }) => ({
+		promise: new Promise<number>((resolve, reject) => {
+			setTimeout(() => {
+				if (typeof context === 'number') {
+					resolve(context);
+				} else {
+					reject(context);
+				}
+			}, delay);
+		}),
+		context,
+	})));
+
+	const results: any[] = [];
+
+	for await (const value of stream) {
+		results.push(value);
+	}
+
+	t.snapshot(results);
+	t.is(results.length, 8);
+});

package/src/allSettledStream.test.ts.md

@@ -0,0 +1,52 @@
+# Snapshot report for `src/allSettledStream.test.ts`
+
+The actual snapshot is saved in `allSettledStream.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## allSettledStream
+
+> Snapshot 1
+
+    [
+      {
+        context: 3,
+        status: 'fulfilled',
+        value: 3,
+      },
+      {
+        context: 'c',
+        reason: 'c',
+        status: 'rejected',
+      },
+      {
+        context: 1,
+        status: 'fulfilled',
+        value: 1,
+      },
+      {
+        context: 'a',
+        reason: 'a',
+        status: 'rejected',
+      },
+      {
+        context: 2,
+        status: 'fulfilled',
+        value: 2,
+      },
+      {
+        context: 'b',
+        reason: 'b',
+        status: 'rejected',
+      },
+      {
+        context: 4,
+        status: 'fulfilled',
+        value: 4,
+      },
+      {
+        context: 'd',
+        reason: 'd',
+        status: 'rejected',
+      },
+    ]

package/src/allSettledStream.ts

@@ -0,0 +1,44 @@
+type AllSettledStreamFulfilledResult<T, Context> = {
+	status: 'fulfilled';
+	value: T;
+	context: Context;
+};
+
+type AllSettledStreamRejectedResult<T, Context> = {
+	status: 'rejected';
+	reason: unknown;
+	context: Context;
+};
+
+type AllSettedStreamResult<T, Context> = AllSettledStreamFulfilledResult<T, Context> | AllSettledStreamRejectedResult<T, Context>;
+
+type AllSettledStreamTask<T, Context> = {
+	promise: Promise<T>;
+	context: Context;
+};
+
+export function allSettledStream<T, Context>(tasks: Array<AllSettledStreamTask<T, Context>>): ReadableStream<AllSettedStreamResult<T, Context>> {
+	return new ReadableStream({
+		async start(controller) {
+			let settledCount = 0;
+			for (const { promise, context } of tasks) {
+				(async () => {
+					const [ promiseSettledResult ] = await Promise.allSettled([ promise ]);
+
+					settledCount++;
+
+					const allSettedStreamResult: AllSettedStreamResult<T, Context> = {
+						...promiseSettledResult,
+						context,
+					};
+
+					controller.enqueue(allSettedStreamResult);
+
+					if (settledCount === tasks.length) {
+						controller.close();
+					}
+				})();
+			}
+		},
+	});
+}

package/src/apk.ts

@@ -0,0 +1,16 @@
+import { Zip } from './zip.js';
+
+export type ApkSigningBlockPair = {
+	id: number;
+	value: Uint8Array;
+};
+
+export type ApkSigningBlock = {
+	zeroPaddingLength?: number;
+	signatureV2?: unknown;
+	pairs: ApkSigningBlockPair[];
+};
+
+export type Apk = Zip & {
+	signingBlock?: ApkSigningBlock;
+};

package/src/apkParser.test.ts

@@ -0,0 +1,30 @@
+import test from 'ava';
+import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { runParser } from './parser.js';
+import { apkParser } from './apkParser.js';
+
+for (const apkCid 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, uint8ArrayInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			for (const entry of actual.entries) {
+				if (entry.type === 'file') {
+					entry.content = new Uint8Array([ entry.content.length ]);
+				}
+			}
+
+			t.snapshot(actual);
+		},
+	);
+}