@futpib/parser 1.0.0

package/build/inputCompanion.js

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

@@ -0,0 +1,22 @@
+import { type InputCompanion } from './inputCompanion.js';
+export type InputReader<Sequence, Element> = {
+    get position(): number;
+    peek(offset: number): Promise<Element | undefined>;
+    skip(offset: number): void;
+    lookahead(): InputReader<Sequence, Element>;
+};
+export declare class InputReaderImplementation<Sequence, Element> implements InputReader<Sequence, Element> {
+    private readonly _inputCompanion;
+    private readonly _inputAsyncIterator;
+    private readonly _id;
+    private _position;
+    private _uncommitedSkipOffset;
+    private readonly _promiseMutex;
+    private readonly _sequenceBuffer;
+    constructor(_inputCompanion: InputCompanion<Sequence, Element>, _inputAsyncIterator: AsyncIterator<Sequence>);
+    get [Symbol.toStringTag](): string;
+    get position(): number;
+    peek(offset: number): Promise<Element | undefined>;
+    skip(offset: number): void;
+    lookahead(): InputReader<Sequence, Element>;
+}

package/build/inputReader.js

@@ -0,0 +1,105 @@
+import PromiseMutex from 'p-mutex';
+import invariant from 'invariant';
+import { SequenceBufferImplementation } from './sequenceBuffer.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+let inputReaderId = 0;
+export class InputReaderImplementation {
+    _inputCompanion;
+    _inputAsyncIterator;
+    _id = inputReaderId++;
+    _position = 0;
+    _uncommitedSkipOffset = 0;
+    _promiseMutex = new PromiseMutex();
+    _sequenceBuffer;
+    constructor(_inputCompanion, _inputAsyncIterator) {
+        this._inputCompanion = _inputCompanion;
+        this._inputAsyncIterator = _inputAsyncIterator;
+        this._sequenceBuffer = new SequenceBufferImplementation(this._inputCompanion);
+    }
+    get [Symbol.toStringTag]() {
+        return [
+            'InputReader',
+            this._id,
+            this.position,
+        ].join(' ');
+    }
+    get position() {
+        return this._position;
+    }
+    async peek(offset) {
+        parserImplementationInvariant(offset >= 0, 'offset >= 0');
+        offset += this._uncommitedSkipOffset;
+        const element = this._sequenceBuffer.peek(offset);
+        if (element !== undefined) {
+            return element;
+        }
+        return this._promiseMutex.withLock(async () => {
+            while (true) {
+                const element = this._sequenceBuffer.peek(offset);
+                if (element !== undefined) {
+                    return element;
+                }
+                const inputIteratorResult = await this._inputAsyncIterator.next();
+                if (inputIteratorResult.done) {
+                    return undefined;
+                }
+                parserImplementationInvariant(this._inputCompanion.is(inputIteratorResult.value), [
+                    'Input iterator result value (%s) is of unexpected type.',
+                    'Expected a sequence (a chunk of input) recognized by the input companion (%s).',
+                    'You may have provided a wrong input companion for the input.',
+                ], inputIteratorResult.value, this._inputCompanion.constructor.name);
+                this._sequenceBuffer.push(inputIteratorResult.value);
+            }
+        });
+    }
+    skip(offset) {
+        parserImplementationInvariant(offset >= 0, 'offset >= 0');
+        this._position += offset;
+        if (this._promiseMutex.isLocked) {
+            this._uncommitedSkipOffset += offset;
+        }
+        else {
+            this._sequenceBuffer.skip(offset + this._uncommitedSkipOffset);
+            this._uncommitedSkipOffset = 0;
+        }
+    }
+    lookahead() {
+        return new InputReaderLookaheadImplementation(this);
+    }
+}
+class InputReaderLookaheadImplementation {
+    _inputReader;
+    _initialInputReaderPosition = 0;
+    _offset = 0;
+    constructor(_inputReader) {
+        this._inputReader = _inputReader;
+        this._initialInputReaderPosition = this._inputReader.position;
+    }
+    get [Symbol.toStringTag]() {
+        return [
+            'InputReaderLookahead',
+            this._inputReader.toString(),
+            this.position,
+        ].join(' ');
+    }
+    get position() {
+        return this._initialInputReaderPosition + this._offset;
+    }
+    async peek(offset) {
+        const inputReaderMovedForward = this._inputReader.position - this._initialInputReaderPosition;
+        this._initialInputReaderPosition = this._inputReader.position;
+        this._offset -= inputReaderMovedForward;
+        return this._inputReader.peek(this._offset + offset);
+    }
+    skip(offset) {
+        parserImplementationInvariant(offset >= 0, 'offset >= 0');
+        this._offset += offset;
+    }
+    lookahead() {
+        const lookahead = new InputReaderLookaheadImplementation(this._inputReader);
+        const offset = this.position - lookahead.position;
+        lookahead.skip(offset);
+        invariant(this.position === lookahead.position, 'this.position (%s) === lookahead.position (%s)', this.position, lookahead.position);
+        return lookahead;
+    }
+}

