@futpib/parser 1.0.3 → 1.0.4

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