@futpib/parser 1.0.1 → 1.0.3

package/build/leb128Parser.test.js

@@ -0,0 +1,107 @@
+import { testProp, fc } from '@fast-check/ava';
+import test from 'ava';
+// @ts-expect-error
+import leb128 from 'leb128';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { runParser } from './parser.js';
+import { uleb128Parser, sleb128Parser, uleb128NumberParser, sleb128NumberParser, } from './leb128Parser.js';
+test('sleb128, uleb128, uleb128p1', async (t) => {
+    for (const [input, expectedSleb128, expectedUleb128,] of [
+        [Buffer.from('00', 'hex'), 0n, 0n],
+        [Buffer.from('01', 'hex'), 1n, 1n],
+        [Buffer.from('7f', 'hex'), -1n, 127n],
+        [Buffer.from('807f', 'hex'), -128n, 16256n],
+    ]) {
+        const actualSleb128 = await runParser(sleb128Parser, input, uint8ArrayParserInputCompanion);
+        const actualUleb128 = await runParser(uleb128Parser, input, uint8ArrayParserInputCompanion);
+        t.is(actualSleb128, expectedSleb128, 'sleb128');
+        t.is(actualUleb128, expectedUleb128, 'uleb128');
+    }
+    for (const [input, expectedUleb128,] of [
+        [new Uint8Array([2]), 2n],
+        [new Uint8Array([127]), 127n],
+        [new Uint8Array([0 + 0x80, 1]), 128n],
+        [new Uint8Array([1 + 0x80, 1]), 129n],
+        [new Uint8Array([57 + 0x80, 100]), 12857n],
+    ]) {
+        const actualUleb128 = await runParser(uleb128Parser, input, uint8ArrayParserInputCompanion);
+        t.is(actualUleb128, expectedUleb128, 'uleb128');
+    }
+    for (const [input, expectedSleb128,] of [
+        [new Uint8Array([2]), 2n],
+        [new Uint8Array([0x7E]), -2n],
+        [new Uint8Array([127 + 0x80, 0]), 127n],
+        [new Uint8Array([1 + 0x80, 0x7F]), -127n],
+        [new Uint8Array([0 + 0x80, 1]), 128n],
+        [new Uint8Array([0 + 0x80, 0x7F]), -128n],
+        [new Uint8Array([1 + 0x80, 1]), 129n],
+        [new Uint8Array([0x7F + 0x80, 0x7E]), -129n],
+    ]) {
+        const actualSleb128 = await runParser(sleb128Parser, input, uint8ArrayParserInputCompanion);
+        t.is(actualSleb128, expectedSleb128, 'sleb128');
+    }
+});
+testProp('uleb128NumberParser on small number', [
+    fc.nat(),
+], async (t, natural) => {
+    const uleb128 = leb128.unsigned.encode(natural);
+    const actualUleb128 = await runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion);
+    t.is(actualUleb128, natural, 'uleb128');
+}, {
+    verbose: true,
+});
+testProp('sleb128NumberParser on small number', [
+    fc.integer(),
+], async (t, integer) => {
+    const sleb128 = leb128.signed.encode(integer);
+    const actualSleb128 = await runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion);
+    t.is(actualSleb128, integer, 'sleb128');
+}, {
+    verbose: true,
+});
+// TODO?
+testProp.skip('uleb128NumberParser on large number', [
+    fc.maxSafeNat(),
+], async (t, natural) => {
+    const uleb128 = leb128.unsigned.encode(natural);
+    if (natural > (2 ** 32) - 1) {
+        await t.throwsAsync(async () => runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion));
+        return;
+    }
+    const actualUleb128 = await runParser(uleb128NumberParser, uleb128, uint8ArrayParserInputCompanion);
+    t.is(actualUleb128, natural, 'uleb128');
+}, {
+    verbose: true,
+});
+// TODO?
+testProp.skip('sleb128NumberParser on large number', [
+    fc.maxSafeInteger(),
+], async (t, integer) => {
+    const sleb128 = leb128.signed.encode(integer);
+    if (integer > (2 ** 32) - 1 || integer < -(2 ** 32)) {
+        await t.throwsAsync(async () => runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion));
+        return;
+    }
+    const actualSleb128 = await runParser(sleb128NumberParser, sleb128, uint8ArrayParserInputCompanion);
+    t.is(actualSleb128, integer, 'sleb128');
+}, {
+    verbose: true,
+});
+testProp('uleb128Parser on bigint', [
+    fc.bigInt({ min: 0n }),
+], async (t, bigInt) => {
+    const uleb128 = leb128.unsigned.encode(bigInt);
+    const actualUleb128 = await runParser(uleb128Parser, uleb128, uint8ArrayParserInputCompanion);
+    t.is(actualUleb128, bigInt, 'uleb128');
+}, {
+    verbose: true,
+});
+testProp('sleb128Parser on bigint', [
+    fc.bigInt(),
+], async (t, bigInt) => {
+    const sleb128 = leb128.signed.encode(bigInt);
+    const actualSleb128 = await runParser(sleb128Parser, sleb128, uint8ArrayParserInputCompanion);
+    t.is(actualSleb128, bigInt, 'sleb128');
+}, {
+    verbose: true,
+});

