@futpib/parser 1.0.1 → 1.0.2

package/build/createDisjunctionParser.js

@@ -1,47 +0,0 @@
-import { ParserParsingFailedError } from './parserError.js';
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { parserParsingInvariant } from './parserParsingInvariant.js';
-function getParserName(parser) {
-    return parser.name || 'anonymousDisjunctionChild';
-}
-export const createDisjunctionParser = (childParsers) => {
-    parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
-    const disjunctionParser = async (parserContext) => {
-        const parserParsingFailedErrors = [];
-        for (const childParser of childParsers) {
-            const childParserContext = parserContext.lookahead(getParserName(childParser));
-            const [childParserResult] = await Promise.allSettled([childParser(childParserContext)]);
-            if (childParserResult.status === 'fulfilled') {
-                const successfulParserOutput = childParserResult.value;
-                childParserContext.unlookahead();
-                childParserContext.dispose();
-                return successfulParserOutput;
-            }
-            else {
-                const error = childParserResult.reason;
-                if (error instanceof ParserParsingFailedError) {
-                    parserParsingFailedErrors.push(error);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        parserParsingInvariant(false, [
-            'No disjunction child parser succeeded.',
-            'Parsing errors, indented, separated by newlines:',
-            '%s',
-            'End of parsing errors.',
-        ], parserParsingFailedErrors
-            .flatMap(error => error.stack?.split('\n'))
-            .map(line => '  ' + line)
-            .join('\n'));
-    };
-    const name = [
-        '(',
-        ...childParsers.map(getParserName).join('|'),
-        ')',
-    ].join('');
-    Object.defineProperty(disjunctionParser, 'name', { value: name });
-    return disjunctionParser;
-};

package/build/createExactParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createExactParser: <InputChunk>(inputChunk: InputChunk) => Parser<InputChunk, InputChunk, unknown>;

package/build/createExactParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createExactParser = (inputChunk) => {
-    parserImplementationInvariant(length > 0, 'Length must be positive.');
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/createSequentialUnionParser.d.ts

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

package/build/createSequentialUnionParser.js

@@ -1,69 +0,0 @@
-import { ParserParsingFailedError } from './parserError.js';
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { parserParsingInvariant } from './parserParsingInvariant.js';
-function getParserName(parser) {
-    return parser.name || 'anonymousSequentialUnionChild';
-}
-export const createDisjunctionParser = (childParsers) => {
-    parserImplementationInvariant(childParsers.length > 0, 'SequentialUnion parser must have at least one child parser.');
-    const sequentialUnionParser = async (parserContext) => {
-        let runningChildParserContexts = [];
-        const childParserResults = (async function* () {
-            for (const childParser of childParsers) {
-                const childParserContext = parserContext.lookahead(getParserName(childParser));
-                runningChildParserContexts.push(childParserContext);
-                const [promiseSettledResult] = await Promise.allSettled([childParser(childParserContext)]);
-                yield {
-                    ...promiseSettledResult,
-                    context: childParserContext,
-                };
-            }
-        })();
-        const parserParsingFailedErrors = [];
-        const successfulParserOutputs = [];
-        const successfulParserContexts = [];
-        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;
-                }
-            }
-        }
-        parserImplementationInvariant(successfulParserOutputs.length <= 1, [
-            'Multiple sequentialUnion child parsers succeeded.',
-            'Successful parser outputs, indented, separated by newlines:',
-            '%s',
-            'End of successful parser outputs.',
-        ], successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'));
-        parserParsingInvariant(successfulParserOutputs.length === 1, [
-            'No sequentialUnion child parser succeeded.',
-            'Parsing errors, indented, separated by newlines:',
-            '%s',
-            'End of parsing errors.',
-        ], parserParsingFailedErrors
-            .flatMap(error => error.stack?.split('\n'))
-            .map(line => '  ' + line)
-            .join('\n'));
-        const [successfulParserContext] = successfulParserContexts;
-        successfulParserContext.unlookahead();
-        successfulParserContext.dispose();
-        const [successfulParserOutput] = successfulParserOutputs;
-        return successfulParserOutput;
-    };
-    const name = [
-        '(',
-        ...childParsers.map(getParserName).join('|'),
-        ')',
-    ].join('');
-    Object.defineProperty(sequentialUnionParser, 'name', { value: name });
-    return sequentialUnionParser;
-};

package/build/fixedLengthChunkParser.d.ts

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

package/build/fixedLengthChunkParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createFixedLengthParser = (length) => {
-    parserImplementationInvariant(length > 0, 'Length must be positive.');
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/fixedLengthParser.d.ts

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

package/build/fixedLengthParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createFixedLengthSequenceParser = (length) => {
-    parserImplementationInvariant(length >= 0, 'Length must be non-negative got %s.', length);
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/inputChunkBuffer.d.ts

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

package/build/inputChunkBuffer.js

@@ -1,40 +0,0 @@
-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/inputChunkBuffer.test.js

@@ -1,34 +0,0 @@
-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/inputCompanion.d.ts

@@ -1,18 +0,0 @@
-export type InputCompanion<Sequence, Element> = {
-    is(value: unknown): value is Sequence;
-    from(elements: Element[]): Sequence;
-    length(sequence: Sequence): number;
-    at(sequence: Sequence, index: number): Element | undefined;
-};
-export declare const stringInputCompanion: {
-    is(value: unknown): value is string;
-    from(elements: string[]): string;
-    length(sequence: string): number;
-    at(sequence: string, index: number): string | undefined;
-};
-export declare const uint8ArrayInputCompanion: {
-    is(value: unknown): value is Uint8Array;
-    from(elements: number[]): Uint8Array;
-    length(sequence: Uint8Array): number;
-    at(sequence: Uint8Array, index: number): number | undefined;
-};

package/build/inputCompanion.js

@@ -1,28 +0,0 @@
-export const stringInputCompanion = new class StringInputCompanion {
-    is(value) {
-        return typeof value === 'string';
-    }
-    from(elements) {
-        return elements.join('');
-    }
-    length(sequence) {
-        return sequence.length;
-    }
-    at(sequence, index) {
-        return sequence.at(index);
-    }
-}();
-export const uint8ArrayInputCompanion = new class Uint8ArrayInputCompanion {
-    is(value) {
-        return value instanceof Uint8Array;
-    }
-    from(elements) {
-        return new Uint8Array(elements);
-    }
-    length(sequence) {
-        return sequence.length;
-    }
-    at(sequence, index) {
-        return sequence.at(index);
-    }
-}();

package/build/invariantDefined.d.ts

@@ -1 +0,0 @@
-export declare function invariantDefined<T>(value: T, format: string, ...extra: any[]): Exclude<T, undefined>;

package/build/invariantDefined.js

@@ -1,5 +0,0 @@
-import invariant from 'invariant';
-export function invariantDefined(value, format, ...extra) {
-    invariant(value !== undefined, format, ...extra);
-    return value;
-}

package/build/invariantIdentity.d.ts

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

package/build/invariantIdentity.js

@@ -1,5 +0,0 @@
-import invariant from 'invariant';
-export function invariantIdentity(value, format, ...extra) {
-    invariant(value, format, ...extra);
-    return value;
-}

package/build/javaKeystoreParser.d.ts

@@ -1,2 +0,0 @@
-import { Parser } from "./parser.js";
-export declare const javaKeyStoreParser: Parser<unknown, Uint8Array>;

package/build/javaKeystoreParser.js

@@ -1,7 +0,0 @@
-import { createArrayParser } from "./arrayParser.js";
-import { createElementParser } from "./elementParser.js";
-import { createTupleParser } from "./tupleParser.js";
-export const javaKeyStoreParser = createTupleParser([
-    createArrayParser(createElementParser()),
-    createArrayParser(createElementParser()),
-]);

package/build/jsonParser2.d.ts

@@ -1,3 +0,0 @@
-import { type JsonValue } from 'type-fest';
-import { type Parser } from './parser.js';
-export declare const jsonValueParser2: Parser<JsonValue, string>;

package/build/jsonParser2.js

@@ -1,52 +0,0 @@
-import { parserParsingInvariant } from './parserParsingInvariant.js';
-import { createUnionParser } from './unionParser.js';
-import { createExactSequenceParser } from './exactSequenceParser.js';
-import { promiseCompose } from './promiseCompose.js';
-const jsonStringParser = async (inputContext) => {
-    await inputContext.read(0);
-    await inputContext.read(0);
-    return '';
-};
-const jsonDummyParser = async (inputContext) => {
-    await inputContext.read(0);
-    parserParsingInvariant(false, 'dummy');
-    return 0;
-};
-const jsonNullParser = promiseCompose(createExactSequenceParser('null'), () => null);
-Object.defineProperty(jsonNullParser, 'name', { value: 'jsonNullParser' });
-const jsonPrimitiveParser = createUnionParser([
-    jsonDummyParser,
-    jsonDummyParser,
-    jsonDummyParser,
-    jsonDummyParser,
-    jsonNullParser,
-]);
-Object.defineProperty(jsonPrimitiveParser, 'name', { value: 'jsonPrimitiveParser' });
-const jsonObjectParser = async (inputContext) => {
-    const value = {};
-    const firstCharacter = await inputContext.read(0);
-    parserParsingInvariant(firstCharacter === '{', 'Expected "{", got "%s"', firstCharacter);
-    const key = await jsonStringParser(inputContext);
-    const colon = await inputContext.read(0);
-    parserParsingInvariant(colon === ':', 'Expected ":", got "%s"', colon);
-    const keyValue = await jsonValueParser2(inputContext);
-    Object.defineProperty(value, key, {
-        value: keyValue,
-        enumerable: true,
-    });
-    const commaOrClosingBrace = await inputContext.peek(0);
-    parserParsingInvariant((commaOrClosingBrace === ','
-        || commaOrClosingBrace === '}'), 'Expected "," or "}", got "%s"', commaOrClosingBrace);
-    if (commaOrClosingBrace === '}') {
-        inputContext.skip(1);
-        return value;
-    }
-    parserParsingInvariant(commaOrClosingBrace === ',', 'Expected ",", got "%s"', commaOrClosingBrace);
-    inputContext.skip(1);
-    return value;
-};
-export const jsonValueParser2 = createUnionParser([
-    jsonObjectParser,
-    jsonPrimitiveParser,
-]);
-Object.defineProperty(jsonValueParser2, 'name', { value: 'jsonValueParser2' });

package/build/jsonParser2.test.js

@@ -1,22 +0,0 @@
-import { testProp, fc } from '@fast-check/ava';
-import { jsonValueParser2 } from './jsonParser2.js';
-import { runParser } from './parser.js';
-import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
-import { stringInputCompanion } from './inputCompanion.js';
-testProp('json', [
-    arbitrarilySlicedAsyncIterator(fc.json()),
-], async (t, [jsonString, jsonStringChunkIterator]) => {
-    if (jsonString !== '{"":null}') {
-        throw new Error('This test is only for the JSON string \'{"":null}\'.');
-    }
-    const actual = await runParser(jsonValueParser2, jsonStringChunkIterator, stringInputCompanion);
-    const expected = JSON.parse(jsonString);
-    t.deepEqual(actual, expected);
-}, {
-    verbose: true,
-    examples: [
-        [['{"":null}', (async function* () {
-                    yield* ['{"":null}'];
-                })()[Symbol.asyncIterator]()]],
-    ],
-});

package/build/negativeLookahead.d.ts

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

package/build/negativeLookahead.js

@@ -1,18 +0,0 @@
-import { getParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
-export const createNegativeLookaheadParser = (childParser) => async (parserContext) => {
-    const childParserContext = parserContext.lookahead();
-    try {
-        await childParser(childParserContext);
-        parserContext.invariant(false, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
-    }
-    catch (error) {
-        if (error instanceof ParserParsingFailedError) {
-            return;
-        }
-        throw error;
-    }
-    finally {
-        childParserContext.dispose();
-    }
-};

package/build/parserCompose.d.ts

@@ -1,3 +0,0 @@
-import { Parser } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
-export declare function parserCreatorCompose<OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): Parser<OutputB, Sequence, Element>;

package/build/parserCompose.js

@@ -1,7 +0,0 @@
-export function parserCreatorCompose(f1, f2) {
-    return async (parserContext) => {
-        const outputA = await f1(parserContext);
-        const parserB = f2(outputA);
-        return parserB(parserContext);
-    };
-}

package/build/parserImplementationInvariantInvariant.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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

package/build/parserInvariant.js

@@ -1,11 +0,0 @@
-export function customInvariant(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/promiseFish.d.ts

@@ -1 +0,0 @@
-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

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

package/build/sequenceParser.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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/terminatedSequenceParser.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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/unparserInputCompanion.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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/zipEntry.d.ts

@@ -1,28 +0,0 @@
-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;