@futpib/parser 1.0.0 → 1.0.1

package/build/unparser.test.js

@@ -0,0 +1,150 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { runUnparser } from './unparser.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+import { testProp } from '@fast-check/ava';
+test('writeLater', async (t) => {
+    const stringToBeWrittenBefore = 'before writeLater\n';
+    const stringToBeWrittenLater = 'written later\n';
+    const stringToBeWrittenAfter = 'after writeLater\n';
+    let expectedPositionA;
+    let expectedPositionB;
+    let actualPositionAFromWithinWriteLater;
+    let actualPositionBFromWithinWriteLater;
+    const unparser = async function* (_input, unparserContext) {
+        yield stringToBeWrittenBefore;
+        expectedPositionA = unparserContext.position;
+        const writeLater = yield* unparserContext.writeLater(stringToBeWrittenLater.length);
+        expectedPositionB = unparserContext.position;
+        yield stringToBeWrittenAfter;
+        yield* unparserContext.writeEarlier(writeLater, async function* (_input, unparserContext) {
+            actualPositionAFromWithinWriteLater = unparserContext.position;
+            yield stringToBeWrittenLater;
+            actualPositionBFromWithinWriteLater = unparserContext.position;
+        }, undefined);
+    };
+    const stringsAsyncIterable = runUnparser(unparser, undefined, stringUnparserOutputCompanion);
+    const strings = [];
+    for await (const string of stringsAsyncIterable) {
+        strings.push(string);
+    }
+    const string = strings.join('');
+    t.is(string, stringToBeWrittenBefore + stringToBeWrittenLater + stringToBeWrittenAfter);
+    t.is(actualPositionAFromWithinWriteLater, expectedPositionA, 'position a');
+    t.is(actualPositionBFromWithinWriteLater, expectedPositionB, 'position b');
+    t.is(expectedPositionA, stringToBeWrittenBefore.length);
+    t.is(expectedPositionB, stringToBeWrittenBefore.length + stringToBeWrittenLater.length);
+});
+test('writeLater one deep', async (t) => {
+    const unparser = async function* (_input, unparserContext) {
+        yield '(';
+        const writeLaterA = yield* unparserContext.writeLater(3);
+        yield ')';
+        yield* unparserContext.writeEarlier(writeLaterA, async function* (_input, unparserContext) {
+            yield '[';
+            const writeLaterB = yield* unparserContext.writeLater(1);
+            yield ']';
+            yield* unparserContext.writeEarlier(writeLaterB, async function* (_input, unparserContext) {
+                yield 'a';
+            }, undefined);
+        }, undefined);
+    };
+    const stringsAsyncIterable = runUnparser(unparser, undefined, stringUnparserOutputCompanion);
+    const strings = [];
+    for await (const string of stringsAsyncIterable) {
+        strings.push(string);
+    }
+    const string = strings.join('');
+    t.is(string, '([a])');
+});
+test('writeLater deep', async (t) => {
+    const unparser = async function* (_input, unparserContext) {
+        yield '(';
+        const writeLaterA = yield* unparserContext.writeLater(5);
+        yield ')';
+        let writeLaterC;
+        yield* unparserContext.writeEarlier(writeLaterA, async function* (_input, unparserContext) {
+            yield '[';
+            const writeLaterB = yield* unparserContext.writeLater(3);
+            yield ']';
+            yield* unparserContext.writeEarlier(writeLaterB, async function* (_input, unparserContext) {
+                yield '{';
+                writeLaterC = yield* unparserContext.writeLater(1);
+                yield '}';
+            }, undefined);
+        }, undefined);
+        yield* unparserContext.writeEarlier(writeLaterC, async function* (_input, unparserContext) {
+            yield 'a';
+        }, undefined);
+        yield 'z';
+    };
+    const stringsAsyncIterable = runUnparser(unparser, undefined, stringUnparserOutputCompanion);
+    const strings = [];
+    for await (const string of stringsAsyncIterable) {
+        strings.push(string);
+    }
+    const string = strings.join('');
+    t.is(string, '([{a}])z');
+});
+testProp('writeLater positions and lengths', [
+    fc.array(fc.oneof(fc.array(fc.oneof(fc.array(fc.string()), fc.string())), fc.string())),
+], async (t, stringArray3) => {
+    const numberUnparser = async function* (input, unparserContext) {
+        yield input.toString().padStart(8, '0');
+    };
+    const createLengthPrefixedUnparser = (unparser) => {
+        return async function* (input, unparserContext) {
+            const length = yield* unparserContext.writeLater(8);
+            yield* unparser(input, unparserContext);
+            yield* unparserContext.writeEarlier(length, numberUnparser, unparserContext.position - length.positionEnd);
+        };
+    };
+    const unparser0 = createLengthPrefixedUnparser(async function* (input, unparserContext) {
+        yield input;
+    });
+    const unparser1 = createLengthPrefixedUnparser(async function* (input, unparserContext) {
+        for (const string of input) {
+            yield* unparser0(string, unparserContext);
+        }
+    });
+    const unparser2 = createLengthPrefixedUnparser(async function* (input, unparserContext) {
+        for (const stringArray2 of input) {
+            if (typeof stringArray2 === 'string') {
+                yield* unparser0(stringArray2, unparserContext);
+            }
+            else {
+                yield* unparser1(stringArray2, unparserContext);
+            }
+        }
+    });
+    const unparser3 = createLengthPrefixedUnparser(async function* (input, unparserContext) {
+        for (const stringArray3 of input) {
+            if (typeof stringArray3 === 'string') {
+                yield* unparser0(stringArray3, unparserContext);
+            }
+            else {
+                yield* unparser2(stringArray3, unparserContext);
+            }
+        }
+    });
+    const stringsAsyncIterable = runUnparser(unparser3, stringArray3, stringUnparserOutputCompanion);
+    const strings = [];
+    for await (const string of stringsAsyncIterable) {
+        strings.push(string);
+    }
+    const actualString = strings.join('');
+    function getExpectedString(stringArray) {
+        let expectedString = stringArray;
+        if (typeof stringArray !== 'string') {
+            expectedString = stringArray.map(getExpectedString).join('');
+        }
+        return [
+            expectedString.length.toString().padStart(8, '0'),
+            expectedString,
+        ].join('');
+    }
+    const expectedString = getExpectedString(stringArray3);
+    t.deepEqual(actualString, expectedString);
+}, {
+    verbose: true,
+});

