@futpib/parser 1.0.1 → 1.0.3

package/build/toAsyncIterator.js

@@ -0,0 +1,33 @@
+import invariant from 'invariant';
+function isAsyncIterable(value) {
+    return typeof value === 'object' && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === 'function';
+}
+function isIterable(value) {
+    return typeof value === 'object' && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === 'function';
+}
+function isIterator(value) {
+    return typeof value === 'object' && value !== null && 'next' in value && typeof value.next === 'function';
+}
+function iteratorToAsyncIterator(iterator) {
+    return {
+        next: async () => iterator.next(),
+    };
+}
+export function toAsyncIterator(value) {
+    if (typeof value === 'string'
+        || value instanceof Uint8Array) {
+        return (async function* () {
+            yield value;
+        })();
+    }
+    if (isAsyncIterable(value)) {
+        return value[Symbol.asyncIterator]();
+    }
+    if (isIterable(value)) {
+        return iteratorToAsyncIterator(value[Symbol.iterator]());
+    }
+    if (isIterator(value)) {
+        return iteratorToAsyncIterator(value);
+    }
+    invariant(false, 'Value must be an async iterator, async iterable, iterable or iterator got %s.', value);
+}

package/build/tupleParser.d.ts

@@ -9,3 +9,7 @@ export declare function createTupleParser<A, B, C, D, E, F, G, H, Sequence>([par
 export declare function createTupleParser<A, B, C, D, E, F, G, H, I, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I], Sequence>;
 export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J], Sequence>;
 export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN, parserO]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>, Parser<O, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O], Sequence>;

package/build/tupleParser.js

@@ -8,10 +8,6 @@ export function createTupleParser(parsers) {
         }
         return values;
     };
-    setParserName(tupleParser, [
-        '[',
-        parsers.map(parser => getParserName(parser, 'anonymousTupleChild')).join(','),
-        ']',
-    ].join(''));
+    setParserName(tupleParser, parsers.map(parser => '(' + getParserName(parser, 'anonymousTupleChild') + ')').join(''));
     return tupleParser;
 }

package/build/unionParser.d.ts

@@ -1,2 +1,3 @@
 import { type Parser } from './parser.js';
-export declare const createUnionParser: <Output, Sequence>(childParsers: Array<Parser<any, Sequence, any>>) => Parser<Output, Sequence, unknown>;
+import { type DeriveSequenceElement } from './sequence.js';
+export declare const createUnionParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Array<Parser<unknown, Sequence, Element>>) => Parser<Output, Sequence, Element>;

package/build/unionParser.js

