@futpib/parser 1.0.0

package/build/parserError.js

@@ -0,0 +1,61 @@
+export class ParserError extends Error {
+    name = 'ParserError';
+}
+export class ParserImplementationError extends ParserError {
+    name = 'ParserImplementationError';
+}
+export class ParserImplementationInvariantError extends ParserImplementationError {
+    name = 'ParserImplementationInvariantError';
+}
+export class ParserParsingFailedError extends ParserError {
+    depth;
+    position;
+    name = 'ParserParsingFailedError';
+    constructor(message, depth, position) {
+        super([
+            '(position: ',
+            position,
+            ') ',
+            message,
+        ].join(''));
+        this.depth = depth;
+        this.position = position;
+    }
+}
+export class ParserParsingJoinError extends ParserParsingFailedError {
+    name = 'ParserParsingJoinError';
+    childErrors = [];
+}
+export class ParserParsingJoinNoneError extends ParserParsingJoinError {
+    name = 'ParserParsingJoinNoneError';
+}
+export class ParserParsingJoinAllError extends ParserParsingJoinError {
+    childErrors;
+    name = 'ParserParsingJoinAllError';
+    constructor(message, depth, position, childErrors) {
+        super(message, depth, position);
+        this.childErrors = childErrors;
+    }
+}
+export class ParserParsingJoinDeepestError extends ParserParsingJoinError {
+    childErrors;
+    name = 'ParserParsingJoinDeepestError';
+    constructor(message, depth, position, childErrors) {
+        super(message, depth, position);
+        this.childErrors = childErrors;
+    }
+}
+export class ParserParsingJoinFurthestError extends ParserParsingJoinError {
+    childErrors;
+    name = 'ParserParsingJoinFurthestError';
+    constructor(message, depth, position, childErrors) {
+        super(message, depth, position);
+        this.childErrors = childErrors;
+    }
+}
+export class ParserParsingInvariantError extends ParserParsingFailedError {
+    name = 'ParserParsingInvariantError';
+}
+export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
+    name = 'ParserUnexpectedEndOfInputError';
+}

package/build/parserImplementationInvariant.d.ts

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

package/build/parserImplementationInvariant.js

@@ -0,0 +1,5 @@
+import { ParserImplementationInvariantError } from './parserError.js';
+import { parserInvariant } from './parserInvariant.js';
+export function parserImplementationInvariant(value, format, ...formatArguments) {
+    return parserInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+}

package/build/parserImplementationInvariantInvariant.d.ts

@@ -0,0 +1,3 @@
+type Falsy = '' | 0 | false | undefined;
+export declare function parserImplementationInvariant<T>(value: T, formatOrFormatLines: string | string[], ...extra: any[]): Exclude<T, Falsy>;
+export {};

package/build/parserImplementationInvariantInvariant.js

@@ -0,0 +1,15 @@
+import invariant from 'invariant';
+import { ParserImplementationInvariantError } from './parserError.js';
+export function parserImplementationInvariant(value, formatOrFormatLines, ...extra) {
+    const format = Array.isArray(formatOrFormatLines) ? formatOrFormatLines.join('\n') : formatOrFormatLines;
+    try {
+        invariant(value, format, ...extra);
+        return value;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new ParserImplementationInvariantError(error.message);
+        }
+        throw error;
+    }
+}

package/build/parserInvariant.d.ts