package/build/unparserContext.d.ts

@@ -0,0 +1,31 @@
+import { Unparser, UnparserResult } from "./unparser.js";
+import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
+export type UnparserContext<Sequence, Element> = {
+    get position(): number;
+    writeLater(length: number): AsyncIterable<WriteLater<Sequence, Element>, WriteLater<Sequence, Element>>;
+    writeEarlier<Input>(writeLater: WriteLater<Sequence, Element>, unparser: Unparser<Input, Sequence, Element>, input: Input): AsyncIterable<WriteEarlier<Sequence, Element>, void>;
+};
+export declare class WriteLater<Sequence, Element> extends Error {
+    private readonly _position;
+    private readonly _length;
+    name: string;
+    constructor(_position: number, _length: number);
+    get position(): number;
+    get positionEnd(): number;
+    get length(): number;
+}
+export declare class WriteEarlier<Sequence, Element> {
+    readonly writeLater: WriteLater<Sequence, Element>;
+    readonly unparserResult: UnparserResult<Sequence, Element>;
+    readonly unparserContext: UnparserContext<Sequence, Element>;
+    constructor(writeLater: WriteLater<Sequence, Element>, unparserResult: UnparserResult<Sequence, Element>, unparserContext: UnparserContext<Sequence, Element>);
+}
+export declare class UnparserContextImplementation<Sequence, Element> implements UnparserContext<Sequence, Element> {
+    private readonly _outputCompanion;
+    private _position;
+    constructor(_outputCompanion: UnparserOutputCompanion<Sequence, Element>, position?: number);
+    get position(): number;
+    writeLater(length: number): AsyncIterable<WriteLater<Sequence, Element>, WriteLater<Sequence, Element>>;
+    writeEarlier<Input>(writeLater: WriteLater<Sequence, Element>, unparser: Unparser<Input, Sequence, Element>, input: Input): AsyncIterable<WriteEarlier<Sequence, Element>, void>;
+    handleYield(value: Sequence | WriteLater<Sequence, Element> | WriteEarlier<Sequence, Element>): void;
+}