@@ -1,35 +1,47 @@
 import { allSettledStream } from './allSettledStream.js';
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+const bigintReplacer = (_key, value) => {
+    if (typeof value === 'bigint') {
+        return `${value}n`;
+    }
+    return value;
+};
 export const createUnionParser = (childParsers) => {
     parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
     const unionParser = async (parserContext) => {
         let runningChildParserContexts = [];
-        const childParserResults = allSettledStream(childParsers.map(childParser => {
+        const createChildParserTask = (childParser) => {
             const childParserContext = parserContext.lookahead({
                 debugName: getParserName(childParser, 'anonymousUnionChild'),
             });
-            runningChildParserContexts.push(childParserContext);
-            const promise = childParser(childParserContext);
+            const context = {
+                childParser,
+                childParserContext,
+            };
+            runningChildParserContexts.push(context);
+            const getChildParserPromise = (async () => childParser(childParserContext));
+            const promise = getChildParserPromise();
             return {
                 promise,
-                context: childParserContext,
+                context,
             };
-        }));
+        };
+        const childParserResults = allSettledStream(childParsers.map(createChildParserTask));
         const parserParsingFailedErrors = [];
         const successfulParserOutputs = [];
-        const successfulParserContexts = [];
+        const successfulTaskContexts = [];
         let didUnlookahead = false;
         for await (const childParserResult of childParserResults) {
             runningChildParserContexts = runningChildParserContexts.filter(runningChildParserContext => runningChildParserContext !== childParserResult.context);
             if (childParserResult.status === 'fulfilled') {
                 successfulParserOutputs.push(childParserResult.value);
-                successfulParserContexts.push(childParserResult.context);
+                successfulTaskContexts.push(childParserResult.context);
             }
             else {
                 const error = childParserResult.reason;
-                if (error instanceof ParserParsingFailedError) {
+                if (isParserParsingFailedError(error)) {
                     parserParsingFailedErrors.push(error);
                 }
                 else {
@@ -41,7 +53,7 @@ export const createUnionParser = (childParsers) => {
                 parserImplementationInvariant(!didUnlookahead, 'Union parser unlookaheaded multiple times.');
                 didUnlookahead = true;
                 const [runningChildParserContext] = runningChildParserContexts;
-                runningChildParserContext.unlookahead();
+                runningChildParserContext.childParserContext.unlookahead();
             }
         }
         parserImplementationInvariant(successfulParserOutputs.length <= 1, [
@@ -49,13 +61,16 @@ export const createUnionParser = (childParsers) => {
             'Successful parser outputs, indented, separated by newlines:',
             '%s',
             'End of successful parser outputs.',
-        ], () => successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'));
+            'Successful parser names, indented, separated by newlines:',
+            '%s',
+            'End of successful parser names.',
+        ], () => successfulParserOutputs.map(output => '  ' + JSON.stringify(output, bigintReplacer)).join('\n'), () => successfulTaskContexts.map(taskContext => '  ' + getParserName(taskContext.childParser, 'anonymousUnionChild')).join('\n'));
         parserContext.invariantJoin(successfulParserOutputs.length === 1, parserParsingFailedErrors, 'No union child parser succeeded.');
-        const [successfulParserContext] = successfulParserContexts;
+        const [successfulParserContext] = successfulTaskContexts;
         if (!didUnlookahead) {
-            successfulParserContext.unlookahead();
+            successfulParserContext.childParserContext.unlookahead();
         }
-        successfulParserContext.dispose();
+        successfulParserContext.childParserContext.dispose();
         const [successfulParserOutput] = successfulParserOutputs;
         return successfulParserOutput;
     };

package/build/unionParser.test.d.ts

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

package/build/unionParser.test.js

@@ -0,0 +1,60 @@
+import test from 'ava';
+import { createUnionParser } from './unionParser.js';
+import { runParser, setParserName } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createArrayParser } from './arrayParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+test('union of union of union', async (t) => {
+    const parser = createUnionParser([
+        createExactElementParser('a'),
+        createUnionParser([
+            createExactElementParser('b'),
+            createUnionParser([
+                createExactElementParser('c'),
+                createExactElementParser('d'),
+            ]),
+            createExactElementParser('e'),
+        ]),
+        createExactElementParser('f'),
+        createUnionParser([
+            createExactElementParser('g'),
+            createExactElementParser('h'),
+        ]),
+    ]);
+    for (const character of 'abcdefgh') {
+        t.deepEqual(await runParser(parser, character, stringParserInputCompanion), character);
+    }
+});
+test('sync and async child parsers', async (t) => {
+    const parser = createArrayParser(createUnionParser([
+        async (parserContext) => {
+            parserContext.invariant(parserContext.position % 2 === 0, 'Expected an even position.');
+            return parserContext.read(0);
+        },
+        parserContext => {
+            parserContext.invariant(parserContext.position % 2 === 1, 'Expected an odd position.');
+            parserContext.skip(1);
+            return String.fromCodePoint('A'.codePointAt(0) + parserContext.position - 1);
+        },
+    ]));
+    const result = await runParser(parser, 'a?c?', stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    t.deepEqual(result, [...'aBcD']);
+});
+test('multiple parsers succeeded error', async (t) => {
+    const parser = createUnionParser([
+        setParserName(createExactSequenceParser('foo'), 'foo1'),
+        setParserName(createExactSequenceParser('foo'), 'foo2'),
+    ]);
+    const error = await t.throwsAsync(runParser(parser, 'foo', stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    }), {
+        any: true,
+        name: 'ParserImplementationInvariantError',
+    });
+    t.true(error.message.includes('foo'));
+    t.true(error.message.includes('foo1'));
+    t.true(error.message.includes('foo2'));
+});

package/build/unparser.d.ts

@@ -1,6 +1,6 @@
-import { DeriveSequenceElement } from "./sequence.js";
-import { UnparserContext, WriteEarlier, WriteLater } from "./unparserContext.js";
-import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
+import { type DeriveSequenceElement } from './sequence.js';
+import { type UnparserContext, WriteEarlier, WriteLater } from './unparserContext.js';
+import { type UnparserOutputCompanion } from './unparserOutputCompanion.js';
 type UnparserIterableValue<Sequence, Element> = Sequence | Element | WriteLater<Sequence, Element> | WriteEarlier<Sequence, Element>;
 export type UnparserResult<Sequence, Element> = AsyncIterable<UnparserIterableValue<Sequence, Element>>;
 export type Unparser<Input, Sequence, Element = DeriveSequenceElement<Sequence>> = (input: Input, unparserContext: UnparserContext<Sequence, Element>) => UnparserResult<Sequence, Element>;

package/build/unparser.js

@@ -1,6 +1,6 @@
-import invariant from "invariant";
-import { UnparserContextImplementation, WriteEarlier, WriteLater } from "./unparserContext.js";
-import { unparserImplementationInvariant } from "./unparserImplementationInvariant.js";
+import invariant from 'invariant';
+import { UnparserContextImplementation, WriteEarlier, WriteLater, } from './unparserContext.js';
+import { unparserImplementationInvariant } from './unparserImplementationInvariant.js';
 async function* onYield(asyncIterable, onYield) {
     for await (const value of asyncIterable) {
         onYield(value);
@@ -40,7 +40,9 @@ async function* elementsToSequences(values, unparserOutputCompanion) {
     }
 }
 function wrapUnparserResult(unparserResult, unparserContext, unparserOutputCompanion) {
-    return onYield(elementsToSequences(unparserResult, unparserOutputCompanion), value => unparserContext.handleYield(value));
+    return onYield(elementsToSequences(unparserResult, unparserOutputCompanion), value => {
+        unparserContext.handleYield(value);
+    });
 }
 export async function* runUnparser(unparser, input, unparserOutputCompanion) {
     const unparserContext = new UnparserContextImplementation(unparserOutputCompanion);

package/build/unparser.test.js

@@ -1,8 +1,8 @@
 import test from 'ava';
 import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
 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';
@@ -92,12 +92,10 @@ testProp('writeLater positions and lengths', [
     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 createLengthPrefixedUnparser = (unparser) => 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;
@@ -109,22 +107,12 @@ testProp('writeLater positions and lengths', [
     });
     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);
-            }
+            yield* (typeof stringArray2 === 'string' ? unparser0(stringArray2, unparserContext) : 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);
-            }
+            yield* (typeof stringArray3 === 'string' ? unparser0(stringArray3, unparserContext) : unparser2(stringArray3, unparserContext));
         }
     });
     const stringsAsyncIterable = runUnparser(unparser3, stringArray3, stringUnparserOutputCompanion);