package/build/inputReader.test.d.ts

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

package/build/inputReader.test.js

@@ -0,0 +1,174 @@
+import test from 'ava';
+import { InputReaderImplementation } from './inputReader.js';
+import { stringInputCompanion } from './inputCompanion.js';
+import { ParserImplementationError } from './parserError.js';
+test('inputReader', async (t) => {
+    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+        yield '';
+        yield 'abc';
+        yield 'def';
+        yield '';
+        yield 'gh';
+    })());
+    t.is(await inputReader.peek(0), 'a');
+    inputReader.skip(0);
+    t.is(await inputReader.peek(1), 'b');
+    inputReader.skip(1);
+    t.is(await inputReader.peek(1), 'c');
+    t.is(await inputReader.peek(2), 'd');
+    t.is(await inputReader.peek(3), 'e');
+    t.is(await inputReader.peek(4), 'f');
+    t.is(await inputReader.peek(5), 'g');
+    t.is(await inputReader.peek(6), 'h');
+    t.is(await inputReader.peek(7), undefined);
+    inputReader.skip(6);
+    t.is(await inputReader.peek(0), 'h');
+    t.is(await inputReader.peek(1), undefined);
+    inputReader.skip(1);
+    t.is(await inputReader.peek(0), undefined);
+    inputReader.skip(0);
+    t.is(await inputReader.peek(0), undefined);
+    inputReader.skip(1);
+    t.is(await inputReader.peek(0), undefined);
+});
+test('inputReader.peek concurrent', async (t) => {
+    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+        yield* 'abcdefgh';
+    })());
+    const peeks = await Promise.all([
+        inputReader.peek(0),
+        inputReader.peek(0),
+        inputReader.peek(0),
+        inputReader.peek(0),
+        inputReader.peek(1),
+        inputReader.peek(2),
+        inputReader.peek(3),
+        inputReader.peek(4),
+        inputReader.peek(5),
+        inputReader.peek(6),
+        inputReader.peek(7),
+    ]);
+    t.deepEqual(peeks, ['a', 'a', 'a', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
+});
+test('inputReader skip while peeking', async (t) => {
+    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+        yield* 'abcdefgh';
+    })());
+    const peekPromise = inputReader.peek(0);
+    inputReader.skip(1);
+    t.is(await peekPromise, 'a');
+    t.is(await inputReader.peek(0), 'b');
+});
+test('inputReader.lookahead', async (t) => {
+    let read = 0;
+    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+        for (const character of 'abcdefgh') {
+            read++;
+            yield character;
+        }
+    })());
+    const lookahead0a = inputReader.lookahead();
+    const lookahead0b = lookahead0a.lookahead();
+    const lookahead0c = lookahead0b.lookahead();
+    t.is(await inputReader.peek(0), 'a');
+    t.is(await lookahead0a.peek(0), 'a');
+    t.is(await lookahead0b.peek(0), 'a');
+    t.is(await lookahead0c.peek(0), 'a');
+    t.is(inputReader.position, 0);
+    t.is(lookahead0a.position, 0);
+    t.is(lookahead0b.position, 0);
+    t.is(lookahead0c.position, 0);
+    t.is(read, 1);
+    t.is(await lookahead0b.peek(1), 'b');
+    t.is(await inputReader.peek(0), 'a');
+    t.is(read, 2);
+    inputReader.skip(1);
+    await t.throwsAsync(async () => lookahead0a.peek(0), {
+        instanceOf: ParserImplementationError,
+    });
+    await t.throwsAsync(async () => lookahead0b.peek(0));
+    await t.throwsAsync(async () => lookahead0c.peek(0));
+    const lookahead1a = inputReader.lookahead();
+    const lookahead1b = inputReader.lookahead();
+    t.is(await lookahead1a.peek(0), 'b');
+    t.is(await lookahead1b.peek(0), 'b');
+    t.is(lookahead1a.position, 1);
+    t.is(lookahead1b.position, 1);
+    lookahead1a.skip(1);
+    t.is(await lookahead1a.peek(0), 'c');
+    t.is(await lookahead1b.peek(0), 'b');
+    t.is(lookahead1a.position, 2);
+    t.is(lookahead1b.position, 1);
+    const lookahead2a = lookahead1a.lookahead();
+    const lookahead2b = lookahead1a.lookahead();
+    lookahead2a.skip(1);
+    t.is(await lookahead2a.peek(0), 'd');
+    t.is(await lookahead2b.peek(0), 'c');
+    t.is(lookahead2a.position, 3);
+    t.is(lookahead2b.position, 2);
+    t.is(read, 4);
+    t.is(await inputReader.peek(0), 'b');
+    t.is(inputReader.position, 1);
+    inputReader.skip(1);
+    t.is(await inputReader.peek(0), 'c');
+    t.is(inputReader.position, 2);
+    await t.throwsAsync(async () => lookahead0a.peek(0));
+    await t.throwsAsync(async () => lookahead0b.peek(0));
+    await t.throwsAsync(async () => lookahead0c.peek(0));
+    t.is(await lookahead1a.peek(0), 'c');
+    await t.throwsAsync(async () => lookahead1b.peek(0));
+    t.is(await lookahead2a.peek(0), 'd');
+    t.is(await lookahead2b.peek(0), 'c');
+    t.is(lookahead0a.position, 0);
+    t.is(lookahead0b.position, 0);
+    t.is(lookahead0c.position, 0);
+    t.is(lookahead1a.position, 2);
+    t.is(lookahead1b.position, 1);
+    t.is(lookahead2a.position, 3);
+    t.is(lookahead2b.position, 2);
+});
+test('inputReader.lookahead concurrent', async (t) => {
+    let read = 0;
+    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+        for (const character of 'abcdefgh') {
+            read++;
+            yield character;
+        }
+    })());
+    const lookahead1 = inputReader.lookahead();
+    const lookahead2 = inputReader.lookahead();
+    const lookahead3 = inputReader.lookahead();
+    const peeks = await Promise.all([
+        lookahead1.peek(0),
+        lookahead2.peek(0),
+        lookahead3.peek(0),
+    ]);
+    const positions = [
+        lookahead1.position,
+        lookahead2.position,
+        lookahead3.position,
+    ];
+    t.deepEqual(peeks, ['a', 'a', 'a']);
+    t.deepEqual(positions, [0, 0, 0]);
+    t.is(read, 1);
+});
+test('inputReader.lookahead skip position', async (t) => {
+    let read = 0;
+    const inputReader = new InputReaderImplementation(stringInputCompanion, (async function* () {
+        for (const character of 'abcdefgh') {
+            read++;
+            yield character;
+        }
+    })());
+    inputReader.skip(1);
+    const lookahead = inputReader.lookahead();
+    lookahead.skip(1);
+    const lookahead1 = lookahead.lookahead();
+    lookahead1.skip(1);
+    t.is(inputReader.position, 1);
+    t.is(lookahead.position, 2);
+    t.is(lookahead1.position, 3);
+    t.is(await inputReader.peek(0), 'b');
+    t.is(await lookahead.peek(0), 'c');
+    t.is(await lookahead1.peek(0), 'd');
+});

