@eslint-community/regexpp 4.10.1 → 4.11.0

package/index.mjs

@@ -2,7 +2,7 @@ var ast = /*#__PURE__*/Object.freeze({
     __proto__: null
 });
 
-const latestEcmaVersion = 2024;
+const latestEcmaVersion = 2025;
 
 let largeIdStartRanges = undefined;
 let largeIdContinueRanges = undefined;
@@ -260,6 +260,103 @@ function combineSurrogatePair(lead, trail) {
     return (lead - 0xd800) * 0x400 + (trail - 0xdc00) + 0x10000;
 }
 
+class GroupSpecifiersAsES2018 {
+    constructor() {
+        this.groupName = new Set();
+    }
+    clear() {
+        this.groupName.clear();
+    }
+    isEmpty() {
+        return !this.groupName.size;
+    }
+    hasInPattern(name) {
+        return this.groupName.has(name);
+    }
+    hasInScope(name) {
+        return this.hasInPattern(name);
+    }
+    addToScope(name) {
+        this.groupName.add(name);
+    }
+    enterDisjunction() {
+    }
+    enterAlternative() {
+    }
+    leaveDisjunction() {
+    }
+}
+class BranchID {
+    constructor(parent, base) {
+        this.parent = parent;
+        this.base = base !== null && base !== void 0 ? base : this;
+    }
+    separatedFrom(other) {
+        var _a, _b;
+        if (this.base === other.base && this !== other) {
+            return true;
+        }
+        if (other.parent && this.separatedFrom(other.parent)) {
+            return true;
+        }
+        return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.separatedFrom(other)) !== null && _b !== void 0 ? _b : false;
+    }
+    child() {
+        return new BranchID(this, null);
+    }
+    sibling() {
+        return new BranchID(this.parent, this.base);
+    }
+}
+class GroupSpecifiersAsES2025 {
+    constructor() {
+        this.branchID = new BranchID(null, null);
+        this.groupNames = new Map();
+    }
+    clear() {
+        this.branchID = new BranchID(null, null);
+        this.groupNames.clear();
+    }
+    isEmpty() {
+        return !this.groupNames.size;
+    }
+    enterDisjunction() {
+        this.branchID = this.branchID.child();
+    }
+    enterAlternative(index) {
+        if (index === 0) {
+            return;
+        }
+        this.branchID = this.branchID.sibling();
+    }
+    leaveDisjunction() {
+        this.branchID = this.branchID.parent;
+    }
+    hasInPattern(name) {
+        return this.groupNames.has(name);
+    }
+    hasInScope(name) {
+        const branches = this.groupNames.get(name);
+        if (!branches) {
+            return false;
+        }
+        for (const branch of branches) {
+            if (!branch.separatedFrom(this.branchID)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    addToScope(name) {
+        const branches = this.groupNames.get(name);
+        if (branches) {
+            branches.push(this.branchID);
+            return;
+        }
+        this.groupNames.set(name, [this.branchID]);
+    }
+}
+
 const legacyImpl = {
     at(s, end, i) {
         return i < end ? s.charCodeAt(i) : -1;
@@ -492,10 +589,13 @@ class RegExpValidator {
         this._lastStrValue = "";
         this._lastAssertionIsQuantifiable = false;
         this._numCapturingParens = 0;
-        this._groupNames = new Set();
         this._backreferenceNames = new Set();
         this._srcCtx = null;
         this._options = options !== null && options !== void 0 ? options : {};
+        this._groupSpecifiers =
+            this.ecmaVersion >= 2025
+                ? new GroupSpecifiersAsES2025()
+                : new GroupSpecifiersAsES2018();
     }
     validateLiteral(source, start = 0, end = source.length) {
         this._srcCtx = { source, start, end, kind: "literal" };
@@ -538,7 +638,7 @@ class RegExpValidator {
         this.consumePattern();
         if (!this._nFlag &&
             this.ecmaVersion >= 2018 &&
-            this._groupNames.size > 0) {
+            !this._groupSpecifiers.isEmpty()) {
             this._nFlag = true;
             this.rewind(start);
             this.consumePattern();
@@ -875,7 +975,7 @@ class RegExpValidator {
     consumePattern() {
         const start = this.index;
         this._numCapturingParens = this.countCapturingParens();
-        this._groupNames.clear();
+        this._groupSpecifiers.clear();
         this._backreferenceNames.clear();
         this.onPatternEnter(start);
         this.consumeDisjunction();
@@ -894,7 +994,7 @@ class RegExpValidator {
             this.raise(`Unexpected character '${c}'`);
         }
         for (const name of this._backreferenceNames) {
-            if (!this._groupNames.has(name)) {
+            if (!this._groupSpecifiers.hasInPattern(name)) {
                 this.raise("Invalid named capture referenced");
             }
         }
@@ -935,6 +1035,7 @@ class RegExpValidator {
     consumeDisjunction() {
         const start = this.index;
         let i = 0;
+        this._groupSpecifiers.enterDisjunction();
         this.onDisjunctionEnter(start);
         do {
             this.consumeAlternative(i++);
@@ -946,9 +1047,11 @@ class RegExpValidator {
             this.raise("Lone quantifier brackets");
         }
         this.onDisjunctionLeave(start, this.index);
+        this._groupSpecifiers.leaveDisjunction();
     }
     consumeAlternative(i) {
         const start = this.index;
+        this._groupSpecifiers.enterAlternative(i);
         this.onAlternativeEnter(start, i);
         while (this.currentCodePoint !== -1 && this.consumeTerm()) {
         }
@@ -1182,8 +1285,8 @@ class RegExpValidator {
     consumeGroupSpecifier() {
         if (this.eat(QUESTION_MARK)) {
             if (this.eatGroupName()) {
-                if (!this._groupNames.has(this._lastStrValue)) {
-                    this._groupNames.add(this._lastStrValue);
+                if (!this._groupSpecifiers.hasInScope(this._lastStrValue)) {
+                    this._groupSpecifiers.addToScope(this._lastStrValue);
                     return true;
                 }
                 this.raise("Duplicate capture group name");
@@ -2006,11 +2109,21 @@ class RegExpParserState {
         this._node.raw = this.source.slice(start, end);
         for (const reference of this._backreferences) {
             const ref = reference.ref;
-            const group = typeof ref === "number"
-                ? this._capturingGroups[ref - 1]
-                : this._capturingGroups.find((g) => g.name === ref);
-            reference.resolved = group;
-            group.references.push(reference);
+            const groups = typeof ref === "number"
+                ? [this._capturingGroups[ref - 1]]
+                : this._capturingGroups.filter((g) => g.name === ref);
+            if (groups.length === 1) {
+                const group = groups[0];
+                reference.ambiguous = false;
+                reference.resolved = group;
+            }
+            else {
+                reference.ambiguous = true;
+                reference.resolved = groups;
+            }
+            for (const group of groups) {
+                group.references.push(reference);
+            }
         }
     }
     onAlternativeEnter(start) {
@@ -2256,6 +2369,7 @@ class RegExpParserState {
             end,
             raw: this.source.slice(start, end),
             ref,
+            ambiguous: false,
             resolved: DUMMY_CAPTURING_GROUP,
         };
         parent.elements.push(node);