package/build/unparserContext.d.ts

@@ -1,5 +1,5 @@
-import { Unparser, UnparserResult } from "./unparser.js";
-import { UnparserOutputCompanion } from "./unparserOutputCompanion.js";
+import { type Unparser, type UnparserResult } from './unparser.js';
+import { type UnparserOutputCompanion } from './unparserOutputCompanion.js';
 export type UnparserContext<Sequence, Element> = {
     get position(): number;
     writeLater(length: number): AsyncIterable<WriteLater<Sequence, Element>, WriteLater<Sequence, Element>>;

package/build/unparserContext.js

@@ -1,6 +1,5 @@
-/* eslint-disable prefer-arrow-callback */
-import { unparserImplementationInvariant } from "./unparserImplementationInvariant.js";
-import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
+import { unparserImplementationInvariant } from './unparserImplementationInvariant.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 export class WriteLater extends Error {
     _position;
     _length;

package/build/unparserError.d.ts

@@ -1,4 +1,5 @@
-export declare class UnparserError extends Error {
+import { NormalLazyMessageError } from "./lazyMessageError.js";
+export declare class UnparserError extends NormalLazyMessageError {
     name: string;
 }
 export declare class UnparserImplementationError extends UnparserError {

package/build/unparserError.js

@@ -1,4 +1,5 @@
-export class UnparserError extends Error {
+import { NormalLazyMessageError } from "./lazyMessageError.js";
+export class UnparserError extends NormalLazyMessageError {
     name = 'UnparserError';
 }
 export class UnparserImplementationError extends UnparserError {

package/build/unparserImplementationInvariant.d.ts

@@ -1,2 +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>;
+export declare function unparserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;

package/build/unparserOutputCompanion.d.ts

@@ -1,4 +1,4 @@
-import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from "./parserInputCompanion.js";
+import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 export type UnparserOutputCompanion<Sequence, Element> = {
     is(value: unknown): value is Sequence;
     from(elements: Element[]): Sequence;

package/build/unparserOutputCompanion.js

@@ -1,4 +1,4 @@
-import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from "./parserInputCompanion.js";
+import { StringParserInputCompanion, Uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 export class StringUnparserOutputCompanion extends StringParserInputCompanion {
     concat(sequences) {
         return sequences.join('');

package/build/zipParser.d.ts

@@ -1,6 +1,6 @@
 import { type Parser } from './parser.js';
 import { type Zip, type ZipCompression, type ZipEntry } from './zip.js';
-type ZipLocalFileHeader = {
+export type ZipLocalFileHeader = {
     versionNeededToExtract: number;
     generalPurposeBitFlag: number;
     compressionMethod: ZipCompression;
@@ -11,11 +11,16 @@ type ZipLocalFileHeader = {
     filePath: string;
     extraField: Uint8Array;
 };
+type ZipDataDescriptor = {
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+};
 export type ZipLocalFile = {
     zipLocalFileHeader: ZipLocalFileHeader;
     zipEncryptionHeader: unknown;
     compressedData: Uint8Array;
-    zipDataDescriptor: unknown;
+    zipDataDescriptor: undefined | ZipDataDescriptor;
 };
 export declare const zipLocalFileParser: Parser<ZipLocalFile, Uint8Array>;
 export declare const zipArchiveDecryptionHeaderParser: Parser<unknown, Uint8Array>;

package/build/zipParser.js

@@ -11,6 +11,8 @@ 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');
@@ -29,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,
@@ -61,20 +64,40 @@ const zipLocalFileHeaderParser = promiseCompose(zipLocalFileHeaderParser_, ([_zi
 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,
@@ -163,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,
@@ -173,6 +196,7 @@ export const zipEndOfCentralDirectoryRecordParser = promiseCompose(zipEndOfCentr
     offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber,
     zipFileComment,
 }));
+setParserName(zipEndOfCentralDirectoryRecordParser, 'zipEndOfCentralDirectoryRecordParser');
 const zipParser_ = createTupleParser([
     createArrayParser(zipLocalFileParser),
     createOptionalParser(zipArchiveDecryptionHeaderParser),

package/build/zipUnparser.d.ts

@@ -1,5 +1,8 @@
-import { Unparser } from "./unparser.js";
-import { Zip } from "./zip.js";
-import { ZipEndOfCentralDirectoryRecord } from './zipParser.js';
+import { type Unparser } from './unparser.js';
+import { type Zip } from './zip.js';
+import { type ZipEndOfCentralDirectoryRecord } from './zipParser.js';
 export declare const zipEndOfCentralDirectoryRecordUnparser: Unparser<ZipEndOfCentralDirectoryRecord, Uint8Array>;
-export declare const zipUnparser: Unparser<Zip, Uint8Array>;
+export declare const createZipUnparser: ({ dataDescriptor, }?: {
+    dataDescriptor?: boolean;
+}) => Unparser<Zip, Uint8Array>;
+export declare const zipUnparser: Unparser<Zip, Uint8Array<ArrayBufferLike>>;