package/build/invariantDefined.d.ts

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

package/build/invariantDefined.js

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

package/build/invariantIdentity.d.ts

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

package/build/invariantIdentity.js

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

package/build/jsonParser.d.ts

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

package/build/jsonParser.js

@@ -0,0 +1,133 @@
+import { setParserName } from './parser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { createUnionParser } from './unionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createTerminatedArrayParser } from './terminatedArrayParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createElementParser } from './elementParser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+const whitespaceParser = createArrayParser(createUnionParser([
+    createExactSequenceParser(' '),
+    createExactSequenceParser('\t'),
+    createExactSequenceParser('\r'),
+    createExactSequenceParser('\n'),
+]));
+const jsonQuoteEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\"'), () => '"');
+const jsonBackslashEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\\\'), () => '\\');
+const jsonSlashEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\/'), () => '/');
+const jsonBackspaceEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\b'), () => '\b');
+const jsonFormFeedEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\f'), () => '\f');
+const jsonNewLineEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\n'), () => '\n');
+const jsonCarriageReturnEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\r'), () => '\r');
+const jsonTabEscapeSequenceParser = promiseCompose(createExactSequenceParser('\\t'), () => '\t');
+const jsonUnicodeEscapeSequenceParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\u'),
+    createFixedLengthSequenceParser(4),
+]), ([, hexCode]) => String.fromCharCode(Number.parseInt(hexCode, 16)));
+const jsonStringEscapeSequenceParser = createUnionParser([
+    jsonQuoteEscapeSequenceParser,
+    jsonBackslashEscapeSequenceParser,
+    jsonSlashEscapeSequenceParser,
+    jsonBackspaceEscapeSequenceParser,
+    jsonFormFeedEscapeSequenceParser,
+    jsonNewLineEscapeSequenceParser,
+    jsonCarriageReturnEscapeSequenceParser,
+    jsonTabEscapeSequenceParser,
+    jsonUnicodeEscapeSequenceParser,
+]);
+const elementParser = createElementParser();
+const jsonStringCharacterParser = createDisjunctionParser([
+    jsonStringEscapeSequenceParser,
+    parserCreatorCompose(() => elementParser, character => async (parserContext) => {
+        parserContext.invariant(character !== '"', 'Unexpected """');
+        return character;
+    })(),
+]);
+const jsonStringParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('"'),
+    promiseCompose(createTerminatedArrayParser(jsonStringCharacterParser, createExactSequenceParser('"')), ([characters]) => characters.join('')),
+]), ([, string]) => string);
+const jsonNumberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, (character) => async (parserContext) => {
+    parserContext.invariant((character === '-'
+        || (character >= '0' && character <= '9')
+        || character === '.'
+        || character === 'e'
+        || character === 'E'
+        || character === '+'), 'Expected "-", "0" to "9", ".", "e", "E", "+", got "%s"', character);
+    return character;
+})()), (characters) => async (parserContext) => {
+    parserContext.invariant(characters.length > 0, 'Expected at least one character');
+    return Number(characters.join(''));
+})();
+const jsonTrueParser = promiseCompose(createExactSequenceParser('true'), () => true);
+setParserName(jsonTrueParser, 'jsonTrueParser');
+const jsonFalseParser = promiseCompose(createExactSequenceParser('false'), () => false);
+setParserName(jsonFalseParser, 'jsonFalseParser');
+const jsonNullParser = promiseCompose(createExactSequenceParser('null'), () => null);
+setParserName(jsonNullParser, 'jsonNullParser');
+const jsonPrimitiveParser = createUnionParser([
+    jsonStringParser,
+    jsonNumberParser,
+    jsonTrueParser,
+    jsonFalseParser,
+    jsonNullParser,
+]);
+setParserName(jsonPrimitiveParser, 'jsonPrimitiveParser');
+const jsonObjectEntryParser = promiseCompose(createTupleParser([
+    jsonStringParser,
+    whitespaceParser,
+    createExactSequenceParser(':'),
+    whitespaceParser,
+    createParserAccessorParser(() => jsonValueParser),
+]), ([key, _whitespace1, _colon, _whitespace2, value]) => [key, value]);
+const jsonObjectParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    whitespaceParser,
+    promiseCompose(createTerminatedArrayParser(createDisjunctionParser([
+        promiseCompose(createTupleParser([
+            createParserAccessorParser(() => jsonObjectEntryParser),
+            whitespaceParser,
+            createExactSequenceParser(','),
+            whitespaceParser,
+        ]), ([entry]) => entry),
+        promiseCompose(createTupleParser([
+            createParserAccessorParser(() => jsonObjectEntryParser),
+            whitespaceParser,
+        ]), ([value]) => value),
+    ]), createExactSequenceParser('}')), ([entries]) => entries),
+]), ([_brace, _whitespace, entries]) => {
+    const object = {};
+    for (const [key, value] of entries) {
+        Object.defineProperty(object, key, {
+            value,
+            enumerable: true,
+        });
+    }
+    return object;
+});
+const jsonArrayParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('['),
+    whitespaceParser,
+    promiseCompose(createTerminatedArrayParser(createDisjunctionParser([
+        promiseCompose(createTupleParser([
+            createParserAccessorParser(() => jsonValueParser),
+            whitespaceParser,
+            createExactSequenceParser(','),
+            whitespaceParser,
+        ]), ([value]) => value),
+        promiseCompose(createTupleParser([
+            createParserAccessorParser(() => jsonValueParser),
+            whitespaceParser,
+        ]), ([value]) => value),
+    ]), createExactSequenceParser(']')), ([values]) => values),
+]), ([_bracket, _whitespace, values]) => values);
+export const jsonValueParser = createUnionParser([
+    jsonObjectParser,
+    jsonArrayParser,
+    jsonPrimitiveParser,
+]);
+setParserName(jsonValueParser, 'jsonValueParser');