@@ -0,0 +1,4 @@
+import { type Constructor } from 'type-fest';
+export type Falsy = '' | 0 | false | undefined;
+export type ValueOrAccessor<T> = T | (() => T);
+export declare function parserInvariant<T>(ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;

package/build/parserInvariant.js

@@ -0,0 +1,11 @@
+export function parserInvariant(ErrorConstructor, value, formatOrFormatLines, ...formatArguments) {
+    if (value) {
+        return value;
+    }
+    let format = typeof formatOrFormatLines === 'function' ? formatOrFormatLines() : formatOrFormatLines;
+    format = Array.isArray(format) ? format.join('\n') : format;
+    throw new ErrorConstructor(format.replaceAll('%s', () => {
+        const argumentOrAccessor = formatArguments.shift();
+        return typeof argumentOrAccessor === 'function' ? argumentOrAccessor() : argumentOrAccessor;
+    }));
+}

package/build/parserParsingInvariant.d.ts

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

package/build/parserParsingInvariant.js

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

package/build/promiseCompose.d.ts

@@ -0,0 +1 @@
+export declare function promiseCompose<A, B, C>(f1: (a: A) => Promise<B>, f2: (b: B) => C | Promise<C>): (a: A) => Promise<C>;

package/build/promiseCompose.js

@@ -0,0 +1,3 @@
+export function promiseCompose(f1, f2) {
+    return async (a) => f1(a).then(f2);
+}

package/build/promiseFish.d.ts

@@ -0,0 +1 @@
+export declare function promiseCompose<A, B, C>(f1: (a: A) => Promise<B>, f2: (b: B) => Promise<C>): (a: A) => Promise<C>;

package/build/promiseFish.js

@@ -0,0 +1,3 @@
+export function promiseCompose(f1, f2) {
+    return a => f1(a).then(f2);
+}

package/build/sequence.d.ts

@@ -0,0 +1 @@
+export type DeriveSequenceElement<Sequence> = (Sequence extends string ? string : (Sequence extends Uint8Array ? number : never));

package/build/sequence.js

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

package/build/sequenceBuffer.d.ts

@@ -0,0 +1,15 @@
+import { type InputCompanion } from './inputCompanion.js';
+export type SequenceBuffer<Sequence, Element> = {
+    push(sequence: Sequence): void;
+    peek(offset: number): Element | undefined;
+    skip(offset: number): void;
+};
+export declare class SequenceBufferImplementation<Sequence, Element> implements SequenceBuffer<Sequence, Element> {
+    private readonly _inputCompanion;
+    private readonly _sequences;
+    private _indexInFirstSequence;
+    constructor(_inputCompanion: InputCompanion<Sequence, Element>);
+    push(sequence: Sequence): void;
+    peek(offset: number): Element | undefined;
+    skip(offset: number): void;
+}

package/build/sequenceBuffer.js

@@ -0,0 +1,40 @@
+import invariant from 'invariant';
+export class SequenceBufferImplementation {
+    _inputCompanion;
+    _sequences = [];
+    _indexInFirstSequence = 0;
+    constructor(_inputCompanion) {
+        this._inputCompanion = _inputCompanion;
+    }
+    push(sequence) {
+        this._sequences.push(sequence);
+        while (this._sequences.length > 0) {
+            const firstSequence = this._sequences[0];
+            const firstSequenceLength = this._inputCompanion.length(firstSequence);
+            if (firstSequenceLength === 0) {
+                this._sequences.shift();
+                continue;
+            }
+            if (this._indexInFirstSequence < firstSequenceLength) {
+                break;
+            }
+            this._sequences.shift();
+            this._indexInFirstSequence -= firstSequenceLength;
+        }
+    }
+    peek(offset) {
+        invariant(offset >= 0, 'Offset must be non-negative.');
+        let index = this._indexInFirstSequence + offset;
+        for (const sequence of this._sequences) {
+            const sequenceLength = this._inputCompanion.length(sequence);
+            if (index < sequenceLength) {
+                return this._inputCompanion.at(sequence, index);
+            }
+            index -= sequenceLength;
+        }
+        return undefined;
+    }
+    skip(offset) {
+        this._indexInFirstSequence += offset;
+    }
+}

package/build/sequenceBuffer.test.d.ts

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

package/build/sequenceBuffer.test.js

@@ -0,0 +1,34 @@
+import test from 'ava';
+import { SequenceBufferImplementation } from './sequenceBuffer.js';
+import { stringInputCompanion } from './inputCompanion.js';
+test('sequenceBuffer', t => {
+    const sequenceBuffer = new SequenceBufferImplementation(stringInputCompanion);
+    t.is(sequenceBuffer.peek(0), undefined);
+    sequenceBuffer.push('');
+    t.is(sequenceBuffer.peek(0), undefined);
+    sequenceBuffer.push('abc');
+    t.is(sequenceBuffer.peek(0), 'a');
+    t.is(sequenceBuffer.peek(1), 'b');
+    t.is(sequenceBuffer.peek(2), 'c');
+    t.is(sequenceBuffer.peek(3), undefined);
+    sequenceBuffer.push('def');
+    t.is(sequenceBuffer.peek(0), 'a');
+    t.is(sequenceBuffer.peek(3), 'd');
+    t.is(sequenceBuffer.peek(6), undefined);
+    sequenceBuffer.push('');
+    t.is(sequenceBuffer.peek(0), 'a');
+    t.is(sequenceBuffer.peek(3), 'd');
+    t.is(sequenceBuffer.peek(6), undefined);
+    sequenceBuffer.skip(1);
+    t.is(sequenceBuffer.peek(0), 'b');
+    t.is(sequenceBuffer.peek(3), 'e');
+    t.is(sequenceBuffer.peek(5), undefined);
+    sequenceBuffer.skip(3);
+    t.is(sequenceBuffer.peek(0), 'e');
+    t.is(sequenceBuffer.peek(2), undefined);
+    sequenceBuffer.push('gh');
+    t.is(sequenceBuffer.peek(0), 'e');
+    t.is(sequenceBuffer.peek(2), 'g');
+    t.is(sequenceBuffer.peek(3), 'h');
+    t.is(sequenceBuffer.peek(4), undefined);
+});

package/build/sequenceParser.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from './parser.js';
+export declare function createTupleParser<A, B, Sequence>([parserA, parserB]: [Parser<A, Sequence>, Parser<B, Sequence>]): Parser<[A, B], Sequence>;
+export declare function createTupleParser<A, B, C, Sequence>([parserA, parserB, parserC]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>]): Parser<[A, B, C], Sequence>;