package/build/lookaheadParser.d.ts

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

package/build/lookaheadParser.js

@@ -0,0 +1,14 @@
+import { getParserName, setParserName } from './parser.js';
+export const createLookaheadParser = (childParser) => {
+    const lookaheadParser = async (parserContext) => {
+        const childParserContext = parserContext.lookahead();
+        try {
+            return await childParser(childParserContext);
+        }
+        finally {
+            childParserContext.dispose();
+        }
+    };
+    setParserName(lookaheadParser, `(?=${getParserName(childParser)})`);
+    return lookaheadParser;
+};

package/build/negativeLookaheadParser.js

@@ -1,18 +1,24 @@
-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;
+import { getParserName, setParserName } from './parser.js';
+import { isParserParsingFailedError } from './parserError.js';
+export const createNegativeLookaheadParser = (childParser) => {
+    const negativeLookaheadParser = async (parserContext) => {
+        const childParserContext = parserContext.lookahead();
+        let childParserSuccess;
+        try {
+            await childParser(childParserContext);
+            childParserSuccess = true;
         }
-        throw error;
-    }
-    finally {
-        childParserContext.dispose();
-    }
+        catch (error) {
+            if (!isParserParsingFailedError(error)) {
+                throw error;
+            }
+            childParserSuccess = false;
+        }
+        finally {
+            childParserContext.dispose();
+        }
+        parserContext.invariant(!childParserSuccess, 'Negative lookahead assertion failed for child parser %s.', getParserName(childParser));
+    };
+    setParserName(negativeLookaheadParser, `(?!${getParserName(childParser)})`);
+    return negativeLookaheadParser;
 };

package/build/negativeLookaheadParser.test.d.ts

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

package/build/negativeLookaheadParser.test.js

@@ -0,0 +1,30 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createTupleParser } from './tupleParser.js';
+testProp('negativeLookaheadParser', [
+    fc.tuple(fc.string({
+        minLength: 1,
+    }), fc.string({
+        minLength: 1,
+    })).filter(([a, b]) => !a.startsWith(b)),
+], async (t, [stringA, stringB]) => {
+    const result = await runParser(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(stringB)),
+        createExactSequenceParser(stringA + stringB),
+    ]), stringA + stringB, stringParserInputCompanion);
+    t.deepEqual(result, [undefined, stringA + stringB]);
+    await t.throwsAsync(async () => runParser(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(stringA)),
+        createExactSequenceParser(stringA + stringB),
+    ]), stringA + stringB, stringParserInputCompanion), {
+        any: true,
+        name: 'ParserParsingInvariantError',
+        message: /lookahead/,
+    });
+}, {
+    verbose: true,
+});

package/build/noStackCaptureOverheadError.d.ts

@@ -0,0 +1,4 @@
+declare class NoStackCaptureOverheadErrorClass extends Error {
+}
+export declare const NoStackCaptureOverheadError: typeof NoStackCaptureOverheadErrorClass;
+export {};

package/build/noStackCaptureOverheadError.js

@@ -0,0 +1,9 @@
+class NoStackCaptureOverheadErrorClass extends Error {
+}
+function NoStackCaptureOverheadErrorConstructor(message) {
+    this.name = 'NoStackCaptureOverheadError';
+    this.message = message;
+    this.stack = 'This stack is intentionally left blank to avoid capture overhead.';
+}
+NoStackCaptureOverheadErrorConstructor.prototype = Object.create(Error.prototype);
+export const NoStackCaptureOverheadError = NoStackCaptureOverheadErrorConstructor;

package/build/noStackCaptureOverheadError.test.d.ts

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

package/build/noStackCaptureOverheadError.test.js

@@ -0,0 +1,15 @@
+import test from 'ava';
+import util from 'util';
+import { NoStackCaptureOverheadError } from './noStackCaptureOverheadError.js';
+test('NoStackCaptureOverheadError works', t => {
+    const error = new NoStackCaptureOverheadError('Test message');
+    t.is(error.name, 'NoStackCaptureOverheadError');
+    t.is(error.message, 'Test message');
+    t.true(error instanceof Error, 'error is instance of Error');
+    t.true(error instanceof NoStackCaptureOverheadError, 'error is instance of NoStackCaptureOverheadError');
+    t.false(new Error() instanceof NoStackCaptureOverheadError, 'regular Error is not instance of NoStackCaptureOverheadError');
+    if (typeof Error.isError === 'function') {
+        t.false(Error.isError(error), 'Error.isError does not identify error as Error');
+    }
+    t.false(util.types.isNativeError(error), 'util.types.isNativeError does not identify error as native Error');
+});