package/build/jsonParser.test.d.ts

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

package/build/jsonParser.test.js

@@ -0,0 +1,17 @@
+import { testProp, fc } from '@fast-check/ava';
+import { jsonValueParser } from './jsonParser.js';
+import { runParser } from './parser.js';
+import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
+import { stringInputCompanion } from './inputCompanion.js';
+testProp('json', [
+    arbitrarilySlicedAsyncIterator(fc.tuple(fc.json(), fc.nat())
+        .map(([jsonString, indent]) => JSON.stringify(JSON.parse(jsonString), null, indent))),
+], async (t, [jsonString, jsonStringChunkIterator]) => {
+    const actual = await runParser(jsonValueParser, jsonStringChunkIterator, stringInputCompanion, {
+        errorJoinMode: 'none',
+    });
+    const expected = JSON.parse(jsonString);
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+});

package/build/jsonParser2.d.ts

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

package/build/jsonParser2.js

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

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

package/build/jsonParser2.test.js

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

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

package/build/listParser.js

@@ -0,0 +1,34 @@
+import { createNegativeLookaheadParser } from "./negativeLookahead.js";
+import { createParserAccessorParser } from "./parserAccessorParser.js";
+import { promiseCompose } from "./promiseCompose.js";
+import { createTupleParser } from "./tupleParser.js";
+import { createUnionParser } from "./unionParser.js";
+class Nil {
+}
+class Cons {
+    head;
+    tail;
+    constructor(head, tail) {
+        this.head = head;
+        this.tail = tail;
+    }
+}
+export const createListParser = (elementParser) => {
+    const consParser = promiseCompose(createTupleParser([
+        elementParser,
+        createParserAccessorParser(() => listParser),
+    ]), ([head, tail]) => new Cons(head, tail));
+    const nilParser = promiseCompose(createNegativeLookaheadParser(elementParser), () => new Nil());
+    const listParser = createUnionParser([
+        consParser,
+        nilParser,
+    ]);
+    return promiseCompose(listParser, list => {
+        const array = [];
+        while (list instanceof Cons) {
+            array.push(list.head);
+            list = list.tail;
+        }
+        return array;
+    });
+};

package/build/negativeLookahead.d.ts

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

package/build/negativeLookahead.js

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

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