@futpib/parser 1.0.3 → 1.0.4

package/build/regularExpressionParser.js

@@ -0,0 +1,580 @@
+import { createUnionParser } from './unionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createParserAccessorParser } from './parserAccessorParser.js';
+import { createElementParser } from './elementParser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createOptionalParser } from './optionalParser.js';
+import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
+import { createTerminatedArrayParser } from './terminatedArrayParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+// CharacterSet helpers
+const emptyCharacterSet = { type: 'empty' };
+function codePointRangeIsEmpty(range) {
+    return range.start > range.end;
+}
+function codePointRangeIsStrictlyBefore(rangeA, rangeB) {
+    return rangeA.end + 1 < rangeB.start;
+}
+function codePointRangeIsStrictlyAfter(rangeA, rangeB) {
+    return codePointRangeIsStrictlyBefore(rangeB, rangeA);
+}
+function codePointRangeLeastUpperBound(rangeA, rangeB) {
+    if (codePointRangeIsEmpty(rangeA))
+        return rangeB;
+    if (codePointRangeIsEmpty(rangeB))
+        return rangeA;
+    return {
+        start: Math.min(rangeA.start, rangeB.start),
+        end: Math.max(rangeA.end, rangeB.end),
+    };
+}
+function codePointRangeStrictlyDisjoint(rangeA, rangeB) {
+    return codePointRangeIsStrictlyBefore(rangeA, rangeB) || codePointRangeIsStrictlyAfter(rangeA, rangeB);
+}
+function characterSetNode(range, left, right) {
+    return { type: 'node', range, left, right };
+}
+function* characterSetGetRanges(set) {
+    if (set.type === 'node') {
+        yield* characterSetGetRanges(set.left);
+        yield set.range;
+        yield* characterSetGetRanges(set.right);
+    }
+}
+function characterSetExtractOverlap(set, range) {
+    if (set.type === 'empty') {
+        return { restCharSet: set, extendedRange: range };
+    }
+    let extendedRange = range;
+    let newLeft = set.left;
+    let newRight = set.right;
+    if (range.start < set.range.start) {
+        const resultLeft = characterSetExtractOverlap(set.left, range);
+        extendedRange = codePointRangeLeastUpperBound(extendedRange, resultLeft.extendedRange);
+        newLeft = resultLeft.restCharSet;
+    }
+    if (range.end > set.range.end) {
+        const resultRight = characterSetExtractOverlap(set.right, range);
+        extendedRange = codePointRangeLeastUpperBound(extendedRange, resultRight.extendedRange);
+        newRight = resultRight.restCharSet;
+    }
+    if (codePointRangeStrictlyDisjoint(range, set.range)) {
+        return {
+            extendedRange,
+            restCharSet: characterSetNode(set.range, newLeft, newRight),
+        };
+    }
+    return {
+        extendedRange: codePointRangeLeastUpperBound(set.range, extendedRange),
+        restCharSet: characterSetUnion(newLeft, newRight),
+    };
+}
+function characterSetInsertRange(set, range) {
+    if (codePointRangeIsEmpty(range)) {
+        return set;
+    }
+    if (set.type === 'empty') {
+        return characterSetNode(range, emptyCharacterSet, emptyCharacterSet);
+    }
+    if (codePointRangeIsStrictlyBefore(range, set.range)) {
+        return characterSetNode(set.range, characterSetInsertRange(set.left, range), set.right);
+    }
+    if (codePointRangeIsStrictlyAfter(range, set.range)) {
+        return characterSetNode(set.range, set.left, characterSetInsertRange(set.right, range));
+    }
+    const resultLeft = characterSetExtractOverlap(set.left, range);
+    const resultRight = characterSetExtractOverlap(set.right, range);
+    const resultRange = [set.range, resultLeft.extendedRange, resultRight.extendedRange].reduce(codePointRangeLeastUpperBound);
+    if (codePointRangeIsEmpty(resultRange)) {
+        return emptyCharacterSet;
+    }
+    return characterSetNode(resultRange, resultLeft.restCharSet, resultRight.restCharSet);
+}
+function characterSetUnion(setA, setB) {
+    return [...characterSetGetRanges(setB)].reduce(characterSetInsertRange, setA);
+}
+function codePointRangeSplitAt(point, range) {
+    return [
+        { start: range.start, end: Math.min(range.end, point) },
+        { start: Math.max(range.start, point + 1), end: range.end },
+    ];
+}
+function codePointRangeUnion(rangeA, rangeB) {
+    if (codePointRangeIsEmpty(rangeA) && codePointRangeIsEmpty(rangeB))
+        return [];
+    if (codePointRangeIsEmpty(rangeA))
+        return [rangeB];
+    if (codePointRangeIsEmpty(rangeB))
+        return [rangeA];
+    if (rangeA.end + 1 < rangeB.start)
+        return [rangeA, rangeB];
+    if (rangeB.end + 1 < rangeA.start)
+        return [rangeB, rangeA];
+    return [{
+            start: Math.min(rangeA.start, rangeB.start),
+            end: Math.max(rangeA.end, rangeB.end),
+        }];
+}
+function codePointRangeDifference(rangeA, rangeB) {
+    const [before, restRangeA] = codePointRangeSplitAt(rangeB.start - 1, rangeA);
+    const [, after] = codePointRangeSplitAt(rangeB.end, restRangeA);
+    return codePointRangeUnion(before, after);
+}
+function characterSetDeleteRange(set, range) {
+    if (codePointRangeIsEmpty(range)) {
+        return set;
+    }
+    if (set.type === 'empty') {
+        return emptyCharacterSet;
+    }
+    const [rangeBeforeStart] = codePointRangeSplitAt(set.range.start - 1, range);
+    const [rangeRest2, rangeAfterEnd] = codePointRangeSplitAt(set.range.end, range);
+    const newLeft = characterSetDeleteRange(set.left, rangeBeforeStart);
+    const newRight = characterSetDeleteRange(set.right, rangeAfterEnd);
+    const setRangeRest = codePointRangeDifference(set.range, rangeRest2);
+    if (setRangeRest.length === 0) {
+        return characterSetUnion(newLeft, newRight);
+    }
+    if (setRangeRest.length === 1) {
+        return characterSetNode(setRangeRest[0], newLeft, newRight);
+    }
+    // setRangeRest.length === 2
+    return characterSetUnion(characterSetInsertRange(newLeft, setRangeRest[0]), characterSetInsertRange(newRight, setRangeRest[1]));
+}
+function characterSetDifference(setA, setB) {
+    return [...characterSetGetRanges(setB)].reduce(characterSetDeleteRange, setA);
+}
+function characterSetFromRange(range) {
+    if (codePointRangeIsEmpty(range)) {
+        return emptyCharacterSet;
+    }
+    return characterSetNode(range, emptyCharacterSet, emptyCharacterSet);
+}
+function characterSetSingleton(char) {
+    const codePoint = char.codePointAt(0);
+    return characterSetFromRange({ start: codePoint, end: codePoint });
+}
+function characterSetCharRange(startChar, endChar) {
+    const start = startChar.codePointAt(0);
+    const end = endChar.codePointAt(0);
+    return characterSetFromRange({ start, end });
+}
+function characterSetFromArray(chars) {
+    return chars.map(characterSetSingleton).reduce(characterSetUnion, emptyCharacterSet);
+}
+function characterSetComplement(set) {
+    return characterSetDifference(alphabet, set);
+}
+// Pre-defined character sets
+const alphabet = characterSetDifference(characterSetFromRange({ start: 0, end: 0x10FFFF }), characterSetFromArray(['\r', '\n', '\u2028', '\u2029']));
+const wildcardCharacterSet = characterSetDifference(alphabet, characterSetFromArray(['\r', '\n', '\u2028', '\u2029']));
+const digitChars = characterSetCharRange('0', '9');
+const nonDigitChars = characterSetComplement(digitChars);
+const wordChars = [
+    characterSetCharRange('a', 'z'),
+    characterSetCharRange('A', 'Z'),
+    characterSetCharRange('0', '9'),
+    characterSetSingleton('_'),
+].reduce(characterSetUnion);
+const nonWordChars = characterSetComplement(wordChars);
+const whiteSpaceChars = [
+    characterSetSingleton('\f'),
+    characterSetSingleton('\n'),
+    characterSetSingleton('\r'),
+    characterSetSingleton('\t'),
+    characterSetSingleton('\v'),
+    characterSetSingleton('\u0020'),
+    characterSetSingleton('\u00a0'),
+    characterSetSingleton('\u1680'),
+    characterSetCharRange('\u2000', '\u200a'),
+    characterSetSingleton('\u2028'),
+    characterSetSingleton('\u2029'),
+    characterSetSingleton('\u202f'),
+    characterSetSingleton('\u205f'),
+    characterSetSingleton('\u3000'),
+    characterSetSingleton('\ufeff'),
+].reduce(characterSetUnion);
+const nonWhiteSpaceChars = characterSetComplement(whiteSpaceChars);
+// AST constructors
+const epsilon = { type: 'epsilon' };
+function literal(charset) {
+    return { type: 'literal', charset };
+}
+function concat(left, right) {
+    return { type: 'concat', left, right };
+}
+function union(left, right) {
+    return { type: 'union', left, right };
+}
+function star(inner) {
+    return { type: 'star', inner };
+}
+function plus(inner) {
+    return { type: 'plus', inner };
+}
+function optional(inner) {
+    return { type: 'optional', inner };
+}
+function repeat(inner, bounds) {
+    return { type: 'repeat', inner, bounds };
+}
+function captureGroup(inner, name) {
+    if (name === undefined) {
+        return { type: 'capture-group', inner };
+    }
+    return { type: 'capture-group', inner, name };
+}
+function lookahead(isPositive, inner, right) {
+    return { type: 'lookahead', isPositive, inner, right };
+}
+function startAnchor(left, right) {
+    return { type: 'start-anchor', left, right };
+}
+function endAnchor(left, right) {
+    return { type: 'end-anchor', left, right };
+}
+// Parser implementation
+const elementParser = createElementParser();
+const metaCharacters = new Set(['\\', '^', '$', '.', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}']);
+// Escape sequences for control characters
+const escapeNParser = promiseCompose(createExactSequenceParser('\\n'), () => literal(characterSetSingleton('\n')));
+const escapeRParser = promiseCompose(createExactSequenceParser('\\r'), () => literal(characterSetSingleton('\r')));
+const escapeTParser = promiseCompose(createExactSequenceParser('\\t'), () => literal(characterSetSingleton('\t')));
+const escapeFParser = promiseCompose(createExactSequenceParser('\\f'), () => literal(characterSetSingleton('\f')));
+const escapeVParser = promiseCompose(createExactSequenceParser('\\v'), () => literal(characterSetSingleton('\v')));
+const escape0Parser = promiseCompose(createExactSequenceParser('\\0'), () => literal(characterSetSingleton('\0')));
+// Character class escapes
+const escapeDigitParser = promiseCompose(createExactSequenceParser('\\d'), () => literal(digitChars));
+const escapeNonDigitParser = promiseCompose(createExactSequenceParser('\\D'), () => literal(nonDigitChars));
+const escapeWordParser = promiseCompose(createExactSequenceParser('\\w'), () => literal(wordChars));
+const escapeNonWordParser = promiseCompose(createExactSequenceParser('\\W'), () => literal(nonWordChars));
+const escapeSpaceParser = promiseCompose(createExactSequenceParser('\\s'), () => literal(whiteSpaceChars));
+const escapeNonSpaceParser = promiseCompose(createExactSequenceParser('\\S'), () => literal(nonWhiteSpaceChars));
+// Hex escape \xHH
+const escapeHexParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\x'),
+    createFixedLengthSequenceParser(2),
+]), ([, hexCode]) => literal(characterSetSingleton(String.fromCharCode(Number.parseInt(hexCode, 16)))));
+// Unicode escape \uHHHH
+const escapeUnicodeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\u'),
+    createFixedLengthSequenceParser(4),
+]), ([, hexCode]) => literal(characterSetSingleton(String.fromCharCode(Number.parseInt(hexCode, 16)))));
+// Escaped metacharacter (e.g., \., \*, etc.)
+const escapeMetacharacterParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\'),
+    elementParser,
+]), ([, char]) => literal(characterSetSingleton(char)));
+// All escape sequences - use createDisjunctionParser to try specific escapes first
+const escapeParser = createDisjunctionParser([
+    escapeNParser,
+    escapeRParser,
+    escapeTParser,
+    escapeFParser,
+    escapeVParser,
+    escape0Parser,
+    escapeDigitParser,
+    escapeNonDigitParser,
+    escapeWordParser,
+    escapeNonWordParser,
+    escapeSpaceParser,
+    escapeNonSpaceParser,
+    escapeHexParser,
+    escapeUnicodeParser,
+    escapeMetacharacterParser, // Must be last - matches any escaped char
+]);
+// Dot (matches any character except newline)
+const dotParser = promiseCompose(createExactSequenceParser('.'), () => literal(wildcardCharacterSet));
+// Literal character (non-metacharacter)
+const literalCharacterParser = parserCreatorCompose(() => elementParser, char => async (parserContext) => {
+    parserContext.invariant(!metaCharacters.has(char), 'Unexpected metacharacter "%s"', char);
+    return literal(characterSetSingleton(char));
+})();
+// Character class internals
+// Character in a character class (different rules than outside)
+const charClassMetaCharacters = new Set(['\\', ']', '^', '-']);
+// Escape sequences inside character class (returns CharacterSet)
+const charClassEscapeNParser = promiseCompose(createExactSequenceParser('\\n'), () => characterSetSingleton('\n'));
+const charClassEscapeRParser = promiseCompose(createExactSequenceParser('\\r'), () => characterSetSingleton('\r'));
+const charClassEscapeTParser = promiseCompose(createExactSequenceParser('\\t'), () => characterSetSingleton('\t'));
+const charClassEscapeFParser = promiseCompose(createExactSequenceParser('\\f'), () => characterSetSingleton('\f'));
+const charClassEscapeVParser = promiseCompose(createExactSequenceParser('\\v'), () => characterSetSingleton('\v'));
+const charClassEscape0Parser = promiseCompose(createExactSequenceParser('\\0'), () => characterSetSingleton('\0'));
+const charClassEscapeDigitParser = promiseCompose(createExactSequenceParser('\\d'), () => digitChars);
+const charClassEscapeNonDigitParser = promiseCompose(createExactSequenceParser('\\D'), () => nonDigitChars);
+const charClassEscapeWordParser = promiseCompose(createExactSequenceParser('\\w'), () => wordChars);
+const charClassEscapeNonWordParser = promiseCompose(createExactSequenceParser('\\W'), () => nonWordChars);
+const charClassEscapeSpaceParser = promiseCompose(createExactSequenceParser('\\s'), () => whiteSpaceChars);
+const charClassEscapeNonSpaceParser = promiseCompose(createExactSequenceParser('\\S'), () => nonWhiteSpaceChars);
+const charClassEscapeHexParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\x'),
+    createFixedLengthSequenceParser(2),
+]), ([, hexCode]) => characterSetSingleton(String.fromCharCode(Number.parseInt(hexCode, 16))));
+const charClassEscapeUnicodeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\u'),
+    createFixedLengthSequenceParser(4),
+]), ([, hexCode]) => characterSetSingleton(String.fromCharCode(Number.parseInt(hexCode, 16))));
+const charClassEscapeMetacharacterParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('\\'),
+    elementParser,
+]), ([, char]) => characterSetSingleton(char));
+// Use createDisjunctionParser to try specific escapes before generic metacharacter escape
+const charClassEscapeParser = createDisjunctionParser([
+    charClassEscapeNParser,
+    charClassEscapeRParser,
+    charClassEscapeTParser,
+    charClassEscapeFParser,
+    charClassEscapeVParser,
+    charClassEscape0Parser,
+    charClassEscapeDigitParser,
+    charClassEscapeNonDigitParser,
+    charClassEscapeWordParser,
+    charClassEscapeNonWordParser,
+    charClassEscapeSpaceParser,
+    charClassEscapeNonSpaceParser,
+    charClassEscapeHexParser,
+    charClassEscapeUnicodeParser,
+    charClassEscapeMetacharacterParser, // Must be last - matches any escaped char
+]);
+// Single character (not escape, not ], not -)
+const charClassLiteralParser = parserCreatorCompose(() => elementParser, char => async (parserContext) => {
+    parserContext.invariant(!charClassMetaCharacters.has(char), 'Unexpected character class metacharacter "%s"', char);
+    return characterSetSingleton(char);
+})();
+// Single char in character class (escape or literal) - returns the character string for range checking
+const charClassSingleCharParser = createUnionParser([
+    // Escape sequences that produce single chars
+    promiseCompose(createExactSequenceParser('\\n'), () => '\n'),
+    promiseCompose(createExactSequenceParser('\\r'), () => '\r'),
+    promiseCompose(createExactSequenceParser('\\t'), () => '\t'),
+    promiseCompose(createExactSequenceParser('\\f'), () => '\f'),
+    promiseCompose(createExactSequenceParser('\\v'), () => '\v'),
+    promiseCompose(createExactSequenceParser('\\0'), () => '\0'),
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('\\x'),
+        createFixedLengthSequenceParser(2),
+    ]), ([, hexCode]) => String.fromCharCode(Number.parseInt(hexCode, 16))),
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('\\u'),
+        createFixedLengthSequenceParser(4),
+    ]), ([, hexCode]) => String.fromCharCode(Number.parseInt(hexCode, 16))),
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('\\'),
+        elementParser,
+    ]), ([, char]) => char),
+    // Literal char (not metacharacter, not -)
+    parserCreatorCompose(() => elementParser, char => async (parserContext) => {
+        parserContext.invariant(!charClassMetaCharacters.has(char) && char !== '-', 'Unexpected character "%s"', char);
+        return char;
+    })(),
+]);
+// Character range (a-z)
+const charClassRangeParser = promiseCompose(createTupleParser([
+    charClassSingleCharParser,
+    createExactSequenceParser('-'),
+    charClassSingleCharParser,
+]), ([startChar, , endChar]) => characterSetCharRange(startChar, endChar));
+// Character class element: range, escape (for \d, \w, etc.), or single char
+const charClassElementParser = createDisjunctionParser([
+    charClassRangeParser,
+    charClassEscapeParser,
+    charClassLiteralParser,
+    // Literal hyphen at end or after negation
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('-'),
+        createNegativeLookaheadParser(createExactSequenceParser(']')),
+    ]), () => characterSetSingleton('-')),
+]);
+// Character class [...]
+const characterClassParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('['),
+    createOptionalParser(createExactSequenceParser('^')),
+    createTerminatedArrayParser(charClassElementParser, createExactSequenceParser(']')),
+]), ([, negation, [elements]]) => {
+    let charset = elements.reduce((acc, el) => characterSetUnion(acc, el), emptyCharacterSet);
+    if (negation !== undefined) {
+        charset = characterSetComplement(charset);
+    }
+    return literal(charset);
+});
+const starQuantifierParser = promiseCompose(createExactSequenceParser('*'), () => ({ type: 'star' }));
+const plusQuantifierParser = promiseCompose(createExactSequenceParser('+'), () => ({ type: 'plus' }));
+const optionalQuantifierParser = promiseCompose(createExactSequenceParser('?'), () => ({ type: 'optional' }));
+// Parse a number for quantifiers
+const numberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, char => async (parserContext) => {
+    parserContext.invariant(char >= '0' && char <= '9', 'Expected digit, got "%s"', char);
+    return char;
+})()), digits => async (parserContext) => {
+    parserContext.invariant(digits.length > 0, 'Expected at least one digit');
+    return Number.parseInt(digits.join(''), 10);
+})();
+// {n}, {n,}, {n,m}
+const braceQuantifierParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    numberParser,
+    createOptionalParser(createTupleParser([
+        createExactSequenceParser(','),
+        createOptionalParser(numberParser),
+    ])),
+    createExactSequenceParser('}'),
+]), ([, min, comma]) => {
+    if (comma === undefined) {
+        // {n} - exactly n
+        return { type: 'repeat', bounds: min };
+    }
+    const [, max] = comma;
+    if (max === undefined) {
+        // {n,} - at least n
+        return { type: 'repeat', bounds: { min } };
+    }
+    // {n,m} - between n and m
+    return { type: 'repeat', bounds: { min, max } };
+});
+const quantifierParser = createUnionParser([
+    starQuantifierParser,
+    plusQuantifierParser,
+    optionalQuantifierParser,
+    braceQuantifierParser,
+]);
+// Groups
+// Capture group (...)
+const captureGroupParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    createNegativeLookaheadParser(createExactSequenceParser('?')),
+    createParserAccessorParser(() => alternationParser),
+    createExactSequenceParser(')'),
+]), ([, , inner]) => captureGroup(inner));
+// Named capture group (?<name>...)
+const namedCaptureGroupParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('(?<'),
+    createTerminatedArrayParser(parserCreatorCompose(() => elementParser, char => async (parserContext) => {
+        parserContext.invariant(char !== '>', 'Unexpected ">"');
+        return char;
+    })(), createExactSequenceParser('>')),
+    createParserAccessorParser(() => alternationParser),
+    createExactSequenceParser(')'),
+]), ([, [nameChars], inner]) => captureGroup(inner, nameChars.join('')));
+// Non-capture group (?:...)
+const nonCaptureGroupParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('(?:'),
+    createParserAccessorParser(() => alternationParser),
+    createExactSequenceParser(')'),
+]), ([, inner]) => inner);
+// Positive lookahead (?=...)
+const positiveLookaheadMarkerParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('(?='),
+    createParserAccessorParser(() => alternationParser),
+    createExactSequenceParser(')'),
+]), ([, inner]) => ({ type: 'lookahead-marker', isPositive: true, inner }));
+// Negative lookahead (?!...)
+const negativeLookaheadMarkerParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('(?!'),
+    createParserAccessorParser(() => alternationParser),
+    createExactSequenceParser(')'),
+]), ([, inner]) => ({ type: 'lookahead-marker', isPositive: false, inner }));
+const groupParser = createUnionParser([
+    namedCaptureGroupParser,
+    nonCaptureGroupParser,
+    captureGroupParser,
+]);
+const startAnchorMarkerParser = promiseCompose(createExactSequenceParser('^'), () => ({ type: 'start-anchor-marker' }));
+const endAnchorMarkerParser = promiseCompose(createExactSequenceParser('$'), () => ({ type: 'end-anchor-marker' }));
+// Atom: the basic unit that can be quantified (excluding anchors)
+const atomParser = createUnionParser([
+    groupParser,
+    characterClassParser,
+    escapeParser,
+    dotParser,
+    literalCharacterParser,
+]);
+// Quantified atom
+const quantifiedParser = promiseCompose(createTupleParser([
+    atomParser,
+    createOptionalParser(quantifierParser),
+]), ([atom, quantifier]) => {
+    if (quantifier === undefined) {
+        return atom;
+    }
+    switch (quantifier.type) {
+        case 'star':
+            return star(atom);
+        case 'plus':
+            return plus(atom);
+        case 'optional':
+            return optional(atom);
+        case 'repeat':
+            return repeat(atom, quantifier.bounds);
+    }
+});
+// Element in a sequence: either a quantified atom, anchor marker, or lookahead marker
+const sequenceElementParser = createUnionParser([
+    startAnchorMarkerParser,
+    endAnchorMarkerParser,
+    positiveLookaheadMarkerParser,
+    negativeLookaheadMarkerParser,
+    quantifiedParser,
+]);
+// Helper to concatenate a list of RegularExpressions (right-associative)
+function concatList(parts) {
+    if (parts.length === 0) {
+        return epsilon;
+    }
+    return parts.reduceRight((acc, part) => concat(part, acc));
+}
+// Process elements with anchor markers and lookahead markers into proper AST
+// Handles anchors and lookahead as infix operators like @gruhn/regex-utils
+// Precedence order (lowest to highest): union -> start-anchor -> end-anchor -> lookahead -> concat
+function processElements(elements) {
+    if (elements.length === 0) {
+        return epsilon;
+    }
+    // Process start anchors first (lowest precedence among infix operators)
+    const startAnchorIdx = elements.findIndex(e => 'type' in e && e.type === 'start-anchor-marker');
+    if (startAnchorIdx !== -1) {
+        const left = elements.slice(0, startAnchorIdx);
+        const right = elements.slice(startAnchorIdx + 1);
+        return startAnchor(processElements(left), processElements(right));
+    }
+    // Then end anchors
+    const endAnchorIdx = elements.findIndex(e => 'type' in e && e.type === 'end-anchor-marker');
+    if (endAnchorIdx !== -1) {
+        const left = elements.slice(0, endAnchorIdx);
+        const right = elements.slice(endAnchorIdx + 1);
+        return endAnchor(processElements(left), processElements(right));
+    }
+    // Then lookaheads (higher precedence than anchors)
+    const lookaheadIdx = elements.findIndex(e => 'type' in e && e.type === 'lookahead-marker');
+    if (lookaheadIdx !== -1) {
+        const marker = elements[lookaheadIdx];
+        const left = elements.slice(0, lookaheadIdx);
+        const right = elements.slice(lookaheadIdx + 1);
+        const lookaheadExpr = lookahead(marker.isPositive, marker.inner, processElements(right));
+        if (left.length === 0) {
+            return lookaheadExpr;
+        }
+        // If there's content before the lookahead, concatenate it
+        return concat(processElements(left), lookaheadExpr);
+    }
+    // No markers, just regular expressions - concatenate them
+    const regexParts = elements;
+    return concatList(regexParts);
+}
+// Concatenation: sequence of quantified atoms and anchors
+const concatParser = promiseCompose(createArrayParser(sequenceElementParser), processElements);
+// Alternation: concat ('|' concat)*
+const alternationParser = promiseCompose(createTupleParser([
+    concatParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('|'),
+        concatParser,
+    ]), ([, right]) => right)),
+]), ([first, rest]) => {
+    // Right-associative union like @gruhn/regex-utils
+    const allParts = [first, ...rest];
+    return allParts.reduceRight((acc, part) => union(part, acc));
+});
+export const regularExpressionParser = alternationParser;