package/build/nonEmptyArrayParser.d.ts

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

package/build/nonEmptyArrayParser.js

@@ -0,0 +1,32 @@
+import { getParserName, setParserName } from './parser.js';
+import { isParserParsingFailedError } from './parserError.js';
+export const createNonEmptyArrayParser = (elementParser) => {
+    const nonEmptyArrayParser = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const elementParserContext = parserContext.lookahead();
+            const initialPosition = elementParserContext.position;
+            try {
+                const element = await elementParser(elementParserContext);
+                if (elementParserContext.position === initialPosition) {
+                    break;
+                }
+                elements.push(element);
+                elementParserContext.unlookahead();
+            }
+            catch (error) {
+                if (isParserParsingFailedError(error)) {
+                    break;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+        }
+        parserContext.invariant(elements.length > 0, 'Expected elementParser (%s) to match at least once', getParserName(elementParser, 'anonymousNonEmptyArrayChild'));
+        return elements;
+    };
+    setParserName(nonEmptyArrayParser, getParserName(elementParser, 'anonymousNonEmptyArrayChild') + '+');
+    return nonEmptyArrayParser;
+};

package/build/nonEmptyArrayParser.test.d.ts

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

package/build/nonEmptyArrayParser.test.js

@@ -0,0 +1,17 @@
+import test from 'ava';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactElementParser } from './exactElementParser.js';
+test('empty array does not match', async (t) => {
+    const parser = createNonEmptyArrayParser(createExactElementParser('0'));
+    await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});
+test('non-empty array matches', async (t) => {
+    const parser = createNonEmptyArrayParser(createExactElementParser('0'));
+    const result = await runParser(parser, '0', stringParserInputCompanion);
+    t.deepEqual(result, ['0']);
+});

package/build/optionalParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 export const createOptionalParser = (childParser) => {
     const optionalParser = async (parserContext) => {
         const childParserContext = parserContext.lookahead();
@@ -9,7 +9,7 @@ export const createOptionalParser = (childParser) => {
             return value;
         }
         catch (error) {
-            if (error instanceof ParserParsingFailedError) {
+            if (isParserParsingFailedError(error)) {
                 return undefined;
             }
             throw error;

package/build/parser.d.ts

@@ -1,10 +1,20 @@
+import { type Class } from 'type-fest';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type ParserContext } from './parserContext.js';
 import { type DeriveSequenceElement } from './sequence.js';
-export type Parser<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = (parserContext: ParserContext<Sequence, Element>) => Promise<Output>;
+export type Parser<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = (parserContext: ParserContext<Sequence, Element>) => Output | Promise<Output>;
 export declare function getParserName(parser: Parser<any, any, any>, default_?: string): string;
 export declare function setParserName<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, name: string): Parser<Output, Sequence, Element>;
+export declare function cloneParser<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>): Parser<Output, Sequence, Element>;
 export type RunParserOptions<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = {
     errorJoinMode?: 'none' | 'deepest' | 'furthest' | 'all';
+    errorStack?: boolean;
+    parserContextClass?: Class<ParserContext<Sequence, Element>>;
 };
+export type RunParserWithRemainingInputResult<Output, Sequence, Element = DeriveSequenceElement<Sequence>> = {
+    output: Output;
+    position: number;
+    remainingInput: undefined | AsyncIterable<Sequence>;
+};
+export declare function runParserWithRemainingInput<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence, parserInputCompanion: ParserInputCompanion<Sequence, Element>, options?: RunParserOptions<Output, Sequence, Element>): Promise<RunParserWithRemainingInputResult<Output, Sequence, Element>>;
 export declare function runParser<Output, Sequence, Element = DeriveSequenceElement<Sequence>>(parser: Parser<Output, Sequence, Element>, input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence, parserInputCompanion: ParserInputCompanion<Sequence, Element>, options?: RunParserOptions<Output, Sequence, Element>): Promise<Output>;

package/build/parser.js

@@ -1,6 +1,12 @@
-import invariant from 'invariant';
 import { InputReaderImplementation } from './inputReader.js';
 import { ParserContextImplementation } from './parserContext.js';
+import { toAsyncIterator } from './toAsyncIterator.js';
+import { inputReaderStateCompanion } from './inputReaderState.js';
+import { isLazyMessageError } from './lazyMessageError.js';
+import { isParserError, normalParserErrorModule, noStackCaptureOverheadParserErrorModule } from './parserError.js';
+import { NoStackCaptureOverheadError } from './noStackCaptureOverheadError.js';
+import invariant from 'invariant';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function getParserName(parser, default_ = 'anonymous') {
     return parser.name || default_;
 }
