@eslint-community/regexpp 4.11.2 → 4.12.0

package/index.mjs

@@ -548,6 +548,17 @@ const CLASS_SET_RESERVED_PUNCTUATOR = new Set([
     GRAVE_ACCENT,
     TILDE,
 ]);
+const FLAG_PROP_TO_CODEPOINT = {
+    global: LATIN_SMALL_LETTER_G,
+    ignoreCase: LATIN_SMALL_LETTER_I,
+    multiline: LATIN_SMALL_LETTER_M,
+    unicode: LATIN_SMALL_LETTER_U,
+    sticky: LATIN_SMALL_LETTER_Y,
+    dotAll: LATIN_SMALL_LETTER_S,
+    hasIndices: LATIN_SMALL_LETTER_D,
+    unicodeSets: LATIN_SMALL_LETTER_V,
+};
+const FLAG_CODEPOINT_TO_PROP = Object.fromEntries(Object.entries(FLAG_PROP_TO_CODEPOINT).map(([k, v]) => [v, k]));
 function isSyntaxCharacter(cp) {
     return SYNTAX_CHARACTER.has(cp);
 }
@@ -575,6 +586,11 @@ function isUnicodePropertyNameCharacter(cp) {
 function isUnicodePropertyValueCharacter(cp) {
     return isUnicodePropertyNameCharacter(cp) || isDecimalDigit(cp);
 }
+function isRegularExpressionModifier(ch) {
+    return (ch === LATIN_SMALL_LETTER_I ||
+        ch === LATIN_SMALL_LETTER_M ||
+        ch === LATIN_SMALL_LETTER_S);
+}
 class RegExpValidator {
     constructor(options) {
         this._reader = new Reader();
@@ -645,64 +661,8 @@ class RegExpValidator {
         }
     }
     validateFlagsInternal(source, start, end) {
-        const existingFlags = new Set();
-        let global = false;
-        let ignoreCase = false;
-        let multiline = false;
-        let sticky = false;
-        let unicode = false;
-        let dotAll = false;
-        let hasIndices = false;
-        let unicodeSets = false;
-        for (let i = start; i < end; ++i) {
-            const flag = source.charCodeAt(i);
-            if (existingFlags.has(flag)) {
-                this.raise(`Duplicated flag '${source[i]}'`, { index: start });
-            }
-            existingFlags.add(flag);
-            if (flag === LATIN_SMALL_LETTER_G) {
-                global = true;
-            }
-            else if (flag === LATIN_SMALL_LETTER_I) {
-                ignoreCase = true;
-            }
-            else if (flag === LATIN_SMALL_LETTER_M) {
-                multiline = true;
-            }
-            else if (flag === LATIN_SMALL_LETTER_U &&
-                this.ecmaVersion >= 2015) {
-                unicode = true;
-            }
-            else if (flag === LATIN_SMALL_LETTER_Y &&
-                this.ecmaVersion >= 2015) {
-                sticky = true;
-            }
-            else if (flag === LATIN_SMALL_LETTER_S &&
-                this.ecmaVersion >= 2018) {
-                dotAll = true;
-            }
-            else if (flag === LATIN_SMALL_LETTER_D &&
-                this.ecmaVersion >= 2022) {
-                hasIndices = true;
-            }
-            else if (flag === LATIN_SMALL_LETTER_V &&
-                this.ecmaVersion >= 2024) {
-                unicodeSets = true;
-            }
-            else {
-                this.raise(`Invalid flag '${source[i]}'`, { index: start });
-            }
-        }
-        this.onRegExpFlags(start, end, {
-            global,
-            ignoreCase,
-            multiline,
-            unicode,
-            sticky,
-            dotAll,
-            hasIndices,
-            unicodeSets,
-        });
+        const flags = this.parseFlags(source, start, end);
+        this.onRegExpFlags(start, end, flags);
     }
     _parseFlagsOptionToMode(uFlagOrFlags, sourceEnd) {
         let unicode = false;
@@ -797,6 +757,26 @@ class RegExpValidator {
             this._options.onGroupLeave(start, end);
         }
     }
+    onModifiersEnter(start) {
+        if (this._options.onModifiersEnter) {
+            this._options.onModifiersEnter(start);
+        }
+    }
+    onModifiersLeave(start, end) {
+        if (this._options.onModifiersLeave) {
+            this._options.onModifiersLeave(start, end);
+        }
+    }
+    onAddModifiers(start, end, flags) {
+        if (this._options.onAddModifiers) {
+            this._options.onAddModifiers(start, end, flags);
+        }
+    }
+    onRemoveModifiers(start, end, flags) {
+        if (this._options.onRemoveModifiers) {
+            this._options.onRemoveModifiers(start, end, flags);
+        }
+    }
     onCapturingGroupEnter(start, name) {
         if (this._options.onCapturingGroupEnter) {
             this._options.onCapturingGroupEnter(start, name);
@@ -1169,8 +1149,8 @@ class RegExpValidator {
             this.consumeDot() ||
             this.consumeReverseSolidusAtomEscape() ||
             Boolean(this.consumeCharacterClass()) ||
-            this.consumeUncapturingGroup() ||
-            this.consumeCapturingGroup());
+            this.consumeCapturingGroup() ||
+            this.consumeUncapturingGroup());
     }
     consumeDot() {
         if (this.eat(FULL_STOP)) {
@@ -1191,8 +1171,15 @@ class RegExpValidator {
     }
     consumeUncapturingGroup() {
         const start = this.index;
-        if (this.eat3(LEFT_PARENTHESIS, QUESTION_MARK, COLON)) {
+        if (this.eat2(LEFT_PARENTHESIS, QUESTION_MARK)) {
             this.onGroupEnter(start);
+            if (this.ecmaVersion >= 2025) {
+                this.consumeModifiers();
+            }
+            if (!this.eat(COLON)) {
+                this.rewind(start + 1);
+                this.raise("Invalid group");
+            }
             this.consumeDisjunction();
             if (!this.eat(RIGHT_PARENTHESIS)) {
                 this.raise("Unterminated group");
@@ -1202,6 +1189,35 @@ class RegExpValidator {
         }
         return false;
     }
+    consumeModifiers() {
+        const start = this.index;
+        const hasAddModifiers = this.eatModifiers();
+        const addModifiersEnd = this.index;
+        const hasHyphen = this.eat(HYPHEN_MINUS);
+        if (!hasAddModifiers && !hasHyphen) {
+            return false;
+        }
+        this.onModifiersEnter(start);
+        const addModifiers = this.parseModifiers(start, addModifiersEnd);
+        this.onAddModifiers(start, addModifiersEnd, addModifiers);
+        if (hasHyphen) {
+            const modifiersStart = this.index;
+            if (!this.eatModifiers() &&
+                !hasAddModifiers &&
+                this.currentCodePoint === COLON) {
+                this.raise("Invalid empty flags");
+            }
+            const modifiers = this.parseModifiers(modifiersStart, this.index);
+            for (const [flagName] of Object.entries(modifiers).filter(([, enable]) => enable)) {
+                if (addModifiers[flagName]) {
+                    this.raise(`Duplicated flag '${String.fromCodePoint(FLAG_PROP_TO_CODEPOINT[flagName])}'`);
+                }
+            }
+            this.onRemoveModifiers(modifiersStart, this.index, modifiers);
+        }
+        this.onModifiersLeave(start, this.index);
+        return true;
+    }
     consumeCapturingGroup() {
         const start = this.index;
         if (this.eat(LEFT_PARENTHESIS)) {
@@ -1210,9 +1226,14 @@ class RegExpValidator {
                 if (this.consumeGroupSpecifier()) {
                     name = this._lastStrValue;
                 }
+                else if (this.currentCodePoint === QUESTION_MARK) {
+                    this.rewind(start);
+                    return false;
+                }
             }
             else if (this.currentCodePoint === QUESTION_MARK) {
-                this.raise("Invalid group");
+                this.rewind(start);
+                return false;
             }
             this.onCapturingGroupEnter(start, name);
             this.consumeDisjunction();
@@ -1229,8 +1250,8 @@ class RegExpValidator {
             this.consumeReverseSolidusAtomEscape() ||
             this.consumeReverseSolidusFollowedByC() ||
             Boolean(this.consumeCharacterClass()) ||
-            this.consumeUncapturingGroup() ||
             this.consumeCapturingGroup() ||
+            this.consumeUncapturingGroup() ||
             this.consumeInvalidBracedQuantifier() ||
             this.consumeExtendedPatternCharacter());
     }
@@ -1283,6 +1304,7 @@ class RegExpValidator {
         return false;
     }
     consumeGroupSpecifier() {
+        const start = this.index;
         if (this.eat(QUESTION_MARK)) {
             if (this.eatGroupName()) {
                 if (!this._groupSpecifiers.hasInScope(this._lastStrValue)) {
@@ -1291,7 +1313,7 @@ class RegExpValidator {
                 }
                 this.raise("Duplicate capture group name");
             }
-            this.raise("Invalid group");
+            this.rewind(start);
         }
         return false;
     }
@@ -2039,6 +2061,63 @@ class RegExpValidator {
         }
         return true;
     }
+    eatModifiers() {
+        let ate = false;
+        while (isRegularExpressionModifier(this.currentCodePoint)) {
+            this.advance();
+            ate = true;
+        }
+        return ate;
+    }
+    parseModifiers(start, end) {
+        const { ignoreCase, multiline, dotAll } = this.parseFlags(this._reader.source, start, end);
+        return { ignoreCase, multiline, dotAll };
+    }
+    parseFlags(source, start, end) {
+        const flags = {
+            global: false,
+            ignoreCase: false,
+            multiline: false,
+            unicode: false,
+            sticky: false,
+            dotAll: false,
+            hasIndices: false,
+            unicodeSets: false,
+        };
+        const validFlags = new Set();
+        validFlags.add(LATIN_SMALL_LETTER_G);
+        validFlags.add(LATIN_SMALL_LETTER_I);
+        validFlags.add(LATIN_SMALL_LETTER_M);
+        if (this.ecmaVersion >= 2015) {
+            validFlags.add(LATIN_SMALL_LETTER_U);
+            validFlags.add(LATIN_SMALL_LETTER_Y);
+            if (this.ecmaVersion >= 2018) {
+                validFlags.add(LATIN_SMALL_LETTER_S);
+                if (this.ecmaVersion >= 2021) {
+                    validFlags.add(LATIN_SMALL_LETTER_D);
+                    if (this.ecmaVersion >= 2024) {
+                        validFlags.add(LATIN_SMALL_LETTER_V);
+                    }
+                }
+            }
+        }
+        for (let i = start; i < end; ++i) {
+            const flag = source.charCodeAt(i);
+            if (validFlags.has(flag)) {
+                const prop = FLAG_CODEPOINT_TO_PROP[flag];
+                if (flags[prop]) {
+                    this.raise(`Duplicated flag '${source[i]}'`, {
+                        index: start,
+                    });
+                }
+                flags[prop] = true;
+            }
+            else {
+                this.raise(`Invalid flag '${source[i]}'`, { index: start });
+            }
+        }
+        return flags;
+    }
 }
 
 const DUMMY_PATTERN = {};
@@ -2158,14 +2237,16 @@ class RegExpParserState {
         if (parent.type !== "Alternative") {
             throw new Error("UnknownError");
         }
-        this._node = {
+        const group = {
             type: "Group",
             parent,
             start,
             end: start,
             raw: "",
+            modifiers: null,
             alternatives: [],
         };
+        this._node = group;
         parent.elements.push(this._node);
     }
     onGroupLeave(start, end) {
@@ -2177,6 +2258,63 @@ class RegExpParserState {
         node.raw = this.source.slice(start, end);
         this._node = node.parent;
     }
+    onModifiersEnter(start) {
+        const parent = this._node;
+        if (parent.type !== "Group") {
+            throw new Error("UnknownError");
+        }
+        this._node = {
+            type: "Modifiers",
+            parent,
+            start,
+            end: start,
+            raw: "",
+            add: null,
+            remove: null,
+        };
+        parent.modifiers = this._node;
+    }
+    onModifiersLeave(start, end) {
+        const node = this._node;
+        if (node.type !== "Modifiers" || node.parent.type !== "Group") {
+            throw new Error("UnknownError");
+        }
+        node.end = end;
+        node.raw = this.source.slice(start, end);
+        this._node = node.parent;
+    }
+    onAddModifiers(start, end, { ignoreCase, multiline, dotAll, }) {
+        const parent = this._node;
+        if (parent.type !== "Modifiers") {
+            throw new Error("UnknownError");
+        }
+        parent.add = {
+            type: "ModifierFlags",
+            parent,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            ignoreCase,
+            multiline,
+            dotAll,
+        };
+    }
+    onRemoveModifiers(start, end, { ignoreCase, multiline, dotAll, }) {
+        const parent = this._node;
+        if (parent.type !== "Modifiers") {
+            throw new Error("UnknownError");
+        }
+        parent.remove = {
+            type: "ModifierFlags",
+            parent,
+            start,
+            end,
+            raw: this.source.slice(start, end),
+            ignoreCase,
+            multiline,
+            dotAll,
+        };
+    }
     onCapturingGroupEnter(start, name) {
         const parent = this._node;
         if (parent.type !== "Alternative") {
@@ -2662,6 +2800,12 @@ class RegExpVisitor {
             case "Group":
                 this.visitGroup(node);
                 break;
+            case "Modifiers":
+                this.visitModifiers(node);
+                break;
+            case "ModifierFlags":
+                this.visitModifierFlags(node);
+                break;
             case "Pattern":
                 this.visitPattern(node);
                 break;
@@ -2800,11 +2944,36 @@ class RegExpVisitor {
         if (this._handlers.onGroupEnter) {
             this._handlers.onGroupEnter(node);
         }
+        if (node.modifiers) {
+            this.visit(node.modifiers);
+        }
         node.alternatives.forEach(this.visit, this);
         if (this._handlers.onGroupLeave) {
             this._handlers.onGroupLeave(node);
         }
     }
+    visitModifiers(node) {
+        if (this._handlers.onModifiersEnter) {
+            this._handlers.onModifiersEnter(node);
+        }
+        if (node.add) {
+            this.visit(node.add);
+        }
+        if (node.remove) {
+            this.visit(node.remove);
+        }
+        if (this._handlers.onModifiersLeave) {
+            this._handlers.onModifiersLeave(node);
+        }
+    }
+    visitModifierFlags(node) {
+        if (this._handlers.onModifierFlagsEnter) {
+            this._handlers.onModifierFlagsEnter(node);
+        }
+        if (this._handlers.onModifierFlagsLeave) {
+            this._handlers.onModifierFlagsLeave(node);
+        }
+    }
     visitPattern(node) {
         if (this._handlers.onPatternEnter) {
             this._handlers.onPatternEnter(node);