@futpib/parser 1.0.0 → 1.0.2

package/build/zipParser.js

@@ -1,15 +1,18 @@
-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";
+import zlib from 'node:zlib';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import invariant from 'invariant';
+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 { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createSequenceTerminatedSequenceParser } from './sequenceTerminatedSequenceParser.js';
 // https://pkwaredownloads.blob.core.windows.net/pem/APPNOTE.txt
 const uint16LEParser = promiseCompose(createFixedLengthSequenceParser(2), array => Buffer.from(array).readUInt16LE());
 setParserName(uint16LEParser, 'uint16LEParser');
@@ -18,7 +21,7 @@ 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)));
+]), ([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';
@@ -28,8 +31,9 @@ const zipCompressionMethodParser = promiseCompose(uint16LEParser, compressionMet
     }
     invariant(false, 'Unsupported compression method %s', compressionMethod);
 });
+const zipLocalFileHeaderSignatureParser = createExactSequenceParser(Buffer.from('504b0304', 'hex'));
 const zipLocalFileHeaderParser_ = createTupleParser([
-    createExactSequenceParser(Buffer.from('504b0304', 'hex')),
+    zipLocalFileHeaderSignatureParser,
     uint16LEParser,
     uint16LEParser,
     zipCompressionMethodParser,
@@ -40,40 +44,60 @@ const zipLocalFileHeaderParser_ = createTupleParser([
     parserCreatorCompose(() => createTupleParser([
         uint16LEParser,
         uint16LEParser,
-    ]), ([fileNameLength, extraFieldLength,]) => createTupleParser([
-        createFixedLengthSequenceParser(fileNameLength),
+    ]), ([filePathLength, extraFieldLength,]) => createTupleParser([
+        createFixedLengthSequenceParser(filePathLength),
         createFixedLengthSequenceParser(extraFieldLength),
     ]))(),
 ]);
 setParserName(zipLocalFileHeaderParser_, 'zipLocalFileHeaderParser_');
-const zipLocalFileHeaderParser = promiseCompose(zipLocalFileHeaderParser_, ([_zipLocalFileHeaderSignature, versionNeededToExtract, generalPurposeBitFlag, compressionMethod, lastModFile, crc32, compressedSize, uncompressedSize, [fileName, extraField],]) => ({
+const zipLocalFileHeaderParser = promiseCompose(zipLocalFileHeaderParser_, ([_zipLocalFileHeaderSignature, versionNeededToExtract, generalPurposeBitFlag, compressionMethod, lastModifiedFile, crc32, compressedSize, uncompressedSize, [filePath, extraField],]) => ({
     versionNeededToExtract,
     generalPurposeBitFlag,
     compressionMethod,
-    lastModFile,
+    lastModifiedFile,
     crc32,
     compressedSize,
     uncompressedSize,
-    fileName: Buffer.from(fileName).toString('utf8'),
+    filePath: Buffer.from(filePath).toString('utf8'),
     extraField,
 }));
 const zipEncryptionHeaderParser = async (parserContext) => {
     parserContext.invariant(false, 'Not implemented');
 };
-const zipDataDescriptorParser = createTupleParser([
+const zipDataDescriptorSignature = Buffer.from('504b0708', 'hex');
+const zipDataDescriptorSignatureParser = createExactSequenceParser(zipDataDescriptorSignature);
+const zipDataDescriptorParser = promiseCompose(createTupleParser([
+    createNegativeLookaheadParser(zipLocalFileHeaderSignatureParser),
     // FIXME: optional in spec
-    // createOptionalParser(createExactSequenceParser<Uint8Array>(Buffer.from('504b0708', 'hex'))),
-    createExactSequenceParser(Buffer.from('504b0708', 'hex')),
+    //createOptionalParser(zipDataDescriptorSignatureParser),
+    zipDataDescriptorSignatureParser,
     uint32LEParser,
     uint32LEParser,
     uint32LEParser,
-]);
-export const zipLocalFileParser = promiseCompose(parserCreatorCompose(() => zipLocalFileHeaderParser, (zipLocalFileHeader) => createTupleParser([
-    async () => zipLocalFileHeader,
-    createOptionalParser(zipEncryptionHeaderParser),
-    createFixedLengthSequenceParser(zipLocalFileHeader.compressedSize),
-    createOptionalParser(zipDataDescriptorParser),
-]))(), ([zipLocalFileHeader, zipEncryptionHeader, compressedData, zipDataDescriptor,]) => ({
+]), ([_notZipLocalFileHeaderSignature, _zipDataDescriptorSignature, crc32, compressedSize, uncompressedSize,]) => ({
+    crc32,
+    compressedSize,
+    uncompressedSize,
+}));
+setParserName(zipDataDescriptorParser, 'zipDataDescriptorParser');
+export const zipLocalFileParser = promiseCompose(parserCreatorCompose(() => zipLocalFileHeaderParser, zipLocalFileHeader => {
+    const sizeInDataDescriptor = Boolean(zipLocalFileHeader.generalPurposeBitFlag & 0b0000_0000_0000_1000
+        && zipLocalFileHeader.crc32 === 0
+        && zipLocalFileHeader.compressedSize === 0
+        && zipLocalFileHeader.uncompressedSize === 0);
+    return createTupleParser([
+        async () => zipLocalFileHeader,
+        createOptionalParser(zipEncryptionHeaderParser),
+        (sizeInDataDescriptor
+            ? createSequenceTerminatedSequenceParser(zipDataDescriptorSignature, {
+                consumeTerminator: false,
+            })
+            : createFixedLengthSequenceParser(zipLocalFileHeader.compressedSize)),
+        (sizeInDataDescriptor
+            ? ((parser) => parser)
+            : createOptionalParser)(zipDataDescriptorParser),
+    ]);
+})(), ([zipLocalFileHeader, zipEncryptionHeader, compressedData, zipDataDescriptor,]) => ({
     zipLocalFileHeader,
     zipEncryptionHeader,
     compressedData,
@@ -90,9 +114,18 @@ const zipVersionMadeByParser = promiseCompose(createFixedLengthSequenceParser(2)
     hostSystem,
     zipSpecificationVersion,
 }));
-const zipCentralDirectoryHeaderParser_ = createTupleParser([
+const dosExternalFileAttributesParser = promiseCompose(uint32LEParser, externalFileAttributes => ({
+    directory: (externalFileAttributes & 0b0001_0000) !== 0,
+}));
+const unixExternalFileAttributesParser = promiseCompose(uint32LEParser, externalFileAttributes => ({
+    directory: (externalFileAttributes & (0b0100_0000_0000_0000 << 16)) !== 0,
+}));
+const createExternalFileAttributesParser = (hostSystem) => promiseCompose(hostSystem === 0 ? dosExternalFileAttributesParser : unixExternalFileAttributesParser, externalFileAttributes => externalFileAttributes);
+const zipCentralDirectoryHeaderParser_ = parserCreatorCompose(() => createTupleParser([
     createExactSequenceParser(Buffer.from('504b0102', 'hex')),
     zipVersionMadeByParser,
+]), ([_centralDirectoryHeaderSignature, versionMadeBy,]) => createTupleParser([
+    async () => versionMadeBy,
     uint16LEParser,
     uint16LEParser,
     zipCompressionMethodParser,
@@ -106,10 +139,10 @@ const zipCentralDirectoryHeaderParser_ = createTupleParser([
         uint16LEParser,
         uint16LEParser,
         uint16LEParser,
+        createExternalFileAttributesParser(versionMadeBy.hostSystem),
         uint32LEParser,
-        uint32LEParser,
-    ]), ([fileNameLength, extraFieldLength, fileCommentLength, diskNumberStart, internalFileAttributes, externalFileAttributes, relativeOffsetOfLocalHeader,]) => createTupleParser([
-        createFixedLengthSequenceParser(fileNameLength),
+    ]), ([filePathLength, extraFieldLength, fileCommentLength, diskNumberStart, internalFileAttributes, externalFileAttributes, relativeOffsetOfLocalHeader,]) => createTupleParser([
+        createFixedLengthSequenceParser(filePathLength),
         createFixedLengthSequenceParser(extraFieldLength),
         createFixedLengthSequenceParser(fileCommentLength),
         async () => diskNumberStart,
@@ -117,14 +150,14 @@ const zipCentralDirectoryHeaderParser_ = createTupleParser([
         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,],]) => ({
+export const zipCentralDirectoryHeaderParser = promiseCompose(zipCentralDirectoryHeaderParser_, ([versionMadeBy, versionNeededToExtract, generalPurposeBitFlag, compressionMethod, lastModifiedFile, crc32, compressedSize, uncompressedSize, [filePath, extraField, fileComment, diskNumberStart, internalFileAttributes, externalFileAttributes, relativeOffsetOfLocalHeader,],]) => ({
     versionMadeBy,
     versionNeededToExtract,
     generalPurposeBitFlag,
     compressionMethod,
-    lastModFile,
+    lastModifiedFile,
     crc32,
     compressedSize,
     uncompressedSize,
@@ -132,7 +165,7 @@ export const zipCentralDirectoryHeaderParser = promiseCompose(zipCentralDirector
     internalFileAttributes,
     externalFileAttributes,
     relativeOffsetOfLocalHeader,
-    fileName: Buffer.from(fileName).toString('utf8'),
+    filePath: Buffer.from(filePath).toString('utf8'),
     extraField,
     fileComment: Buffer.from(fileComment).toString('utf8'),
 }));
@@ -153,7 +186,7 @@ const zipEndOfCentralDirectoryRecordParser_ = createTupleParser([
     uint32LEParser,
     zipFileCommentParser,
 ]);
-setParserName(zipEndOfCentralDirectoryRecordParser_, 'endOfCentralDirectoryRecordParser_');
+setParserName(zipEndOfCentralDirectoryRecordParser_, 'zipEndOfCentralDirectoryRecordParser_');
 export const zipEndOfCentralDirectoryRecordParser = promiseCompose(zipEndOfCentralDirectoryRecordParser_, ([_endOfCentralDirectoryRecordSignature, numberOfThisDisk, numberOfTheDiskWithTheStartOfTheCentralDirectory, totalNumberOfEntriesInTheCentralDirectoryOnThisDisk, totalNumberOfEntriesInTheCentralDirectory, sizeOfTheCentralDirectory, offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber, zipFileComment,]) => ({
     numberOfThisDisk,
     numberOfTheDiskWithTheStartOfTheCentralDirectory,
@@ -163,6 +196,7 @@ export const zipEndOfCentralDirectoryRecordParser = promiseCompose(zipEndOfCentr
     offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber,
     zipFileComment,
 }));
+setParserName(zipEndOfCentralDirectoryRecordParser, 'zipEndOfCentralDirectoryRecordParser');
 const zipParser_ = createTupleParser([
     createArrayParser(zipLocalFileParser),
     createOptionalParser(zipArchiveDecryptionHeaderParser),
@@ -179,36 +213,20 @@ export async function zipEntriesFromZipSegments({ zipLocalFiles, zipCentralDirec
         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,
+            path: zipLocalFileHeader.filePath,
             comment: centralDirectoryHeader.fileComment,
-            date: zipLocalFileHeader.lastModFile,
-            permissions,
+            date: zipLocalFileHeader.lastModifiedFile,
+            hostSystem: centralDirectoryHeader.versionMadeBy.hostSystem === 0 ? 'dos' : 'unix',
+            attributes: centralDirectoryHeader.externalFileAttributes,
         };
-        const isDirectory = isDosDirectory || commonFields.path.endsWith('/');
+        const isDirectory = (centralDirectoryHeader.externalFileAttributes.directory
+            || commonFields.path.endsWith('/'));
         if (isDirectory) {
             return {
                 ...commonFields,
                 type: 'directory',
-                path: commonFields.path.slice(0, -1),
+                path: commonFields.path.replace(/\/$/, ''),
             };
         }
         const fileEntry = {
@@ -217,18 +235,12 @@ export async function zipEntriesFromZipSegments({ zipLocalFiles, zipCentralDirec
             content: compressedData,
             compression: zipLocalFileHeader.compressionMethod,
         };
-        if (fileEntry.content.length && fileEntry.compression === 'deflate') {
-            const deflate = zlib.createInflateRaw();
+        if (fileEntry.content.length > 0 && fileEntry.compression === 'deflate') {
+            const inflate = 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);
-                })(),
+                pipeline(input, inflate),
+                uint8ArrayAsyncIterableToUint8Array(inflate),
             ]);
             fileEntry.content = Uint8Array.from(buffer);
         }

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,8 @@
+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 createZipUnparser: ({ dataDescriptor, }?: {
+    dataDescriptor?: boolean;
+}) => Unparser<Zip, Uint8Array>;
+export declare const zipUnparser: Unparser<Zip, Uint8Array<ArrayBufferLike>>;

package/build/zipUnparser.js

@@ -0,0 +1,200 @@
+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);
+};
+const zipDataDescriptorUnparser = async function* ({ crc32, compressedSize, uncompressedSize, }, unparserContext) {
+    yield Buffer.from('504b0708', 'hex');
+    yield* uint32LEUnparser(crc32, unparserContext);
+    yield* uint32LEUnparser(compressedSize, unparserContext);
+    yield* uint32LEUnparser(uncompressedSize, unparserContext);
+};
+const zipLocalFileHeaderUnparser = async function* ({ versionNeededToExtract, generalPurposeBitFlag, compressionMethod, lastModifiedFile, crc32, compressedSize, uncompressedSize, filePath, extraField, }, unparserContext) {
+    yield Buffer.from('504b0304', 'hex');
+    yield* uint16LEUnparser(versionNeededToExtract, unparserContext);
+    yield* uint16LEUnparser(generalPurposeBitFlag, unparserContext);
+    yield* zipCompressionMethodUnparser(compressionMethod, unparserContext);
+    yield* dosDateTimeUnparser(lastModifiedFile, unparserContext);
+    yield* uint32LEUnparser(crc32, unparserContext);
+    yield* uint32LEUnparser(compressedSize, unparserContext);
+    yield* uint32LEUnparser(uncompressedSize, unparserContext);
+    const filePathBuffer = Buffer.from(filePath, 'utf8');
+    yield* uint16LEUnparser(filePathBuffer.length, unparserContext);
+    yield* uint16LEUnparser(extraField.length, unparserContext);
+    yield filePathBuffer;
+    yield extraField;
+};
+export const createZipUnparser = ({ dataDescriptor = false, } = {}) => 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);
+        const filePath = filePathByZipEntry.get(zipEntry);
+        const zipLocalFileHeader = {
+            versionNeededToExtract: 20,
+            generalPurposeBitFlag: 0,
+            compressionMethod: 'store',
+            lastModifiedFile: zipEntry.date,
+            crc32: 0,
+            compressedSize: 0,
+            uncompressedSize: 0,
+            filePath,
+            extraField: Buffer.alloc(0),
+        };
+        let shouldWriteDataDescriptor = false;
+        if (zipEntry.type === 'file') {
+            const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
+            zipLocalFileHeader.compressionMethod = zipEntry.compression;
+            zipLocalFileHeader.crc32 = 0; // TODO
+            zipLocalFileHeader.compressedSize = compressedContent.length;
+            zipLocalFileHeader.uncompressedSize = zipEntry.content.length;
+            if (dataDescriptor) {
+                shouldWriteDataDescriptor = true;
+                zipLocalFileHeader.generalPurposeBitFlag |= 0b0000_0000_0000_1000;
+                zipLocalFileHeader.crc32 = 0;
+                zipLocalFileHeader.compressedSize = 0;
+                zipLocalFileHeader.uncompressedSize = 0;
+            }
+        }
+        yield* zipLocalFileHeaderUnparser(zipLocalFileHeader, unparserContext);
+        if (zipEntry.type === 'file') {
+            const compressedContent = await compressedContentByZipFileEntry.get(zipEntry);
+            yield compressedContent;
+            if (shouldWriteDataDescriptor) {
+                yield* zipDataDescriptorUnparser({
+                    crc32: zipLocalFileHeader.crc32,
+                    compressedSize: zipLocalFileHeader.compressedSize,
+                    uncompressedSize: zipLocalFileHeader.uncompressedSize,
+                }, unparserContext);
+            }
+        }
+    }
+    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);
+};
+export const zipUnparser = createZipUnparser();

package/build/zipUnparser.test.d.ts

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

package/build/zipUnparser.test.js

@@ -0,0 +1,80 @@
+import { fc, 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 { createZipUnparser } 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';
+import { hasExecutable } from './hasExecutable.js';
+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,
+    fc.record({
+        dataDescriptor: fc.boolean(),
+    }),
+], async (t, zip, options) => {
+    const zipUnparser = createZipUnparser(options);
+    {
+        const zipStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
+        await fsPromises.writeFile('/tmp/zip.zip', zipStream);
+    }
+    const actualStream = runUnparser(zipUnparser, zip, uint8ArrayUnparserOutputCompanion);
+    const actual = await runParser(zipParser, actualStream, uint8ArrayParserInputCompanion);
+    t.deepEqual(actual, zip);
+    const hasZipinfo = await hasZipinfoPromise;
+    const has7z = await has7zPromise;
+    if (!hasZipinfo && !has7z) {
+        t.pass('no zipinfo or 7z, skipping zipfile check');
+        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.2",
   "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",
@@ -24,18 +24,24 @@
     "@ava/typescript": "^5.0.0",
     "@fast-check/ava": "^2.0.1",
     "@types/invariant": "^2.2.37",
-    "@types/node": "^22.10.1",
+    "@types/node": "^22.10.2",
     "ava": "^6.2.0",
-    "bson": "^6.10.0",
-    "c8": "^10.1.2",
+    "bson": "^6.10.1",
+    "c8": "^10.1.3",
     "coveralls": "^3.1.1",
+    "env-paths": "^3.0.0",
     "eslint-config-xo-typescript-overrides": "^1.6.1",
-    "fast-check": "^3.23.1",
+    "execa": "^9.5.2",
+    "fast-check": "^3.23.2",
     "invariant": "^2.2.4",
     "jszip": "^3.10.1",
-    "type-fest": "^4.29.0",
+    "leb128": "^0.0.5",
+    "mutf-8": "^1.1.4",
+    "p-memoize": "^7.1.1",
+    "tempy": "^3.1.0",
+    "type-fest": "^4.30.1",
     "typescript": "^5.7.2",
-    "xo": "^0.59.3"
+    "xo": "^0.60.0"
   },
   "xo": {
     "extends": [
@@ -47,6 +53,18 @@
   },
   "packageManager": "yarn@4.5.3",
   "dependencies": {
+    "fp-ts": "^2.16.9",
+    "mem": "^10.0.0",
+    "monocle-ts": "^2.3.13",
+    "newtype-ts": "^0.3.5",
     "p-mutex": "^0.1.0"
+  },
+  "peerDependencies": {
+    "mutf-8": "^1.1.4"
+  },
+  "peerDependenciesMeta": {
+    "mutf-8": {
+      "optional": true
+    }
   }
 }