package/build/sequenceParser.js

@@ -0,0 +1,10 @@
+export function createTupleParser(parsers) {
+    return async (parserContext) => {
+        const values = [];
+        for (const parser of parsers) {
+            const value = await parser(parserContext);
+            values.push(value);
+        }
+        return values;
+    };
+}

package/build/skipParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createSkipParser: <Sequence>(length: number) => Parser<undefined, Sequence, unknown>;

package/build/skipParser.js

@@ -0,0 +1,8 @@
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+export const createSkipParser = (length) => {
+    parserImplementationInvariant(length > 0, 'Length must be positive.');
+    return async (parserContext) => {
+        parserContext.skip(length);
+        return undefined;
+    };
+};

package/build/sliceBoundedParser.d.ts

@@ -0,0 +1,2 @@
+import { Parser } from "./parser.js";
+export declare const createSliceBoundedParser: <Output, Sequence>(childParser: Parser<Output, Sequence>, sliceEnd: number) => Parser<Output, Sequence>;

package/build/sliceBoundedParser.js

@@ -0,0 +1,24 @@
+import { getParserName, setParserName } from "./parser.js";
+export const createSliceBoundedParser = (childParser, sliceEnd) => {
+    const sliceBoundedParser = async (parserContext) => {
+        const childParserContext = parserContext.lookahead({
+            sliceEnd: parserContext.position + sliceEnd,
+        });
+        try {
+            const value = await childParser(childParserContext);
+            childParserContext.unlookahead();
+            return value;
+        }
+        finally {
+            childParserContext.dispose();
+        }
+    };
+    setParserName(sliceBoundedParser, [
+        'sliceBounded(',
+        getParserName(childParser, 'anonymousSliceBoundedChild'),
+        ',',
+        sliceEnd,
+        ')',
+    ].join(''));
+    return sliceBoundedParser;
+};

package/build/sliceBoundedParser.test.d.ts

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

package/build/sliceBoundedParser.test.js

@@ -0,0 +1,24 @@
+import test from 'ava';
+import { createArrayParser } from './arrayParser.js';
+import { createElementParser } from './elementParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createSliceBoundedParser } from './sliceBoundedParser.js';
+import { runParser } from './parser.js';
+import { stringInputCompanion } from './inputCompanion.js';
+const anythingParser = createArrayParser(createElementParser());
+test('sliceBoundedParser', async (t) => {
+    const parser = createTupleParser([
+        createElementParser(),
+        createSliceBoundedParser(anythingParser, 2),
+        createElementParser(),
+    ]);
+    const result = await runParser(parser, 'abba', stringInputCompanion);
+    t.deepEqual(result, [
+        'a',
+        [
+            'b',
+            'b',
+        ],
+        'a',
+    ]);
+});

package/build/terminatedArrayParser.d.ts

@@ -0,0 +1,2 @@
+import { Parser } from "./parser.js";
+export declare const createTerminatedArrayParser: <ElementOutput, TerminatorOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, terminatorParser: Parser<unknown, Sequence>) => Parser<[ElementOutput[], TerminatorOutput], Sequence>;

