@futpib/parser 1.0.0 → 1.0.2

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/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.js

@@ -1,20 +0,0 @@
-import { getParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
-export const createNegativeLookaheadParser = (childParser) => {
-    return 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/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/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;

package/build/zipFile.d.ts

@@ -1,32 +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: 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/zipFileEntry.d.ts

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

package/src/apk.ts

@@ -1,16 +0,0 @@
-import { Zip } from './zip.js';
-
-export type ApkSigningBlockPair = {
-	id: number;
-	value: Uint8Array;
-};
-
-export type ApkSigningBlock = {
-	zeroPaddingLength?: number;
-	signatureV2?: unknown;
-	pairs: ApkSigningBlockPair[];
-};
-
-export type Apk = Zip & {
-	signingBlock?: ApkSigningBlock;
-};