@futpib/parser 1.0.2 → 1.0.4

package/build/parserError.js

@@ -1,61 +1,106 @@
-export class ParserError extends Error {
-    name = 'ParserError';
-    position = undefined;
-    inputReaderSate = undefined;
+import { NormalLazyMessageError, NoStackCaptureOverheadLazyMessageError } from './lazyMessageError.js';
+export function isParserError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'position' in value
+        && (typeof value.position === 'number' || value.position === undefined)
+        && 'inputReaderSate' in value
+        && (value.inputReaderSate === undefined || typeof value.inputReaderSate === 'object'));
 }
-export class ParserImplementationError extends ParserError {
-    name = 'ParserImplementationError';
+export function isParserParsingFailedError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'depth' in value
+        && typeof value.depth === 'number'
+        && 'position' in value
+        && typeof value.position === 'number');
 }
-export class ParserImplementationInvariantError extends ParserImplementationError {
-    name = 'ParserImplementationInvariantError';
+export function isParserParsingJoinError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'childErrors' in value
+        && Array.isArray(value.childErrors)
+        && value.childErrors.every((childError) => isParserParsingFailedError(childError)));
 }
-export class ParserParsingFailedError extends ParserError {
-    depth;
-    position;
-    name = 'ParserParsingFailedError';
-    constructor(message, depth, position) {
-        super(message);
-        this.depth = depth;
-        this.position = position;
+function createParserErrorModule(BaseLazyMessageError) {
+    class ParserError extends BaseLazyMessageError {
+        name = 'ParserError';
+        position = undefined;
+        inputReaderSate = undefined;
     }
-}
-export class ParserParsingJoinError extends ParserParsingFailedError {
-    name = 'ParserParsingJoinError';
-    childErrors = [];
-}
-export class ParserParsingJoinNoneError extends ParserParsingJoinError {
-    name = 'ParserParsingJoinNoneError';
-}
-export class ParserParsingJoinAllError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinAllError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserImplementationError extends ParserError {
+        name = 'ParserImplementationError';
     }
-}
-export class ParserParsingJoinDeepestError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinDeepestError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserImplementationInvariantError extends ParserImplementationError {
+        name = 'ParserImplementationInvariantError';
     }
-}
-export class ParserParsingJoinFurthestError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinFurthestError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserParsingFailedError extends ParserError {
+        depth;
+        position;
+        name = 'ParserParsingFailedError';
+        constructor(message, depth, position) {
+            super(message);
+            this.depth = depth;
+            this.position = position;
+        }
     }
+    class ParserParsingJoinError extends ParserParsingFailedError {
+        name = 'ParserParsingJoinError';
+        childErrors = [];
+    }
+    class ParserParsingJoinNoneError extends ParserParsingJoinError {
+        name = 'ParserParsingJoinNoneError';
+    }
+    class ParserParsingJoinAllError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinAllError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingJoinDeepestError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinDeepestError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingJoinFurthestError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinFurthestError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingInvariantError extends ParserParsingFailedError {
+        name = 'ParserParsingInvariantError';
+    }
+    class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
+        name = 'ParserUnexpectedEndOfInputError';
+    }
+    class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+        name = 'ParserUnexpectedRemainingInputError';
+    }
+    return {
+        ParserError,
+        ParserImplementationError,
+        ParserImplementationInvariantError,
+        ParserParsingFailedError,
+        ParserParsingJoinError,
+        ParserParsingJoinNoneError,
+        ParserParsingJoinAllError,
+        ParserParsingJoinDeepestError,
+        ParserParsingJoinFurthestError,
+        ParserParsingInvariantError,
+        ParserUnexpectedEndOfInputError,
+        ParserUnexpectedRemainingInputError,
+    };
 }
-export class ParserParsingInvariantError extends ParserParsingFailedError {
-    name = 'ParserParsingInvariantError';
-}
-export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
-    name = 'ParserUnexpectedEndOfInputError';
-}
-export class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
-    name = 'ParserUnexpectedRemainingInputError';
-}
+export const normalParserErrorModule = createParserErrorModule(NormalLazyMessageError);
+export const noStackCaptureOverheadParserErrorModule = createParserErrorModule(NoStackCaptureOverheadLazyMessageError);

package/build/parserImplementationInvariant.d.ts

@@ -1,2 +1,2 @@
 import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
-export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;

package/build/parserImplementationInvariant.js

@@ -1,5 +1,5 @@
-import { ParserImplementationInvariantError } from './parserError.js';
 import { customInvariant } from './customInvariant.js';
+import { normalParserErrorModule } from './parserError.js';
 export function parserImplementationInvariant(value, format, ...formatArguments) {
-    return customInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+    return customInvariant(normalParserErrorModule.ParserImplementationInvariantError, value, format, ...formatArguments);
 }

package/build/parserInputCompanion.js