package/build/terminatedArrayParser.js

@@ -0,0 +1,27 @@
+import { getParserName, setParserName } from "./parser.js";
+import { promiseCompose } from "./promiseCompose.js";
+import { createUnionParser } from "./unionParser.js";
+class Terminated {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export const createTerminatedArrayParser = (elementParser, terminatorParser) => {
+    const wrappedTerminatorParser = promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue));
+    setParserName(wrappedTerminatorParser, getParserName(terminatorParser, 'anonymousTerminator'));
+    const elementOrTerminatorParser = createUnionParser([
+        elementParser,
+        promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue)),
+    ]);
+    return async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const elementOrTerminator = await elementOrTerminatorParser(parserContext);
+            if (elementOrTerminator instanceof Terminated) {
+                return [elements, elementOrTerminator.value];
+            }
+            elements.push(elementOrTerminator);
+        }
+    };
+};

package/build/terminatedSequenceParser.d.ts

@@ -0,0 +1,2 @@
+import { Parser } from "./parser.js";
+export declare const createTerminatedArrayParser: <ElementOutput, TerminatorOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>, terminatorParser: Parser<unknown, Sequence>) => Parser<[ElementOutput[], TerminatorOutput], Sequence>;

package/build/terminatedSequenceParser.js

@@ -0,0 +1,24 @@
+import { promiseCompose } from "./promiseCompose.js";
+import { createUnionParser } from "./unionParser.js";
+class Terminated {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export const createTerminatedArrayParser = (elementParser, terminatorParser) => {
+    const elementOrTerminatorParser = createUnionParser([
+        elementParser,
+        promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue)),
+    ]);
+    return async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const elementOrTerminator = await elementOrTerminatorParser(parserContext);
+            if (elementOrTerminator instanceof Terminated) {
+                return [elements, elementOrTerminator.value];
+            }
+            elements.push(elementOrTerminator);
+        }
+    };
+};

package/build/tupleParser.d.ts

@@ -0,0 +1,11 @@
+import { type Parser } from './parser.js';
+export declare function createTupleParser<A, B, Sequence>([parserA, parserB]: [Parser<A, Sequence>, Parser<B, Sequence>]): Parser<[A, B], Sequence>;
+export declare function createTupleParser<A, B, C, Sequence>([parserA, parserB, parserC]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>]): Parser<[A, B, C], Sequence>;
+export declare function createTupleParser<A, B, C, D, Sequence>([parserA, parserB, parserC, parserD]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>]): Parser<[A, B, C, D], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, Sequence>([parserA, parserB, parserC, parserD, parserE]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>]): Parser<[A, B, C, D, E], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>]): Parser<[A, B, C, D, E, F], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>]): Parser<[A, B, C, D, E, F, G], Sequence>;
+export declare function createTupleParser<A, B, C, D, E, F, G, H, Sequence>([parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH]: [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<[A, B, C, D, E, F, G, H], Sequence>;
+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>;

package/build/tupleParser.js

@@ -0,0 +1,17 @@
+import { getParserName, setParserName } from './parser.js';
+export function createTupleParser(parsers) {
+    const tupleParser = async (parserContext) => {
+        const values = [];
+        for (const parser of parsers) {
+            const value = await parser(parserContext);
+            values.push(value);
+        }
+        return values;
+    };
+    setParserName(tupleParser, [
+        '[',
+        parsers.map(parser => getParserName(parser, 'anonymousTupleChild')).join(','),
+        ']',
+    ].join(''));
+    return tupleParser;
+}

package/build/unionParser.d.ts

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

package/build/unionParser.js

@@ -0,0 +1,68 @@
+import { allSettledStream } from './allSettledStream.js';
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+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 childParserContext = parserContext.lookahead({
+                debugName: getParserName(childParser, 'anonymousUnionChild'),
+            });
+            runningChildParserContexts.push(childParserContext);
+            const promise = childParser(childParserContext);
+            return {
+                promise,
+                context: childParserContext,
+            };
+        }));
+        const parserParsingFailedErrors = [];
+        const successfulParserOutputs = [];
+        const successfulParserContexts = [];
+        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);
+            }
+            else {
+                const error = childParserResult.reason;
+                if (error instanceof ParserParsingFailedError) {
+                    parserParsingFailedErrors.push(error);
+                }
+                else {
+                    throw error;
+                }
+            }
+            if (runningChildParserContexts.length === 1
+                && successfulParserOutputs.length === 0) {
+                parserImplementationInvariant(!didUnlookahead, 'Union parser unlookaheaded multiple times.');
+                didUnlookahead = true;
+                const [runningChildParserContext] = runningChildParserContexts;
+                runningChildParserContext.unlookahead();
+            }
+        }
+        parserImplementationInvariant(successfulParserOutputs.length <= 1, [
+            'Multiple union child parsers succeeded.',
+            'Successful parser outputs, indented, separated by newlines:',
+            '%s',
+            'End of successful parser outputs.',
+        ], () => successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'));
+        parserContext.invariantJoin(successfulParserOutputs.length === 1, parserParsingFailedErrors, 'No union child parser succeeded.');
+        const [successfulParserContext] = successfulParserContexts;
+        if (!didUnlookahead) {
+            successfulParserContext.unlookahead();
+        }
+        successfulParserContext.dispose();
+        const [successfulParserOutput] = successfulParserOutputs;
+        return successfulParserOutput;
+    };
+    const name = [
+        '(',
+        ...childParsers.map(childParser => getParserName(childParser, 'anonymousUnionChild')).join('|'),
+        ')',
+    ].join('');
+    return setParserName(unionParser, name);
+};