package/build/regularExpressionParser.test.d.ts

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

package/build/regularExpressionParser.test.js

@@ -0,0 +1,89 @@
+import { testProp, fc } from '@fast-check/ava';
+import { regularExpressionParser } from './regularExpressionParser.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+// Import directly from file path to bypass package exports
+// eslint-disable-next-line import/no-unresolved
+import { parseRegExpString } from '../node_modules/@gruhn/regex-utils/dist/regex-parser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
+// Normalize AST for comparison - removes hashes from CharSets and normalizes structure
+function normalizeCharacterSet(charset) {
+    if (charset.type === 'empty') {
+        return { type: 'empty' };
+    }
+    return {
+        type: 'node',
+        range: { start: charset.range.start, end: charset.range.end },
+        left: normalizeCharacterSet(charset.left),
+        right: normalizeCharacterSet(charset.right),
+    };
+}
+function normalizeRegularExpression(ast) {
+    switch (ast.type) {
+        case 'epsilon':
+            return { type: 'epsilon' };
+        case 'literal':
+            return { type: 'literal', charset: normalizeCharacterSet(ast.charset) };
+        case 'concat':
+            return { type: 'concat', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+        case 'union':
+            return { type: 'union', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+        case 'star':
+            return { type: 'star', inner: normalizeRegularExpression(ast.inner) };
+        case 'plus':
+            return { type: 'plus', inner: normalizeRegularExpression(ast.inner) };
+        case 'optional':
+            return { type: 'optional', inner: normalizeRegularExpression(ast.inner) };
+        case 'repeat':
+            return { type: 'repeat', inner: normalizeRegularExpression(ast.inner), bounds: ast.bounds };
+        case 'capture-group':
+            if (ast.name !== undefined) {
+                return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner), name: ast.name };
+            }
+            return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner) };
+        case 'lookahead':
+            return { type: 'lookahead', isPositive: ast.isPositive, inner: normalizeRegularExpression(ast.inner), right: normalizeRegularExpression(ast.right) };
+        case 'start-anchor':
+            return { type: 'start-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+        case 'end-anchor':
+            return { type: 'end-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+    }
+}
+// Generate regex patterns that are likely to be supported
+const supportedRegexArbitrary = fc.stringMatching(/^([a-zA-Z0-9]|\\[dDwWsS.]|\[(\^)?([a-zA-Z0-9](-[a-zA-Z0-9])?|\\[dDwWsS])*\]|\.|\((\?[:=!])?[a-zA-Z0-9]*\)|[*+?]|\{[0-9]+(,[0-9]*)?\}|\||\^|\$)*$/).filter(s => {
+    // Filter out patterns that JavaScript doesn't support
+    try {
+        new RegExp(s);
+    }
+    catch {
+        return false;
+    }
+    // Filter out patterns that @gruhn/regex-utils doesn't support
+    try {
+        parseRegExpString(s);
+    }
+    catch {
+        return false;
+    }
+    // Filter out quantified lookaheads - @gruhn/regex-utils has a bug where it treats
+    // quantifiers after lookaheads as literals instead of quantifiers.
+    // See: https://github.com/gruhn/regex-utils/issues/13
+    // JavaScript allows (?=a){2} but @gruhn/regex-utils parses {2} as literal text.
+    if (/\(\?[=!][^)]*\)[*+?]|\(\?[=!][^)]*\)\{[0-9]/.test(s)) {
+        return false;
+    }
+    return true;
+});
+testProp('regularExpressionParser matches @gruhn/regex-utils', [
+    arbitrarilySlicedAsyncIterator(supportedRegexArbitrary),
+], async (t, [regexStr, regexStringChunkIterator]) => {
+    const expected = normalizeRegularExpression(parseRegExpString(regexStr));
+    const actual = normalizeRegularExpression(await runParser(regularExpressionParser, regexStringChunkIterator, stringParserInputCompanion, {
+        errorJoinMode: 'none',
+    }));
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+    seed,
+});