package/build/unparserContext.js

@@ -0,0 +1,74 @@
+/* eslint-disable prefer-arrow-callback */
+import { unparserImplementationInvariant } from "./unparserImplementationInvariant.js";
+import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
+export class WriteLater extends Error {
+    _position;
+    _length;
+    name = 'WriteLater';
+    constructor(_position, _length) {
+        super(`(position: ${_position}, length: ${_length})`);
+        this._position = _position;
+        this._length = _length;
+    }
+    get position() {
+        return this._position;
+    }
+    get positionEnd() {
+        return this._position + this._length;
+    }
+    get length() {
+        return this._length;
+    }
+}
+export class WriteEarlier {
+    writeLater;
+    unparserResult;
+    unparserContext;
+    constructor(writeLater, unparserResult, unparserContext) {
+        this.writeLater = writeLater;
+        this.unparserResult = unparserResult;
+        this.unparserContext = unparserContext;
+    }
+}
+export class UnparserContextImplementation {
+    _outputCompanion;
+    _position;
+    constructor(_outputCompanion, position = 0) {
+        this._outputCompanion = _outputCompanion;
+        this._position = position;
+    }
+    get position() {
+        return this._position;
+    }
+    async *writeLater(length) {
+        parserImplementationInvariant(length >= 0, 'Length of WriteLater must be non-negative, got %s.', length);
+        const writeLater = new WriteLater(this._position, length);
+        yield writeLater;
+        return writeLater;
+    }
+    async *writeEarlier(writeLater, unparser, input) {
+        const unparserContext = new UnparserContextImplementation(this._outputCompanion, writeLater.position);
+        yield new WriteEarlier(writeLater, (async function* () {
+            const startPosition = unparserContext.position;
+            yield* unparser(input, unparserContext);
+            const endPosition = unparserContext.position;
+            const writtenLength = endPosition - startPosition;
+            unparserImplementationInvariant(writtenLength === writeLater.length, [
+                'WriteEarlier was supposed to write %s elements but wrote %s elements instead.',
+                'Corresponding WriteLater stack (this is where it was created): %s',
+                'End of corresponding WriteEarlier stack.',
+            ], writeLater.length, writtenLength, writeLater.stack);
+        })(), unparserContext);
+    }
+    handleYield(value) {
+        if (value instanceof WriteEarlier) {
+            return;
+        }
+        if (value instanceof WriteLater) {
+            this._position += value.length;
+            return;
+        }
+        const length = this._outputCompanion.length(value);
+        this._position += length;
+    }
+}

package/build/unparserError.d.ts

@@ -0,0 +1,9 @@
+export declare class UnparserError extends Error {
+    name: string;
+}
+export declare class UnparserImplementationError extends UnparserError {
+    name: string;
+}
+export declare class UnparserImplementationInvariantError extends UnparserImplementationError {
+    name: string;
+}

package/build/unparserError.js

@@ -0,0 +1,9 @@
+export class UnparserError extends Error {
+    name = 'UnparserError';
+}
+export class UnparserImplementationError extends UnparserError {
+    name = 'UnparserImplementationError';
+}
+export class UnparserImplementationInvariantError extends UnparserImplementationError {
+    name = 'UnparserImplementationInvariantError';
+}

package/build/unparserImplementationInvariant.d.ts

@@ -0,0 +1,2 @@
+import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
+export declare function unparserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;

package/build/unparserImplementationInvariant.js

@@ -0,0 +1,5 @@
+import { UnparserImplementationInvariantError } from './unparserError.js';
+import { customInvariant } from './customInvariant.js';
+export function unparserImplementationInvariant(value, format, ...formatArguments) {
+    return customInvariant(UnparserImplementationInvariantError, value, format, ...formatArguments);
+}

