Updated refa, regex-ast-analysis, and scslre (#518)

* Updated dep

* Use new APIs

* Use new `getClosestAncestor`

Author: RunDevelopment

lib/rules/no-dupe-disjunctions.ts

@@ -303,7 +303,7 @@ function unionAll(nfas: readonly ReadonlyNFA[]): ReadonlyNFA {
     return total
 }
 
-const DFA_OPTIONS: DFA.CreationOptions = { maxNodes: 100_000 }
+const MAX_DFA_NODES = 100_000
 
 /**
  * Returns whether one NFA is a subset of another.
@@ -313,8 +313,12 @@ function isSubsetOf(
     subset: ReadonlyNFA,
 ): boolean | null {
     try {
-        const a = DFA.fromIntersection(superset, subset, DFA_OPTIONS)
-        const b = DFA.fromFA(subset, DFA_OPTIONS)
+        const a = DFA.fromIntersection(
+            superset,
+            subset,
+            new DFA.LimitedNodeFactory(MAX_DFA_NODES),
+        )
+        const b = DFA.fromFA(subset, new DFA.LimitedNodeFactory(MAX_DFA_NODES))
         a.minimize()
         b.minimize()
         return a.structurallyEqual(b)
@@ -339,13 +343,17 @@ function getSubsetRelation(
     right: ReadonlyNFA,
 ): SubsetRelation {
     try {
-        const inter = DFA.fromIntersection(left, right, DFA_OPTIONS)
+        const inter = DFA.fromIntersection(
+            left,
+            right,
+            new DFA.LimitedNodeFactory(MAX_DFA_NODES),
+        )
         inter.minimize()
 
-        const l = DFA.fromFA(left, DFA_OPTIONS)
+        const l = DFA.fromFA(left, new DFA.LimitedNodeFactory(MAX_DFA_NODES))
         l.minimize()
 
-        const r = DFA.fromFA(right, DFA_OPTIONS)
+        const r = DFA.fromFA(right, new DFA.LimitedNodeFactory(MAX_DFA_NODES))
         r.minimize()
 
         const subset = l.structurallyEqual(inter)

lib/rules/require-unicode-regexp.ts

@@ -211,7 +211,7 @@ function isCompatibleQuantifier(
         return false
     }
 
-    if (!rangeEqual(cs.ranges, uCs.without([ASTRAL]).ranges)) {
+    if (!rangeEqual(cs.ranges, uCs.without(ASTRAL).ranges)) {
         // failed condition 3
         return false
     }

lib/rules/sort-alternatives.ts

@@ -198,13 +198,11 @@ function getLexicographicallySmallestFromAlternative(
         const nfa = NFA.fromRegex(
             expression,
             { maxCharacter: result.maxCharacter },
-            { maxNodes: 1000 },
+            {},
+            new NFA.LimitedNodeFactory(1000),
         )
 
-        return getLexicographicallySmallestFromNfa(
-            nfa.nodes.initial,
-            nfa.nodes.finals,
-        )
+        return getLexicographicallySmallestFromNfa(nfa.initial, nfa.finals)
     } catch (_error) {
         return undefined
     }

lib/utils/fix-simplify-quantifier.ts

@@ -1,7 +1,6 @@
 import type { Rule } from "eslint"
-import type { ClosestAncestor } from "regexp-ast-analysis"
 import { getClosestAncestor } from "regexp-ast-analysis"
-import type { Node, Quantifier } from "@eslint-community/regexpp/ast"
+import type { Quantifier } from "@eslint-community/regexpp/ast"
 import type { RegExpContext } from "."
 import { quantToString } from "."
 import type { CanSimplify } from "./regexp-ast/simplify-quantifier"
@@ -14,10 +13,7 @@ export function fixSimplifyQuantifier(
     result: CanSimplify,
     { fixReplaceNode }: RegExpContext,
 ): [replacement: string, fix: (fixer: Rule.RuleFixer) => Rule.Fix | null] {
-    const ancestor = getClosestAncestorOfAll([
-        quantifier,
-        ...result.dependencies,
-    ])
+    const ancestor = getClosestAncestor(quantifier, ...result.dependencies)
 
     let replacement: string
     if (quantifier.min === 0) {
@@ -45,18 +41,3 @@ export function fixSimplifyQuantifier(
         }),
     ]
 }
-
-/**
- * Returns the closest ancestor of all given elements.
- */
-function getClosestAncestorOfAll<T extends Node>(
-    elements: readonly [T, ...T[]],
-): ClosestAncestor<T, T> {
-    let leftMost = elements[0]
-    let rightMost = elements[0]
-    for (const e of elements) {
-        if (e.start < leftMost.start) leftMost = e
-        if (e.end > rightMost.end) rightMost = e
-    }
-    return getClosestAncestor(leftMost, rightMost)
-}

lib/utils/regexp-ast/simplify-quantifier.ts

@@ -240,7 +240,12 @@ function toNfa(element: Element, parser: JS.Parser): NFA {
         assertions: "throw",
         backreferences: "throw",
     })
-    return NFA.fromRegex(expression, { maxCharacter }, { maxNodes: 1000 })
+    return NFA.fromRegex(
+        expression,
+        { maxCharacter },
+        {},
+        new NFA.LimitedNodeFactory(1000),
+    )
 }
 
 /**
@@ -261,15 +266,15 @@ function canAbsorbElementFormal(
     try {
         // perform a full NFA/DFA language check
         const qNfa = toNfa(quantifier, parser)
-        const qDfa = DFA.fromFA(qNfa, { maxNodes: 1000 })
+        const qDfa = DFA.fromFA(qNfa, new DFA.LimitedNodeFactory(1000))
         const eNfa = toNfa(element, parser)
         // We want to check whether `QE* = Q`. To perform this check, it's
         // sufficient to check `QE? = Q`. Proof sketch:
         // 1. If `QE? = Q`, then `Q = QE? = (QE?)E? = (QE?E?)E? = ... = QE*`.
         // 2. If `QE? != Q`, then `Q ⊂ QE? ⊆ QE*`, so `QE* != Q`.
         eNfa.quantify(0, 1)
         qNfa.append(eNfa)
-        const qeDfa = DFA.fromFA(qNfa, { maxNodes: 1000 })
+        const qeDfa = DFA.fromFA(qNfa, new DFA.LimitedNodeFactory(1000))
 
         qDfa.minimize()
         qeDfa.minimize()