@@ -10,44 +16,88 @@ export function setParserName(parser, name) {
     });
     return parser;
 }
-function isAsyncIterable(value) {
-    return value && typeof value[Symbol.asyncIterator] === 'function';
-}
-function isIterable(value) {
-    return value && typeof value[Symbol.iterator] === 'function';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const originalParserByClone = new WeakMap();
+export function cloneParser(parser) {
+    const originalParser = originalParserByClone.get(parser) ?? parser;
+    const clone = parserContext => originalParser(parserContext);
+    setParserName(clone, getParserName(parser));
+    originalParserByClone.set(clone, originalParser);
+    return clone;
 }
-function isIterator(value) {
-    return value && typeof value.next === 'function';
-}
-function iteratorToAsyncIterator(iterator) {
-    return {
-        next: async () => iterator.next(),
-    };
-}
-function toAsyncIterator(value) {
-    if (typeof value === 'string'
-        || value instanceof Uint8Array) {
-        return (async function* () {
-            yield value;
-        })();
-    }
-    if (isAsyncIterable(value)) {
-        return value[Symbol.asyncIterator]();
-    }
-    if (isIterable(value)) {
-        return iteratorToAsyncIterator(value[Symbol.iterator]());
+async function withEnrichedParserError(parserContext, inputReader, f) {
+    try {
+        return await f();
     }
-    if (isIterator(value)) {
-        return iteratorToAsyncIterator(value);
+    catch (error) {
+        if (error instanceof NoStackCaptureOverheadError) {
+            invariant(error.name in normalParserErrorModule, 'NoStackCaptureOverheadError with unknown name encountered during parser execution: %s', error.name);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const normalError = new (normalParserErrorModule[error.name])(error.message);
+            Object.assign(normalError, error);
+            normalError.stack = normalError.stack + '\nIf you need a useful stack trace, pass `errorStack: true` to `runParser`, trading off some performance.';
+            error = normalError;
+        }
+        if (isLazyMessageError(error)) {
+            error.computeMessage();
+        }
+        if (isParserError(error)) {
+            if (error.position === undefined) {
+                error.position = parserContext.position;
+            }
+            if (error.inputReaderSate === undefined) {
+                error.inputReaderSate = inputReader.toInputReaderState();
+            }
+        }
+        throw error;
     }
-    invariant(false, 'Value must be an async iterator, async iterable, iterable or iterator got %s.', value);
 }
-export async function runParser(parser, input, parserInputCompanion, options = {}) {
+function runParserInternal(parser, input, parserInputCompanion, options = {}) {
     const inputAsyncIterator = toAsyncIterator(input);
     const inputReader = new InputReaderImplementation(parserInputCompanion, inputAsyncIterator);
-    const parserContext = new ParserContextImplementation(parserInputCompanion, inputReader, undefined, {
+    const ParserContext = options.parserContextClass ?? ParserContextImplementation;
+    const parserContext = new ParserContext(parserInputCompanion, inputReader, undefined, {
         ...options,
+        errorsModule: options.errorStack ? normalParserErrorModule : noStackCaptureOverheadParserErrorModule,
         debugName: 'root',
     });
-    return parser(parserContext);
+    const outputPromise = (async () => {
+        try {
+            return await parser(parserContext);
+        }
+        finally {
+            await parserContext.peek(0);
+        }
+    })();
+    return {
+        outputPromise,
+        parserContext,
+        inputReader,
+    };
+}
+export async function runParserWithRemainingInput(parser, input, parserInputCompanion, options = {}) {
+    const { outputPromise, parserContext, inputReader, } = runParserInternal(parser, input, parserInputCompanion, options);
+    return withEnrichedParserError(parserContext, inputReader, async () => {
+        const output = await outputPromise;
+        const inputReaderState = inputReader.toInputReaderState();
+        const remainingInput = (inputReaderStateCompanion.isDone(inputReaderState)
+            ? undefined
+            : inputReaderStateCompanion.toRemainingInputAsyncIterator(inputReaderState));
+        return {
+            output,
+            position: parserContext.position,
+            remainingInput,
+        };
+    });
+}
+export async function runParser(parser, input, parserInputCompanion, options = {}) {
+    const { outputPromise, parserContext, inputReader, } = runParserInternal(parser, input, parserInputCompanion, options);
+    return withEnrichedParserError(parserContext, inputReader, async () => {
+        const output = await outputPromise;
+        const inputReaderState = inputReader.toInputReaderState();
+        if (!inputReaderStateCompanion.isDone(inputReaderState)) {
+            throw new normalParserErrorModule.ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position);
+        }
+        return output;
+    });
 }