package/build/unparserInputCompanion.d.ts

@@ -0,0 +1,15 @@
+import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from "./parserInputCompanion.js";
+export type UnparserOutputCompanion<Sequence, Element> = {
+    is(value: unknown): value is Sequence;
+    from(elements: Element[]): Sequence;
+    concat(sequences: Sequence[]): Sequence;
+    length(sequence: Sequence): number;
+};
+export declare class StringUnparserOutputCompanion extends StringParserInputCompanion implements UnparserOutputCompanion<string, string> {
+    concat(sequences: string[]): string;
+}
+export declare const stringUnparserOutputCompanion: StringUnparserOutputCompanion;
+export declare class Uint8ArrayUnparserOutputCompanion extends Uint8ArrayParserInputCompanion implements UnparserOutputCompanion<Uint8Array, number> {
+    concat(sequences: Uint8Array[]): Uint8Array;
+}
+export declare const uint8ArrayUnparserOutputCompanion: Uint8ArrayUnparserOutputCompanion;

package/build/unparserInputCompanion.js

@@ -0,0 +1,13 @@
+import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from "./parserInputCompanion.js";
+export class StringUnparserOutputCompanion extends StringParserInputCompanion {
+    concat(sequences) {
+        return sequences.join('');
+    }
+}
+export const stringUnparserOutputCompanion = new StringUnparserOutputCompanion();
+export class Uint8ArrayUnparserOutputCompanion extends Uint8ArrayParserInputCompanion {
+    concat(sequences) {
+        return Buffer.concat(sequences);
+    }
+}
+export const uint8ArrayUnparserOutputCompanion = new Uint8ArrayUnparserOutputCompanion();

package/build/unparserOutputCompanion.d.ts

@@ -0,0 +1,15 @@
+import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from "./parserInputCompanion.js";
+export type UnparserOutputCompanion<Sequence, Element> = {
+    is(value: unknown): value is Sequence;
+    from(elements: Element[]): Sequence;
+    concat(sequences: Sequence[]): Sequence;
+    length(sequence: Sequence): number;
+};
+export declare class StringUnparserOutputCompanion extends StringParserInputCompanion implements UnparserOutputCompanion<string, string> {
+    concat(sequences: string[]): string;
+}
+export declare const stringUnparserOutputCompanion: StringUnparserOutputCompanion;
+export declare class Uint8ArrayUnparserOutputCompanion extends Uint8ArrayParserInputCompanion implements UnparserOutputCompanion<Uint8Array, number> {
+    concat(sequences: Uint8Array[]): Uint8Array;
+}
+export declare const uint8ArrayUnparserOutputCompanion: Uint8ArrayUnparserOutputCompanion;

package/build/unparserOutputCompanion.js

@@ -0,0 +1,13 @@
+import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from "./parserInputCompanion.js";
+export class StringUnparserOutputCompanion extends StringParserInputCompanion {
+    concat(sequences) {
+        return sequences.join('');
+    }
+}
+export const stringUnparserOutputCompanion = new StringUnparserOutputCompanion();
+export class Uint8ArrayUnparserOutputCompanion extends Uint8ArrayParserInputCompanion {
+    concat(sequences) {
+        return Buffer.concat(sequences);
+    }
+}
+export const uint8ArrayUnparserOutputCompanion = new Uint8ArrayUnparserOutputCompanion();

package/build/zip.d.ts

@@ -1,31 +1,23 @@
 export type ZipCompression = 'store' | 'deflate';