package/build/zip.d.ts

@@ -0,0 +1,31 @@
+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';
+    path: string;
+    date: Date;
+    comment: string;
+    permissions: ZipPermissions;
+    compression: ZipCompression;
+    content: Uint8Array;
+};
+export type ZipDirectoryEntry = {
+    type: 'directory';
+    path: string;
+    date: Date;
+    comment: string;
+    permissions: ZipPermissions;
+};
+export type ZipEntry = ZipFileEntry | ZipDirectoryEntry;
+export type Zip = {
+    comment: string;
+    entries: ZipEntry[];
+};

package/build/zip.js

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

package/build/zipEntry.d.ts

@@ -0,0 +1,28 @@
+export type ZipStoreCompression = {
+    type: 'store';
+};
+export type ZipDeflateCompression = {
+    type: 'deflate';
+    level: number;
+};
+export type ZipCompression = ZipStoreCompression | ZipDeflateCompression;
+export type ZipFileEntry = {
+    type: 'file';
+    name: string;
+    date: Date;
+    comment: string;
+    unixPermissions: number;
+    dosPermissions: number;
+    compression: ZipCompression;
+    content: Uint8Array;
+};
+export type ZipDirectoryEntry = {
+    type: 'directory';
+    name: string;
+    date: Date;
+    comment: string;
+    unixPermissions: number;
+    dosPermissions: number;
+    entries: ZipEntry[];
+};
+export type ZipEntry = ZipFileEntry | ZipDirectoryEntry;

package/build/zipEntry.js

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

package/build/zipFile.d.ts

@@ -0,0 +1,32 @@
+export type ZipStoreCompression = {
+    type: 'store';
+};
+export type ZipDeflateCompression = {
+    type: 'deflate';
+    level: number;
+};
+export type ZipCompression = ZipStoreCompression | ZipDeflateCompression;
+export type ZipFileEntry = {
+    type: 'file';
+    name: string;
+    date: Date;
+    comment: Uint8Array;
+    unixPermissions: number;
+    dosPermissions: number;
+    compression: ZipCompression;
+    content: Uint8Array;
+};
+export type ZipDirectoryEntry = {
+    type: 'directory';
+    name: string;
+    date: Date;
+    comment: Uint8Array;
+    unixPermissions: number;
+    dosPermissions: number;
+    entries: ZipEntry[];
+};
+export type ZipEntry = ZipFileEntry | ZipDirectoryEntry;
+export type ZipFile = {
+    root: ZipDirectoryEntry;
+    comment: Uint8Array;
+};

package/build/zipFile.js

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

package/build/zipFileEntry.d.ts

@@ -0,0 +1,6 @@
+export type ZipFileEntry = {
+    type: 'file';
+    name: string;
+    date: Date;
+    content: Uint8Array;
+};

package/build/zipFileEntry.js

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