@@ -57,8 +57,8 @@ export class Uint8ArrayParserInputCompanion {
         if (sequenceA.length !== sequenceB.length) {
             return false;
         }
-        for (let index = 0; index < sequenceA.length; index++) {
-            if (sequenceA[index] !== sequenceB[index]) {
+        for (const [index, element] of sequenceA.entries()) {
+            if (element !== sequenceB[index]) {
                 return false;
             }
         }

package/build/promiseCompose.js

@@ -1,12 +1,11 @@
 export function promiseCompose(f1, f2) {
-    function promiseComposed(a) {
+    async function promiseComposed(a) {
         const bOrBPromise = f1(a);
         if (bOrBPromise instanceof Promise) {
             return bOrBPromise.then(f2);
         }
         return f2(bOrBPromise);
     }
-    ;
     Object.defineProperty(promiseComposed, 'name', {
         value: `promiseCompose(${f1.name}, ${f2.name})`,
     });

package/build/regexpParser.d.ts

@@ -0,0 +1,2 @@
+import { type Parser } from './parser.js';
+export declare const createRegExpParser: (regexp: RegExp) => Parser<RegExpExecArray, string, string>;

package/build/regexpParser.js

@@ -0,0 +1,71 @@
+import { setParserName } from './parser.js';
+export const createRegExpParser = (regexp) => {
+    const regexpParser = async (parserContext) => {
+        let start = 0;
+        let window = 1;
+        let lastMatch;
+        let reachedEndOfInput = false;
+        while (true) {
+            const sequence = await parserContext.peekSequence(start, start + window);
+            if (sequence === undefined) {
+                reachedEndOfInput = true;
+                window = Math.floor(window / 2);
+                if (window === 0) {
+                    // Get the full sequence we've accumulated to verify matches
+                    const fullSequence = await parserContext.peekSequence(0, start);
+                    // Verify any previous match is still valid with full context
+                    // For lookahead/lookbehind assertions, additional input might invalidate a match
+                    if (fullSequence !== undefined) {
+                        const verifyMatch = regexp.exec(fullSequence);
+                        if (verifyMatch !== null && verifyMatch.index === 0) {
+                            parserContext.skip(verifyMatch[0].length);
+                            return verifyMatch;
+                        }
+                    }
+                    else if (lastMatch !== undefined) {
+                        // No full sequence available but we have a previous match
+                        parserContext.skip(lastMatch[0].length);
+                        return lastMatch;
+                    }
+                    // No previous match - try matching against empty string for zero-width patterns (e.g., /a*/, /[ \t]*/)
+                    const emptyMatch = regexp.exec('');
+                    if (emptyMatch !== null && emptyMatch.index === 0) {
+                        return emptyMatch;
+                    }
+                    return parserContext.invariant(false, 'Unexpected end of input without regex match');
+                }
+                continue;
+            }
+            const fullSequence = await parserContext.peekSequence(0, start + window);
+            if (fullSequence === undefined) {
+                continue;
+            }
+            const match = regexp.exec(fullSequence);
+            if (match === null || match.index !== 0) {
+                if (lastMatch !== undefined) {
+                    // Verify lastMatch is still valid with current full context
+                    // For lookahead/lookbehind assertions, a match on shorter input might be
+                    // invalidated by additional input (e.g., /\|(?!\|)/ matches '|' but not '||')
+                    const verifyMatch = regexp.exec(fullSequence);
+                    if (verifyMatch !== null && verifyMatch.index === 0) {
+                        parserContext.skip(verifyMatch[0].length);
+                        return verifyMatch;
+                    }
+                    // lastMatch was invalidated by additional context
+                    lastMatch = undefined;
+                }
+                if (reachedEndOfInput) {
+                    parserContext.invariant(false, 'Regex did not match at start of input');
+                }
+                start += window;
+                window *= 2;
+                continue;
+            }
+            lastMatch = match;
+            start += window;
+            window *= 2;
+        }
+    };
+    setParserName(regexpParser, regexp.toString());
+    return regexpParser;
+};

package/build/regexpParser.test.d.ts

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

package/build/regexpParser.test.js

@@ -0,0 +1,83 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createRegExpParser } from './regexpParser.js';
+test('regexpParser matches digits', async (t) => {
+    const regexpParser = createRegExpParser(/\d+/);
+    const result = await runParser(regexpParser, '123', stringParserInputCompanion);
+    t.is(result[0], '123');
+});
+test('regexpParser matches at start only', async (t) => {
+    const regexpParser = createRegExpParser(/\d+/);
+    const { output, remainingInput } = await runParserWithRemainingInput(regexpParser, '123abc', stringParserInputCompanion);
+    t.is(output[0], '123');
+    t.truthy(remainingInput);
+});
+test('regexpParser fails when no match at start', async (t) => {
+    const regexpParser = createRegExpParser(/\d+/);
+    await t.throwsAsync(runParser(regexpParser, 'abc123', stringParserInputCompanion));
+});
+test('regexpParser with capture groups', async (t) => {
+    const regexpParser = createRegExpParser(/(\d+)-(\d+)/);
+    const result = await runParser(regexpParser, '123-456', stringParserInputCompanion);
+    t.is(result[0], '123-456');
+    t.is(result[1], '123');
+    t.is(result[2], '456');
+});
+test('regexpParser greedy matching', async (t) => {
+    const regexpParser = createRegExpParser(/a+/);
+    const { output } = await runParserWithRemainingInput(regexpParser, 'aaab', stringParserInputCompanion);
+    t.is(output[0], 'aaa');
+});
+test('regexpParser with anchored regexp', async (t) => {
+    const regexpParser = createRegExpParser(/^hello/);
+    const { output } = await runParserWithRemainingInput(regexpParser, 'hello world', stringParserInputCompanion);
+    t.is(output[0], 'hello');
+});
+testProp.serial('regexpParser matches word characters', [
+    fc.tuple(fc.stringMatching(/^\w+$/), fc.stringMatching(/^\W*$/)),
+], async (t, [word, nonWord]) => {
+    const regexpParser = createRegExpParser(/\w+/);
+    const { output, position } = await runParserWithRemainingInput(regexpParser, word + nonWord, stringParserInputCompanion);
+    t.is(output[0], word);
+    t.is(position, word.length);
+}, {
+    verbose: true,
+});
+// Tests for zero-width/optional patterns at end of input
+test('regexpParser with star quantifier on empty input', async (t) => {
+    const regexpParser = createRegExpParser(/a*/);
+    const result = await runParser(regexpParser, '', stringParserInputCompanion);
+    t.is(result[0], '');
+});
+test('regexpParser with optional whitespace on empty input', async (t) => {
+    const regexpParser = createRegExpParser(/[ \t]*/);
+    const result = await runParser(regexpParser, '', stringParserInputCompanion);
+    t.is(result[0], '');
+});
+test('regexpParser with star quantifier at end of input (no match)', async (t) => {
+    const regexpParser = createRegExpParser(/a*/);
+    const { output } = await runParserWithRemainingInput(regexpParser, 'bbb', stringParserInputCompanion);
+    t.is(output[0], '');
+});
+test('regexpParser with optional group on empty input', async (t) => {
+    const regexpParser = createRegExpParser(/(?:foo)?/);
+    const result = await runParser(regexpParser, '', stringParserInputCompanion);
+    t.is(result[0], '');
+});
+// Tests for negative lookahead
+test('regexpParser with negative lookahead should not match when followed by same char', async (t) => {
+    // This regex should NOT match anything in '||' - the | is followed by another |
+    const regexpParser = createRegExpParser(/\|(?!\|)/);
+    await t.throwsAsync(runParser(regexpParser, '||', stringParserInputCompanion));
+});
+test('regexpParser with negative lookahead should match single char', async (t) => {
+    // This regex should match single '|' when followed by something else
+    const regexpParser = createRegExpParser(/\|(?!\|)/);
+    const { output, position, remainingInput } = await runParserWithRemainingInput(regexpParser, '| ', stringParserInputCompanion);
+    t.is(output[0], '|');
+    t.is(position, 1); // Consumed 1 character
+    t.truthy(remainingInput); // There's remaining input (the space)
+});

package/build/regularExpression.d.ts

@@ -0,0 +1,63 @@
+export type CodePointRange = {
+    start: number;
+    end: number;
+};
+export type CharacterSet = {
+    type: 'empty';
+} | {
+    type: 'node';
+    range: CodePointRange;
+    left: CharacterSet;
+    right: CharacterSet;
+};
+export type RepeatBounds = number | {
+    min: number;
+    max?: number;
+} | {
+    min?: number;
+    max: number;
+};
+export type RegularExpression = {
+    type: 'epsilon';
+} | {
+    type: 'literal';
+    charset: CharacterSet;
+} | {
+    type: 'concat';
+    left: RegularExpression;
+    right: RegularExpression;
+} | {
+    type: 'union';
+    left: RegularExpression;
+    right: RegularExpression;
+} | {
+    type: 'star';
+    inner: RegularExpression;
+} | {
+    type: 'plus';
+    inner: RegularExpression;
+} | {
+    type: 'optional';
+    inner: RegularExpression;
+} | {
+    type: 'repeat';
+    inner: RegularExpression;
+    bounds: RepeatBounds;
+} | {
+    type: 'capture-group';
+    inner: RegularExpression;
+    name?: string;
+} | {
+    type: 'lookahead';
+    isPositive: boolean;
+    inner: RegularExpression;
+    right: RegularExpression;
+} | {
+    type: 'start-anchor';
+    left: RegularExpression;
+    right: RegularExpression;
+} | {
+    type: 'end-anchor';
+    left: RegularExpression;
+    right: RegularExpression;
+};

package/build/regularExpression.js

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

package/build/regularExpressionParser.d.ts

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