-export type ZipUnixPermissions = {
-    type: 'unix';
-    unixPermissions: number;
-};
-export type ZipDosPermissions = {
-    type: 'dos';
-    dosPermissions: number;
-};
-export type ZipPermissions = ZipUnixPermissions | ZipDosPermissions;
-export type ZipFileEntry = {
-    type: 'file';
+export type ZipEntryAttributes = {};
+type ZipEntryCommon = {
     path: string;
     date: Date;
     comment: string;
-    permissions: ZipPermissions;
+    hostSystem: 'unix' | 'dos';
+    attributes: ZipEntryAttributes;
+};
+export type ZipFileEntry = ZipEntryCommon & {
+    type: 'file';
     compression: ZipCompression;
     content: Uint8Array;
 };
-export type ZipDirectoryEntry = {
+export type ZipDirectoryEntry = ZipEntryCommon & {
     type: 'directory';
-    path: string;
-    date: Date;
-    comment: string;
-    permissions: ZipPermissions;
 };
 export type ZipEntry = ZipFileEntry | ZipDirectoryEntry;
 export type Zip = {
     comment: string;
     entries: ZipEntry[];
 };
+export {};

package/build/zipParser.d.ts

@@ -1,17 +1,17 @@
-import { Parser } from "./parser.js";
-import { Zip, ZipCompression, ZipEntry } from "./zip.js";
+import { type Parser } from './parser.js';
+import { type Zip, type ZipCompression, type ZipEntry } from './zip.js';
 type ZipLocalFileHeader = {
     versionNeededToExtract: number;
     generalPurposeBitFlag: number;
     compressionMethod: ZipCompression;
-    lastModFile: Date;
+    lastModifiedFile: Date;
     crc32: number;
     compressedSize: number;
     uncompressedSize: number;
-    fileName: string;
+    filePath: string;
     extraField: Uint8Array;
 };
-type ZipLocalFile = {
+export type ZipLocalFile = {
     zipLocalFileHeader: ZipLocalFileHeader;
     zipEncryptionHeader: unknown;
     compressedData: Uint8Array;
@@ -24,27 +24,30 @@ type ZipVersionMadeBy = {
     hostSystem: number;
     zipSpecificationVersion: number;
 };
-type ZipCentralDirectoryHeader = {
+type ZipExternalFileAttributes = {
+    directory: boolean;
+};
+export type ZipCentralDirectoryHeader = {
     versionMadeBy: ZipVersionMadeBy;
     versionNeededToExtract: number;
     generalPurposeBitFlag: number;
     compressionMethod: ZipCompression;
-    lastModFile: Date;
+    lastModifiedFile: Date;
     crc32: number;
     compressedSize: number;
     uncompressedSize: number;
     diskNumberStart: number;
     internalFileAttributes: number;
-    externalFileAttributes: number;
+    externalFileAttributes: ZipExternalFileAttributes;
     relativeOffsetOfLocalHeader: number;
-    fileName: string;
+    filePath: 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 = {
+export type ZipEndOfCentralDirectoryRecord = {
     numberOfThisDisk: number;
     numberOfTheDiskWithTheStartOfTheCentralDirectory: number;
     totalNumberOfEntriesInTheCentralDirectoryOnThisDisk: number;

package/build/zipParser.js

@@ -1,15 +1,16 @@
-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';
 // https://pkwaredownloads.blob.core.windows.net/pem/APPNOTE.txt
 const uint16LEParser = promiseCompose(createFixedLengthSequenceParser(2), array => Buffer.from(array).readUInt16LE());
 setParserName(uint16LEParser, 'uint16LEParser');
@@ -18,7 +19,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';
@@ -40,21 +41,21 @@ 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) => {
@@ -68,7 +69,7 @@ const zipDataDescriptorParser = createTupleParser([
     uint32LEParser,
     uint32LEParser,
 ]);
-export const zipLocalFileParser = promiseCompose(parserCreatorCompose(() => zipLocalFileHeaderParser, (zipLocalFileHeader) => createTupleParser([
+export const zipLocalFileParser = promiseCompose(parserCreatorCompose(() => zipLocalFileHeaderParser, zipLocalFileHeader => createTupleParser([
     async () => zipLocalFileHeader,
     createOptionalParser(zipEncryptionHeaderParser),
     createFixedLengthSequenceParser(zipLocalFileHeader.compressedSize),
@@ -90,9 +91,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 +116,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 +127,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 +142,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'),
 }));
@@ -179,36 +189,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 +211,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);
         }