@futpib/parser 1.0.0 → 1.0.2

package/build/unparser.js

@@ -0,0 +1,104 @@
+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);
+        yield value;
+    }
+}
+async function* elementsToSequences(values, unparserOutputCompanion) {
+    let elements = [];
+    for await (const value of values) {
+        if (value instanceof WriteLater
+            || value instanceof WriteEarlier) {
+            if (elements.length > 0) {
+                const sequence = unparserOutputCompanion.from(elements);
+                yield sequence;
+                elements = [];
+            }
+            yield value;
+        }
+        else if (unparserOutputCompanion.is(value)) {
+            if (unparserOutputCompanion.length(value) === 0) {
+                continue;
+            }
+            if (elements.length > 0) {
+                const sequence = unparserOutputCompanion.from(elements);
+                yield sequence;
+                elements = [];
+            }
+            yield value;
+        }
+        else {
+            elements.push(value);
+        }
+    }
+    if (elements.length > 0) {
+        const sequence = unparserOutputCompanion.from(elements);
+        yield sequence;
+    }
+}
+function wrapUnparserResult(unparserResult, unparserContext, unparserOutputCompanion) {
+    return onYield(elementsToSequences(unparserResult, unparserOutputCompanion), value => unparserContext.handleYield(value));
+}
+export async function* runUnparser(unparser, input, unparserOutputCompanion) {
+    const unparserContext = new UnparserContextImplementation(unparserOutputCompanion);
+    const values = unparser(input, unparserContext);
+    const valuesWithoutElements = wrapUnparserResult(values, unparserContext, unparserOutputCompanion);
+    const outputQueue = [];
+    const iteratorStack = [
+        [
+            valuesWithoutElements[Symbol.asyncIterator](),
+            value => outputQueue.push(value),
+            () => { },
+        ],
+    ];
+    while (true) {
+        while (outputQueue.length > 0
+            && !(outputQueue[0] instanceof WriteLater)) {
+            yield outputQueue.shift();
+        }
+        if (iteratorStack.length === 0) {
+            break;
+        }
+        const [iterator, pushOutput, finishOutput] = iteratorStack[0];
+        const iteratorResult = await iterator.next();
+        if (iteratorResult.done) {
+            finishOutput();
+            iteratorStack.shift();
+            continue;
+        }
+        const { value } = iteratorResult;
+        if (value instanceof WriteEarlier) {
+            const { writeLater, unparserResult, unparserContext } = value;
+            invariant(unparserContext instanceof UnparserContextImplementation, 'UnparserContext not an instance of UnparserContextImplementation.');
+            function getOutputQueueWriteLaterIndex() {
+                const outputQueueWriteLaterIndex = outputQueue.indexOf(writeLater);
+                unparserImplementationInvariant(outputQueueWriteLaterIndex !== -1, [
+                    'WriteLater has already been written or was not yielded yet.',
+                    'WriteLater stack: %s',
+                    'End of WriteLater stack.',
+                ], writeLater.stack);
+                return outputQueueWriteLaterIndex;
+            }
+            const unparserResultWithoutElements = wrapUnparserResult(unparserResult, unparserContext, unparserOutputCompanion);
+            const newPushOutput = value => {
+                const outputQueueWriteLaterIndex = getOutputQueueWriteLaterIndex();
+                outputQueue.splice(outputQueueWriteLaterIndex, 0, value);
+            };
+            const newFinishOutput = () => {
+                const outputQueueWriteLaterIndex = getOutputQueueWriteLaterIndex();
+                const [removedValue] = outputQueue.splice(outputQueueWriteLaterIndex, 1);
+                invariant(removedValue === writeLater, 'WriteLater was not removed from the output queue.');
+            };
+            iteratorStack.unshift([
+                unparserResultWithoutElements[Symbol.asyncIterator](),
+                newPushOutput,
+                newFinishOutput,
+            ]);
+            continue;
+        }
+        pushOutput(value);
+    }
+}

package/build/unparser.test.d.ts

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

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/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,21 +1,26 @@
-import { Parser } from "./parser.js";
-import { Zip, ZipCompression, ZipEntry } from "./zip.js";
-type ZipLocalFileHeader = {
+import { type Parser } from './parser.js';
+import { type Zip, type ZipCompression, type ZipEntry } from './zip.js';
+export 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 = {
+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>;
@@ -24,27 +29,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;