@eslint-community/regexpp 4.11.2 → 4.12.1

package/index.d.ts

@@ -51,6 +51,7 @@ declare module "@eslint-community/regexpp/ast" {
     | ExpressionCharacterClass
     | Group
     | LookaroundAssertion
+    | Modifiers
     | Pattern
     | Quantifier
     | RegExpLiteral
@@ -63,7 +64,8 @@ declare module "@eslint-community/regexpp/ast" {
     | BoundaryAssertion
     | Character
     | CharacterSet
-    | Flags;
+    | Flags
+    | ModifierFlags;
   /**
    * The type which includes all atom nodes.
    */
@@ -147,6 +149,7 @@ declare module "@eslint-community/regexpp/ast" {
   export interface Group extends NodeBase {
     type: "Group";
     parent: Alternative | Quantifier;
+    modifiers: Modifiers | null;
     alternatives: Alternative[];
   }
   /**
@@ -447,6 +450,34 @@ declare module "@eslint-community/regexpp/ast" {
     ambiguous: false;
     resolved: CapturingGroup;
   }
+  /**
+   * The modifiers.
+   */
+  export interface Modifiers extends NodeBase {
+    type: "Modifiers";
+    parent: Group;
+    /**
+     * The add modifier flags.
+     */
+    add: ModifierFlags;
+    /**
+     * The remove modifier flags.
+     *
+     * `null` means no remove modifier flags. e.g. `(?ims:x)`
+     * The reason for `null` is that there is no position where the remove modifier flags appears. Must be behind the minus mark.
+     */
+    remove: ModifierFlags | null;
+  }
+  /**
+   * The modifier flags.
+   */
+  export interface ModifierFlags extends NodeBase {
+    type: "ModifierFlags";
+    parent: Modifiers;
+    dotAll: boolean;
+    ignoreCase: boolean;
+    multiline: boolean;
+  }
   /**
    * The flags.
    */
@@ -490,7 +521,7 @@ declare module "@eslint-community/regexpp/parser" {
        * - `2022` added `d` flag.
        * - `2023` added more valid Unicode Property Escapes.
        * - `2024` added `v` flag.
-       * - `2025` added duplicate named capturing groups.
+       * - `2025` added duplicate named capturing groups, modifiers.
        */
       ecmaVersion?: EcmaVersion;
     }
@@ -579,7 +610,7 @@ declare module "@eslint-community/regexpp/validator" {
        * - `2022` added `d` flag.
        * - `2023` added more valid Unicode Property Escapes.
        * - `2024` added `v` flag.
-       * - `2025` added duplicate named capturing groups.
+       * - `2025` added duplicate named capturing groups, modifiers.
        */
       ecmaVersion?: EcmaVersion;
       /**
@@ -691,6 +722,53 @@ declare module "@eslint-community/regexpp/validator" {
        * @param end The next 0-based index of the last character.
        */
       onGroupLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator entered a modifiers.
+       * @param start The 0-based index of the first character.
+       */
+      onModifiersEnter?: (start: number) => void;
+      /**
+       * A function that is called when the validator left a modifiers.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       */
+      onModifiersLeave?: (start: number, end: number) => void;
+      /**
+       * A function that is called when the validator found an add modifiers.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param flags flags.
+       * @param flags.ignoreCase `i` flag.
+       * @param flags.multiline `m` flag.
+       * @param flags.dotAll `s` flag.
+       */
+      onAddModifiers?: (
+        start: number,
+        end: number,
+        flags: {
+          ignoreCase: boolean;
+          multiline: boolean;
+          dotAll: boolean;
+        }
+      ) => void;
+      /**
+       * A function that is called when the validator found a remove modifiers.
+       * @param start The 0-based index of the first character.
+       * @param end The next 0-based index of the last character.
+       * @param flags flags.
+       * @param flags.ignoreCase `i` flag.
+       * @param flags.multiline `m` flag.
+       * @param flags.dotAll `s` flag.
+       */
+      onRemoveModifiers?: (
+        start: number,
+        end: number,
+        flags: {
+          ignoreCase: boolean;
+          multiline: boolean;
+          dotAll: boolean;
+        }
+      ) => void;
       /**
        * A function that is called when the validator entered a capturing group.
        * @param start The 0-based index of the first character.
@@ -977,6 +1055,8 @@ declare module "@eslint-community/regexpp/visitor" {
     ExpressionCharacterClass,
     Flags,
     Group,
+    ModifierFlags,
+    Modifiers,
     Node,
     Pattern,
     Quantifier,
@@ -1032,6 +1112,10 @@ declare module "@eslint-community/regexpp/visitor" {
       onFlagsLeave?: (node: Flags) => void;
       onGroupEnter?: (node: Group) => void;
       onGroupLeave?: (node: Group) => void;
+      onModifierFlagsEnter?: (node: ModifierFlags) => void;
+      onModifierFlagsLeave?: (node: ModifierFlags) => void;
+      onModifiersEnter?: (node: Modifiers) => void;
+      onModifiersLeave?: (node: Modifiers) => void;
       onPatternEnter?: (node: Pattern) => void;
       onPatternLeave?: (node: Pattern) => void;
       onQuantifierEnter?: (node: Quantifier) => void;

package/index.js

@@ -552,6 +552,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);
 }
@@ -579,6 +590,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();
@@ -649,64 +665,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;
@@ -801,6 +761,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);
@@ -1173,8 +1153,8 @@ class RegExpValidator {
             this.consumeDot() ||
             this.consumeReverseSolidusAtomEscape() ||
             Boolean(this.consumeCharacterClass()) ||
-            this.consumeUncapturingGroup() ||
-            this.consumeCapturingGroup());
+            this.consumeCapturingGroup() ||
+            this.consumeUncapturingGroup());
     }
     consumeDot() {
         if (this.eat(FULL_STOP)) {
@@ -1195,8 +1175,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");
@@ -1206,6 +1193,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)) {
@@ -1214,9 +1230,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();
@@ -1233,8 +1254,8 @@ class RegExpValidator {
             this.consumeReverseSolidusAtomEscape() ||
             this.consumeReverseSolidusFollowedByC() ||
             Boolean(this.consumeCharacterClass()) ||
-            this.consumeUncapturingGroup() ||
             this.consumeCapturingGroup() ||
+            this.consumeUncapturingGroup() ||
             this.consumeInvalidBracedQuantifier() ||
             this.consumeExtendedPatternCharacter());
     }
@@ -1287,6 +1308,7 @@ class RegExpValidator {
         return false;
     }
     consumeGroupSpecifier() {
+        const start = this.index;
         if (this.eat(QUESTION_MARK)) {
             if (this.eatGroupName()) {
                 if (!this._groupSpecifiers.hasInScope(this._lastStrValue)) {
@@ -1295,7 +1317,7 @@ class RegExpValidator {
                 }
                 this.raise("Duplicate capture group name");
             }
-            this.raise("Invalid group");
+            this.rewind(start);
         }
         return false;
     }
@@ -2043,6 +2065,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 >= 2022) {
+                    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 = {};
@@ -2162,14 +2241,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) {
@@ -2181,6 +2262,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") {
@@ -2666,6 +2804,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;
@@ -2804,11 +2948,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);