@futpib/parser 1.0.3 → 1.0.6

package/build/parserError.js

@@ -15,7 +15,11 @@ export function isParserParsingFailedError(value) {
         && 'depth' in value
         && typeof value.depth === 'number'
         && 'position' in value
-        && typeof value.position === 'number');
+        && typeof value.position === 'number'
+        && 'furthestReadPosition' in value
+        && typeof value.furthestReadPosition === 'number'
+        && 'furthestPeekedPosition' in value
+        && typeof value.furthestPeekedPosition === 'number');
 }
 export function isParserParsingJoinError(value) {
     return (typeof value === 'object'
@@ -40,11 +44,15 @@ function createParserErrorModule(BaseLazyMessageError) {
     class ParserParsingFailedError extends ParserError {
         depth;
         position;
+        furthestReadPosition;
+        furthestPeekedPosition;
         name = 'ParserParsingFailedError';
-        constructor(message, depth, position) {
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition) {
             super(message);
             this.depth = depth;
             this.position = position;
+            this.furthestReadPosition = furthestReadPosition;
+            this.furthestPeekedPosition = furthestPeekedPosition;
         }
     }
     class ParserParsingJoinError extends ParserParsingFailedError {
@@ -57,24 +65,24 @@ function createParserErrorModule(BaseLazyMessageError) {
     class ParserParsingJoinAllError extends ParserParsingJoinError {
         childErrors;
         name = 'ParserParsingJoinAllError';
-        constructor(message, depth, position, childErrors) {
-            super(message, depth, position);
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition, childErrors) {
+            super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
             this.childErrors = childErrors;
         }
     }
     class ParserParsingJoinDeepestError extends ParserParsingJoinError {
         childErrors;
         name = 'ParserParsingJoinDeepestError';
-        constructor(message, depth, position, childErrors) {
-            super(message, depth, position);
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition, childErrors) {
+            super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
             this.childErrors = childErrors;
         }
     }
     class ParserParsingJoinFurthestError extends ParserParsingJoinError {
         childErrors;
         name = 'ParserParsingJoinFurthestError';
-        constructor(message, depth, position, childErrors) {
-            super(message, depth, position);
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition, childErrors) {
+            super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
             this.childErrors = childErrors;
         }
     }

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,101 @@
+import { setParserName } from './parser.js';
+export const createRegExpParser = (regexp) => {
+    const regexpParser = async (parserContext) => {
+        let start = 0;
+        let window = 1;
+        let lastMatch;
+        let reachedEndOfInput = false;
+        let inputLength;
+        while (true) {
+            const sequence = await parserContext.peekSequence(start, start + window);
+            if (sequence === undefined) {
+                if (!reachedEndOfInput) {
+                    reachedEndOfInput = true;
+                    // Binary search to find actual input length
+                    // We know: length >= start (we've peeked successfully before)
+                    // We know: length < start + window (current peek failed)
+                    let lo = start;
+                    let hi = start + window;
+                    while (hi - lo > 1) {
+                        const mid = (lo + hi) >> 1;
+                        const probe = await parserContext.peekSequence(0, mid);
+                        if (probe !== undefined) {
+                            lo = mid;
+                        }
+                        else {
+                            hi = mid;
+                        }
+                    }
+                    inputLength = lo;
+                    // Try matching against the full input
+                    if (inputLength > 0) {
+                        const fullInput = await parserContext.peekSequence(0, inputLength);
+                        if (fullInput !== undefined) {
+                            const match = regexp.exec(fullInput);
+                            if (match !== null && match.index === 0) {
+                                parserContext.skip(match[0].length);
+                                return match;
+                            }
+                        }
+                    }
+                }
+                window = Math.floor(window / 2);
+                if (window === 0) {
+                    // Get the full sequence we've accumulated to verify matches
+                    const fullSequence = await parserContext.peekSequence(0, inputLength ?? 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, inputLength ?? 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,114 @@
+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)
+});
+test('regexpParser should match exact 6-character input', async (t) => {
+    const regexpParser = createRegExpParser(/abcdef/);
+    const result = await runParser(regexpParser, 'abcdef', stringParserInputCompanion);
+    t.is(result[0], 'abcdef');
+});
+test('regexpParser should match quoted string of length 6', async (t) => {
+    const regexpParser = createRegExpParser(/"[^"]*"/);
+    const result = await runParser(regexpParser, '"abcd"', // 6 characters total
+    stringParserInputCompanion);
+    t.is(result[0], '"abcd"');
+});
+// Property-based tests for fixed-length patterns
+testProp('regexpParser should match exact n-character input for any length', [fc.integer({ min: 1, max: 20 })], async (t, length) => {
+    const input = 'a'.repeat(length);
+    const regex = new RegExp(`a{${length}}`);
+    const regexpParser = createRegExpParser(regex);
+    const result = await runParser(regexpParser, input, stringParserInputCompanion);
+    t.is(result[0], input);
+});
+testProp('regexpParser should match quoted strings of any length', [fc.integer({ min: 0, max: 20 })], async (t, contentLength) => {
+    const content = 'x'.repeat(contentLength);
+    const input = `"${content}"`;
+    const regexpParser = createRegExpParser(/"[^"]*"/);
+    const result = await runParser(regexpParser, input, stringParserInputCompanion);
+    t.is(result[0], input);
+});
+testProp('regexpParser greedy patterns should match any length input', [fc.stringMatching(/^[a-z]+$/).filter(s => s.length > 0 && s.length <= 20)], async (t, input) => {
+    const regexpParser = createRegExpParser(/[a-z]+/);
+    const result = await runParser(regexpParser, input, stringParserInputCompanion);
+    t.is(result[0], input);
+});

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>;