@pobammer-ts/eslint-cease-nonsense-rules 1.7.1 → 1.9.0

package/dist/index.js

@@ -28,6 +28,730 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// node_modules/fast-diff/diff.js
+var require_diff = __commonJS((exports, module3) => {
+  var DIFF_DELETE = -1;
+  var DIFF_INSERT = 1;
+  var DIFF_EQUAL = 0;
+  function diff_main(text1, text2, cursor_pos, cleanup, _fix_unicode) {
+    if (text1 === text2) {
+      if (text1) {
+        return [[DIFF_EQUAL, text1]];
+      }
+      return [];
+    }
+    if (cursor_pos != null) {
+      var editdiff = find_cursor_edit_diff(text1, text2, cursor_pos);
+      if (editdiff) {
+        return editdiff;
+      }
+    }
+    var commonlength = diff_commonPrefix(text1, text2);
+    var commonprefix = text1.substring(0, commonlength);
+    text1 = text1.substring(commonlength);
+    text2 = text2.substring(commonlength);
+    commonlength = diff_commonSuffix(text1, text2);
+    var commonsuffix = text1.substring(text1.length - commonlength);
+    text1 = text1.substring(0, text1.length - commonlength);
+    text2 = text2.substring(0, text2.length - commonlength);
+    var diffs = diff_compute_(text1, text2);
+    if (commonprefix) {
+      diffs.unshift([DIFF_EQUAL, commonprefix]);
+    }
+    if (commonsuffix) {
+      diffs.push([DIFF_EQUAL, commonsuffix]);
+    }
+    diff_cleanupMerge(diffs, _fix_unicode);
+    if (cleanup) {
+      diff_cleanupSemantic(diffs);
+    }
+    return diffs;
+  }
+  function diff_compute_(text1, text2) {
+    var diffs;
+    if (!text1) {
+      return [[DIFF_INSERT, text2]];
+    }
+    if (!text2) {
+      return [[DIFF_DELETE, text1]];
+    }
+    var longtext = text1.length > text2.length ? text1 : text2;
+    var shorttext = text1.length > text2.length ? text2 : text1;
+    var i = longtext.indexOf(shorttext);
+    if (i !== -1) {
+      diffs = [
+        [DIFF_INSERT, longtext.substring(0, i)],
+        [DIFF_EQUAL, shorttext],
+        [DIFF_INSERT, longtext.substring(i + shorttext.length)]
+      ];
+      if (text1.length > text2.length) {
+        diffs[0][0] = diffs[2][0] = DIFF_DELETE;
+      }
+      return diffs;
+    }
+    if (shorttext.length === 1) {
+      return [
+        [DIFF_DELETE, text1],
+        [DIFF_INSERT, text2]
+      ];
+    }
+    var hm = diff_halfMatch_(text1, text2);
+    if (hm) {
+      var text1_a = hm[0];
+      var text1_b = hm[1];
+      var text2_a = hm[2];
+      var text2_b = hm[3];
+      var mid_common = hm[4];
+      var diffs_a = diff_main(text1_a, text2_a);
+      var diffs_b = diff_main(text1_b, text2_b);
+      return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);
+    }
+    return diff_bisect_(text1, text2);
+  }
+  function diff_bisect_(text1, text2) {
+    var text1_length = text1.length;
+    var text2_length = text2.length;
+    var max_d = Math.ceil((text1_length + text2_length) / 2);
+    var v_offset = max_d;
+    var v_length = 2 * max_d;
+    var v1 = new Array(v_length);
+    var v2 = new Array(v_length);
+    for (var x3 = 0;x3 < v_length; x3++) {
+      v1[x3] = -1;
+      v2[x3] = -1;
+    }
+    v1[v_offset + 1] = 0;
+    v2[v_offset + 1] = 0;
+    var delta2 = text1_length - text2_length;
+    var front = delta2 % 2 !== 0;
+    var k1start = 0;
+    var k1end = 0;
+    var k2start = 0;
+    var k2end = 0;
+    for (var d2 = 0;d2 < max_d; d2++) {
+      for (var k1 = -d2 + k1start;k1 <= d2 - k1end; k1 += 2) {
+        var k1_offset = v_offset + k1;
+        var x1;
+        if (k1 === -d2 || k1 !== d2 && v1[k1_offset - 1] < v1[k1_offset + 1]) {
+          x1 = v1[k1_offset + 1];
+        } else {
+          x1 = v1[k1_offset - 1] + 1;
+        }
+        var y1 = x1 - k1;
+        while (x1 < text1_length && y1 < text2_length && text1.charAt(x1) === text2.charAt(y1)) {
+          x1++;
+          y1++;
+        }
+        v1[k1_offset] = x1;
+        if (x1 > text1_length) {
+          k1end += 2;
+        } else if (y1 > text2_length) {
+          k1start += 2;
+        } else if (front) {
+          var k2_offset = v_offset + delta2 - k1;
+          if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] !== -1) {
+            var x22 = text1_length - v2[k2_offset];
+            if (x1 >= x22) {
+              return diff_bisectSplit_(text1, text2, x1, y1);
+            }
+          }
+        }
+      }
+      for (var k2 = -d2 + k2start;k2 <= d2 - k2end; k2 += 2) {
+        var k2_offset = v_offset + k2;
+        var x22;
+        if (k2 === -d2 || k2 !== d2 && v2[k2_offset - 1] < v2[k2_offset + 1]) {
+          x22 = v2[k2_offset + 1];
+        } else {
+          x22 = v2[k2_offset - 1] + 1;
+        }
+        var y2 = x22 - k2;
+        while (x22 < text1_length && y2 < text2_length && text1.charAt(text1_length - x22 - 1) === text2.charAt(text2_length - y2 - 1)) {
+          x22++;
+          y2++;
+        }
+        v2[k2_offset] = x22;
+        if (x22 > text1_length) {
+          k2end += 2;
+        } else if (y2 > text2_length) {
+          k2start += 2;
+        } else if (!front) {
+          var k1_offset = v_offset + delta2 - k2;
+          if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] !== -1) {
+            var x1 = v1[k1_offset];
+            var y1 = v_offset + x1 - k1_offset;
+            x22 = text1_length - x22;
+            if (x1 >= x22) {
+              return diff_bisectSplit_(text1, text2, x1, y1);
+            }
+          }
+        }
+      }
+    }
+    return [
+      [DIFF_DELETE, text1],
+      [DIFF_INSERT, text2]
+    ];
+  }
+  function diff_bisectSplit_(text1, text2, x3, y) {
+    var text1a = text1.substring(0, x3);
+    var text2a = text2.substring(0, y);
+    var text1b = text1.substring(x3);
+    var text2b = text2.substring(y);
+    var diffs = diff_main(text1a, text2a);
+    var diffsb = diff_main(text1b, text2b);
+    return diffs.concat(diffsb);
+  }
+  function diff_commonPrefix(text1, text2) {
+    if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {
+      return 0;
+    }
+    var pointermin = 0;
+    var pointermax = Math.min(text1.length, text2.length);
+    var pointermid = pointermax;
+    var pointerstart = 0;
+    while (pointermin < pointermid) {
+      if (text1.substring(pointerstart, pointermid) == text2.substring(pointerstart, pointermid)) {
+        pointermin = pointermid;
+        pointerstart = pointermin;
+      } else {
+        pointermax = pointermid;
+      }
+      pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+    }
+    if (is_surrogate_pair_start(text1.charCodeAt(pointermid - 1))) {
+      pointermid--;
+    }
+    return pointermid;
+  }
+  function diff_commonOverlap_(text1, text2) {
+    var text1_length = text1.length;
+    var text2_length = text2.length;
+    if (text1_length == 0 || text2_length == 0) {
+      return 0;
+    }
+    if (text1_length > text2_length) {
+      text1 = text1.substring(text1_length - text2_length);
+    } else if (text1_length < text2_length) {
+      text2 = text2.substring(0, text1_length);
+    }
+    var text_length = Math.min(text1_length, text2_length);
+    if (text1 == text2) {
+      return text_length;
+    }
+    var best = 0;
+    var length = 1;
+    while (true) {
+      var pattern4 = text1.substring(text_length - length);
+      var found = text2.indexOf(pattern4);
+      if (found == -1) {
+        return best;
+      }
+      length += found;
+      if (found == 0 || text1.substring(text_length - length) == text2.substring(0, length)) {
+        best = length;
+        length++;
+      }
+    }
+  }
+  function diff_commonSuffix(text1, text2) {
+    if (!text1 || !text2 || text1.slice(-1) !== text2.slice(-1)) {
+      return 0;
+    }
+    var pointermin = 0;
+    var pointermax = Math.min(text1.length, text2.length);
+    var pointermid = pointermax;
+    var pointerend = 0;
+    while (pointermin < pointermid) {
+      if (text1.substring(text1.length - pointermid, text1.length - pointerend) == text2.substring(text2.length - pointermid, text2.length - pointerend)) {
+        pointermin = pointermid;
+        pointerend = pointermin;
+      } else {
+        pointermax = pointermid;
+      }
+      pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+    }
+    if (is_surrogate_pair_end(text1.charCodeAt(text1.length - pointermid))) {
+      pointermid--;
+    }
+    return pointermid;
+  }
+  function diff_halfMatch_(text1, text2) {
+    var longtext = text1.length > text2.length ? text1 : text2;
+    var shorttext = text1.length > text2.length ? text2 : text1;
+    if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {
+      return null;
+    }
+    function diff_halfMatchI_(longtext2, shorttext2, i) {
+      var seed = longtext2.substring(i, i + Math.floor(longtext2.length / 4));
+      var j = -1;
+      var best_common = "";
+      var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;
+      while ((j = shorttext2.indexOf(seed, j + 1)) !== -1) {
+        var prefixLength = diff_commonPrefix(longtext2.substring(i), shorttext2.substring(j));
+        var suffixLength = diff_commonSuffix(longtext2.substring(0, i), shorttext2.substring(0, j));
+        if (best_common.length < suffixLength + prefixLength) {
+          best_common = shorttext2.substring(j - suffixLength, j) + shorttext2.substring(j, j + prefixLength);
+          best_longtext_a = longtext2.substring(0, i - suffixLength);
+          best_longtext_b = longtext2.substring(i + prefixLength);
+          best_shorttext_a = shorttext2.substring(0, j - suffixLength);
+          best_shorttext_b = shorttext2.substring(j + prefixLength);
+        }
+      }
+      if (best_common.length * 2 >= longtext2.length) {
+        return [
+          best_longtext_a,
+          best_longtext_b,
+          best_shorttext_a,
+          best_shorttext_b,
+          best_common
+        ];
+      } else {
+        return null;
+      }
+    }
+    var hm1 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 4));
+    var hm2 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 2));
+    var hm;
+    if (!hm1 && !hm2) {
+      return null;
+    } else if (!hm2) {
+      hm = hm1;
+    } else if (!hm1) {
+      hm = hm2;
+    } else {
+      hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
+    }
+    var text1_a, text1_b, text2_a, text2_b;
+    if (text1.length > text2.length) {
+      text1_a = hm[0];
+      text1_b = hm[1];
+      text2_a = hm[2];
+      text2_b = hm[3];
+    } else {
+      text2_a = hm[0];
+      text2_b = hm[1];
+      text1_a = hm[2];
+      text1_b = hm[3];
+    }
+    var mid_common = hm[4];
+    return [text1_a, text1_b, text2_a, text2_b, mid_common];
+  }
+  function diff_cleanupSemantic(diffs) {
+    var changes = false;
+    var equalities = [];
+    var equalitiesLength = 0;
+    var lastequality = null;
+    var pointer4 = 0;
+    var length_insertions1 = 0;
+    var length_deletions1 = 0;
+    var length_insertions2 = 0;
+    var length_deletions2 = 0;
+    while (pointer4 < diffs.length) {
+      if (diffs[pointer4][0] == DIFF_EQUAL) {
+        equalities[equalitiesLength++] = pointer4;
+        length_insertions1 = length_insertions2;
+        length_deletions1 = length_deletions2;
+        length_insertions2 = 0;
+        length_deletions2 = 0;
+        lastequality = diffs[pointer4][1];
+      } else {
+        if (diffs[pointer4][0] == DIFF_INSERT) {
+          length_insertions2 += diffs[pointer4][1].length;
+        } else {
+          length_deletions2 += diffs[pointer4][1].length;
+        }
+        if (lastequality && lastequality.length <= Math.max(length_insertions1, length_deletions1) && lastequality.length <= Math.max(length_insertions2, length_deletions2)) {
+          diffs.splice(equalities[equalitiesLength - 1], 0, [
+            DIFF_DELETE,
+            lastequality
+          ]);
+          diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
+          equalitiesLength--;
+          equalitiesLength--;
+          pointer4 = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
+          length_insertions1 = 0;
+          length_deletions1 = 0;
+          length_insertions2 = 0;
+          length_deletions2 = 0;
+          lastequality = null;
+          changes = true;
+        }
+      }
+      pointer4++;
+    }
+    if (changes) {
+      diff_cleanupMerge(diffs);
+    }
+    diff_cleanupSemanticLossless(diffs);
+    pointer4 = 1;
+    while (pointer4 < diffs.length) {
+      if (diffs[pointer4 - 1][0] == DIFF_DELETE && diffs[pointer4][0] == DIFF_INSERT) {
+        var deletion = diffs[pointer4 - 1][1];
+        var insertion = diffs[pointer4][1];
+        var overlap_length1 = diff_commonOverlap_(deletion, insertion);
+        var overlap_length2 = diff_commonOverlap_(insertion, deletion);
+        if (overlap_length1 >= overlap_length2) {
+          if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
+            diffs.splice(pointer4, 0, [
+              DIFF_EQUAL,
+              insertion.substring(0, overlap_length1)
+            ]);
+            diffs[pointer4 - 1][1] = deletion.substring(0, deletion.length - overlap_length1);
+            diffs[pointer4 + 1][1] = insertion.substring(overlap_length1);
+            pointer4++;
+          }
+        } else {
+          if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
+            diffs.splice(pointer4, 0, [
+              DIFF_EQUAL,
+              deletion.substring(0, overlap_length2)
+            ]);
+            diffs[pointer4 - 1][0] = DIFF_INSERT;
+            diffs[pointer4 - 1][1] = insertion.substring(0, insertion.length - overlap_length2);
+            diffs[pointer4 + 1][0] = DIFF_DELETE;
+            diffs[pointer4 + 1][1] = deletion.substring(overlap_length2);
+            pointer4++;
+          }
+        }
+        pointer4++;
+      }
+      pointer4++;
+    }
+  }
+  var nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
+  var whitespaceRegex_ = /\s/;
+  var linebreakRegex_ = /[\r\n]/;
+  var blanklineEndRegex_ = /\n\r?\n$/;
+  var blanklineStartRegex_ = /^\r?\n\r?\n/;
+  function diff_cleanupSemanticLossless(diffs) {
+    function diff_cleanupSemanticScore_(one, two) {
+      if (!one || !two) {
+        return 6;
+      }
+      var char1 = one.charAt(one.length - 1);
+      var char2 = two.charAt(0);
+      var nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);
+      var nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);
+      var whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);
+      var whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);
+      var lineBreak1 = whitespace1 && char1.match(linebreakRegex_);
+      var lineBreak2 = whitespace2 && char2.match(linebreakRegex_);
+      var blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);
+      var blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);
+      if (blankLine1 || blankLine2) {
+        return 5;
+      } else if (lineBreak1 || lineBreak2) {
+        return 4;
+      } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
+        return 3;
+      } else if (whitespace1 || whitespace2) {
+        return 2;
+      } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
+        return 1;
+      }
+      return 0;
+    }
+    var pointer4 = 1;
+    while (pointer4 < diffs.length - 1) {
+      if (diffs[pointer4 - 1][0] == DIFF_EQUAL && diffs[pointer4 + 1][0] == DIFF_EQUAL) {
+        var equality1 = diffs[pointer4 - 1][1];
+        var edit2 = diffs[pointer4][1];
+        var equality2 = diffs[pointer4 + 1][1];
+        var commonOffset = diff_commonSuffix(equality1, edit2);
+        if (commonOffset) {
+          var commonString = edit2.substring(edit2.length - commonOffset);
+          equality1 = equality1.substring(0, equality1.length - commonOffset);
+          edit2 = commonString + edit2.substring(0, edit2.length - commonOffset);
+          equality2 = commonString + equality2;
+        }
+        var bestEquality1 = equality1;
+        var bestEdit = edit2;
+        var bestEquality2 = equality2;
+        var bestScore = diff_cleanupSemanticScore_(equality1, edit2) + diff_cleanupSemanticScore_(edit2, equality2);
+        while (edit2.charAt(0) === equality2.charAt(0)) {
+          equality1 += edit2.charAt(0);
+          edit2 = edit2.substring(1) + equality2.charAt(0);
+          equality2 = equality2.substring(1);
+          var score = diff_cleanupSemanticScore_(equality1, edit2) + diff_cleanupSemanticScore_(edit2, equality2);
+          if (score >= bestScore) {
+            bestScore = score;
+            bestEquality1 = equality1;
+            bestEdit = edit2;
+            bestEquality2 = equality2;
+          }
+        }
+        if (diffs[pointer4 - 1][1] != bestEquality1) {
+          if (bestEquality1) {
+            diffs[pointer4 - 1][1] = bestEquality1;
+          } else {
+            diffs.splice(pointer4 - 1, 1);
+            pointer4--;
+          }
+          diffs[pointer4][1] = bestEdit;
+          if (bestEquality2) {
+            diffs[pointer4 + 1][1] = bestEquality2;
+          } else {
+            diffs.splice(pointer4 + 1, 1);
+            pointer4--;
+          }
+        }
+      }
+      pointer4++;
+    }
+  }
+  function diff_cleanupMerge(diffs, fix_unicode) {
+    diffs.push([DIFF_EQUAL, ""]);
+    var pointer4 = 0;
+    var count_delete = 0;
+    var count_insert = 0;
+    var text_delete = "";
+    var text_insert = "";
+    var commonlength;
+    while (pointer4 < diffs.length) {
+      if (pointer4 < diffs.length - 1 && !diffs[pointer4][1]) {
+        diffs.splice(pointer4, 1);
+        continue;
+      }
+      switch (diffs[pointer4][0]) {
+        case DIFF_INSERT:
+          count_insert++;
+          text_insert += diffs[pointer4][1];
+          pointer4++;
+          break;
+        case DIFF_DELETE:
+          count_delete++;
+          text_delete += diffs[pointer4][1];
+          pointer4++;
+          break;
+        case DIFF_EQUAL:
+          var previous_equality = pointer4 - count_insert - count_delete - 1;
+          if (fix_unicode) {
+            if (previous_equality >= 0 && ends_with_pair_start(diffs[previous_equality][1])) {
+              var stray = diffs[previous_equality][1].slice(-1);
+              diffs[previous_equality][1] = diffs[previous_equality][1].slice(0, -1);
+              text_delete = stray + text_delete;
+              text_insert = stray + text_insert;
+              if (!diffs[previous_equality][1]) {
+                diffs.splice(previous_equality, 1);
+                pointer4--;
+                var k2 = previous_equality - 1;
+                if (diffs[k2] && diffs[k2][0] === DIFF_INSERT) {
+                  count_insert++;
+                  text_insert = diffs[k2][1] + text_insert;
+                  k2--;
+                }
+                if (diffs[k2] && diffs[k2][0] === DIFF_DELETE) {
+                  count_delete++;
+                  text_delete = diffs[k2][1] + text_delete;
+                  k2--;
+                }
+                previous_equality = k2;
+              }
+            }
+            if (starts_with_pair_end(diffs[pointer4][1])) {
+              var stray = diffs[pointer4][1].charAt(0);
+              diffs[pointer4][1] = diffs[pointer4][1].slice(1);
+              text_delete += stray;
+              text_insert += stray;
+            }
+          }
+          if (pointer4 < diffs.length - 1 && !diffs[pointer4][1]) {
+            diffs.splice(pointer4, 1);
+            break;
+          }
+          if (text_delete.length > 0 || text_insert.length > 0) {
+            if (text_delete.length > 0 && text_insert.length > 0) {
+              commonlength = diff_commonPrefix(text_insert, text_delete);
+              if (commonlength !== 0) {
+                if (previous_equality >= 0) {
+                  diffs[previous_equality][1] += text_insert.substring(0, commonlength);
+                } else {
+                  diffs.splice(0, 0, [
+                    DIFF_EQUAL,
+                    text_insert.substring(0, commonlength)
+                  ]);
+                  pointer4++;
+                }
+                text_insert = text_insert.substring(commonlength);
+                text_delete = text_delete.substring(commonlength);
+              }
+              commonlength = diff_commonSuffix(text_insert, text_delete);
+              if (commonlength !== 0) {
+                diffs[pointer4][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer4][1];
+                text_insert = text_insert.substring(0, text_insert.length - commonlength);
+                text_delete = text_delete.substring(0, text_delete.length - commonlength);
+              }
+            }
+            var n = count_insert + count_delete;
+            if (text_delete.length === 0 && text_insert.length === 0) {
+              diffs.splice(pointer4 - n, n);
+              pointer4 = pointer4 - n;
+            } else if (text_delete.length === 0) {
+              diffs.splice(pointer4 - n, n, [DIFF_INSERT, text_insert]);
+              pointer4 = pointer4 - n + 1;
+            } else if (text_insert.length === 0) {
+              diffs.splice(pointer4 - n, n, [DIFF_DELETE, text_delete]);
+              pointer4 = pointer4 - n + 1;
+            } else {
+              diffs.splice(pointer4 - n, n, [DIFF_DELETE, text_delete], [DIFF_INSERT, text_insert]);
+              pointer4 = pointer4 - n + 2;
+            }
+          }
+          if (pointer4 !== 0 && diffs[pointer4 - 1][0] === DIFF_EQUAL) {
+            diffs[pointer4 - 1][1] += diffs[pointer4][1];
+            diffs.splice(pointer4, 1);
+          } else {
+            pointer4++;
+          }
+          count_insert = 0;
+          count_delete = 0;
+          text_delete = "";
+          text_insert = "";
+          break;
+      }
+    }
+    if (diffs[diffs.length - 1][1] === "") {
+      diffs.pop();
+    }
+    var changes = false;
+    pointer4 = 1;
+    while (pointer4 < diffs.length - 1) {
+      if (diffs[pointer4 - 1][0] === DIFF_EQUAL && diffs[pointer4 + 1][0] === DIFF_EQUAL) {
+        if (diffs[pointer4][1].substring(diffs[pointer4][1].length - diffs[pointer4 - 1][1].length) === diffs[pointer4 - 1][1]) {
+          diffs[pointer4][1] = diffs[pointer4 - 1][1] + diffs[pointer4][1].substring(0, diffs[pointer4][1].length - diffs[pointer4 - 1][1].length);
+          diffs[pointer4 + 1][1] = diffs[pointer4 - 1][1] + diffs[pointer4 + 1][1];
+          diffs.splice(pointer4 - 1, 1);
+          changes = true;
+        } else if (diffs[pointer4][1].substring(0, diffs[pointer4 + 1][1].length) == diffs[pointer4 + 1][1]) {
+          diffs[pointer4 - 1][1] += diffs[pointer4 + 1][1];
+          diffs[pointer4][1] = diffs[pointer4][1].substring(diffs[pointer4 + 1][1].length) + diffs[pointer4 + 1][1];
+          diffs.splice(pointer4 + 1, 1);
+          changes = true;
+        }
+      }
+      pointer4++;
+    }
+    if (changes) {
+      diff_cleanupMerge(diffs, fix_unicode);
+    }
+  }
+  function is_surrogate_pair_start(charCode) {
+    return charCode >= 55296 && charCode <= 56319;
+  }
+  function is_surrogate_pair_end(charCode) {
+    return charCode >= 56320 && charCode <= 57343;
+  }
+  function starts_with_pair_end(str) {
+    return is_surrogate_pair_end(str.charCodeAt(0));
+  }
+  function ends_with_pair_start(str) {
+    return is_surrogate_pair_start(str.charCodeAt(str.length - 1));
+  }
+  function remove_empty_tuples(tuples) {
+    var ret = [];
+    for (var i = 0;i < tuples.length; i++) {
+      if (tuples[i][1].length > 0) {
+        ret.push(tuples[i]);
+      }
+    }
+    return ret;
+  }
+  function make_edit_splice(before, oldMiddle, newMiddle, after) {
+    if (ends_with_pair_start(before) || starts_with_pair_end(after)) {
+      return null;
+    }
+    return remove_empty_tuples([
+      [DIFF_EQUAL, before],
+      [DIFF_DELETE, oldMiddle],
+      [DIFF_INSERT, newMiddle],
+      [DIFF_EQUAL, after]
+    ]);
+  }
+  function find_cursor_edit_diff(oldText, newText, cursor_pos) {
+    var oldRange = typeof cursor_pos === "number" ? { index: cursor_pos, length: 0 } : cursor_pos.oldRange;
+    var newRange = typeof cursor_pos === "number" ? null : cursor_pos.newRange;
+    var oldLength = oldText.length;
+    var newLength = newText.length;
+    if (oldRange.length === 0 && (newRange === null || newRange.length === 0)) {
+      var oldCursor = oldRange.index;
+      var oldBefore = oldText.slice(0, oldCursor);
+      var oldAfter = oldText.slice(oldCursor);
+      var maybeNewCursor = newRange ? newRange.index : null;
+      editBefore: {
+        var newCursor = oldCursor + newLength - oldLength;
+        if (maybeNewCursor !== null && maybeNewCursor !== newCursor) {
+          break editBefore;
+        }
+        if (newCursor < 0 || newCursor > newLength) {
+          break editBefore;
+        }
+        var newBefore = newText.slice(0, newCursor);
+        var newAfter = newText.slice(newCursor);
+        if (newAfter !== oldAfter) {
+          break editBefore;
+        }
+        var prefixLength = Math.min(oldCursor, newCursor);
+        var oldPrefix = oldBefore.slice(0, prefixLength);
+        var newPrefix = newBefore.slice(0, prefixLength);
+        if (oldPrefix !== newPrefix) {
+          break editBefore;
+        }
+        var oldMiddle = oldBefore.slice(prefixLength);
+        var newMiddle = newBefore.slice(prefixLength);
+        return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldAfter);
+      }
+      editAfter: {
+        if (maybeNewCursor !== null && maybeNewCursor !== oldCursor) {
+          break editAfter;
+        }
+        var cursor = oldCursor;
+        var newBefore = newText.slice(0, cursor);
+        var newAfter = newText.slice(cursor);
+        if (newBefore !== oldBefore) {
+          break editAfter;
+        }
+        var suffixLength = Math.min(oldLength - cursor, newLength - cursor);
+        var oldSuffix = oldAfter.slice(oldAfter.length - suffixLength);
+        var newSuffix = newAfter.slice(newAfter.length - suffixLength);
+        if (oldSuffix !== newSuffix) {
+          break editAfter;
+        }
+        var oldMiddle = oldAfter.slice(0, oldAfter.length - suffixLength);
+        var newMiddle = newAfter.slice(0, newAfter.length - suffixLength);
+        return make_edit_splice(oldBefore, oldMiddle, newMiddle, oldSuffix);
+      }
+    }
+    if (oldRange.length > 0 && newRange && newRange.length === 0) {
+      replaceRange: {
+        var oldPrefix = oldText.slice(0, oldRange.index);
+        var oldSuffix = oldText.slice(oldRange.index + oldRange.length);
+        var prefixLength = oldPrefix.length;
+        var suffixLength = oldSuffix.length;
+        if (newLength < prefixLength + suffixLength) {
+          break replaceRange;
+        }
+        var newPrefix = newText.slice(0, prefixLength);
+        var newSuffix = newText.slice(newLength - suffixLength);
+        if (oldPrefix !== newPrefix || oldSuffix !== newSuffix) {
+          break replaceRange;
+        }
+        var oldMiddle = oldText.slice(prefixLength, oldLength - suffixLength);
+        var newMiddle = newText.slice(prefixLength, newLength - suffixLength);
+        return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldSuffix);
+      }
+    }
+    return null;
+  }
+  function diff2(text1, text2, cursor_pos, cleanup) {
+    return diff_main(text1, text2, cursor_pos, cleanup, true);
+  }
+  diff2.INSERT = DIFF_INSERT;
+  diff2.DELETE = DIFF_DELETE;
+  diff2.EQUAL = DIFF_EQUAL;
+  module3.exports = diff2;
+});
+
 // node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs
 var require_eslint_visitor_keys = __commonJS((exports) => {
   var KEYS = {
@@ -7478,124 +8202,919 @@ var require_dist2 = __commonJS((exports) => {
   __exportStar(require_variable(), exports);
 });
 
-// src/rules/ban-instances.ts
-import { TSESTree } from "@typescript-eslint/types";
+// node_modules/@oxc-resolver/binding-linux-x64-musl/resolver.linux-x64-musl.node
+var require_resolver_linux_x64_musl = __commonJS((exports, module3) => {
+  module3.exports = __require("./resolver.linux-x64-musl-gnkc267h.node");
+});
 
-// node_modules/typebox/build/system/memory/memory.mjs
-var exports_memory = {};
-__export(exports_memory, {
-  Update: () => Update,
-  Metrics: () => Metrics,
-  Discard: () => Discard,
-  Create: () => Create,
-  Clone: () => Clone,
-  Assign: () => Assign
+// node_modules/@oxc-resolver/binding-linux-x64-musl/package.json
+var require_package = __commonJS((exports, module3) => {
+  module3.exports = {
+    name: "@oxc-resolver/binding-linux-x64-musl",
+    version: "11.16.0",
+    cpu: [
+      "x64"
+    ],
+    main: "resolver.linux-x64-musl.node",
+    files: [
+      "resolver.linux-x64-musl.node"
+    ],
+    description: "Oxc Resolver Node API",
+    homepage: "https://oxc.rs",
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/oxc-project/oxc-resolver.git"
+    },
+    publishConfig: {
+      registry: "https://registry.npmjs.org/",
+      access: "public"
+    },
+    os: [
+      "linux"
+    ],
+    libc: [
+      "musl"
+    ]
+  };
 });
 
-// node_modules/typebox/build/system/memory/metrics.mjs
-var Metrics = {
-  assign: 0,
-  create: 0,
-  clone: 0,
-  discard: 0,
-  update: 0
-};
+// node_modules/@oxc-resolver/binding-linux-x64-gnu/resolver.linux-x64-gnu.node
+var require_resolver_linux_x64_gnu = __commonJS((exports, module3) => {
+  module3.exports = __require("./resolver.linux-x64-gnu-hcjn12y1.node");
+});
 
-// node_modules/typebox/build/system/memory/assign.mjs
-function Assign(left, right) {
-  Metrics.assign += 1;
-  return { ...left, ...right };
-}
-// node_modules/typebox/build/guard/emit.mjs
-var exports_emit = {};
-__export(exports_emit, {
-  Ternary: () => Ternary,
-  StringGraphemeCount: () => StringGraphemeCount2,
-  Statements: () => Statements,
-  Return: () => Return,
-  ReduceOr: () => ReduceOr,
-  ReduceAnd: () => ReduceAnd,
-  PrefixIncrement: () => PrefixIncrement,
-  Or: () => Or,
-  Not: () => Not,
-  New: () => New,
-  MultipleOf: () => MultipleOf,
-  Member: () => Member,
-  Keys: () => Keys2,
-  IsUndefined: () => IsUndefined2,
-  IsSymbol: () => IsSymbol2,
-  IsString: () => IsString2,
-  IsObjectNotArray: () => IsObjectNotArray2,
-  IsObject: () => IsObject2,
-  IsNumber: () => IsNumber2,
-  IsNull: () => IsNull2,
-  IsLessThan: () => IsLessThan2,
-  IsLessEqualThan: () => IsLessEqualThan2,
-  IsIterator: () => IsIterator2,
-  IsInteger: () => IsInteger2,
-  IsGreaterThan: () => IsGreaterThan2,
-  IsGreaterEqualThan: () => IsGreaterEqualThan2,
-  IsFunction: () => IsFunction2,
-  IsEqual: () => IsEqual2,
-  IsDeepEqual: () => IsDeepEqual2,
-  IsConstructor: () => IsConstructor2,
-  IsBoolean: () => IsBoolean2,
-  IsBigInt: () => IsBigInt2,
-  IsAsyncIterator: () => IsAsyncIterator2,
-  IsArray: () => IsArray2,
-  If: () => If,
-  HasPropertyKey: () => HasPropertyKey2,
-  Every: () => Every2,
-  Entries: () => Entries2,
-  Constant: () => Constant,
-  ConstDeclaration: () => ConstDeclaration,
-  Call: () => Call,
-  ArrowFunction: () => ArrowFunction,
-  ArrayLiteral: () => ArrayLiteral,
-  And: () => And
+// node_modules/@oxc-resolver/binding-linux-x64-gnu/package.json
+var require_package2 = __commonJS((exports, module3) => {
+  module3.exports = {
+    name: "@oxc-resolver/binding-linux-x64-gnu",
+    version: "11.16.0",
+    cpu: [
+      "x64"
+    ],
+    main: "resolver.linux-x64-gnu.node",
+    files: [
+      "resolver.linux-x64-gnu.node"
+    ],
+    description: "Oxc Resolver Node API",
+    homepage: "https://oxc.rs",
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/oxc-project/oxc-resolver.git"
+    },
+    publishConfig: {
+      registry: "https://registry.npmjs.org/",
+      access: "public"
+    },
+    os: [
+      "linux"
+    ],
+    libc: [
+      "glibc"
+    ]
+  };
 });
 
-// node_modules/typebox/build/guard/guard.mjs
-var exports_guard = {};
-__export(exports_guard, {
-  Values: () => Values,
-  Symbols: () => Symbols,
-  StringGraphemeCount: () => StringGraphemeCount,
-  Keys: () => Keys,
-  IsValueLike: () => IsValueLike,
-  IsUndefined: () => IsUndefined,
-  IsSymbol: () => IsSymbol,
-  IsString: () => IsString,
-  IsObjectNotArray: () => IsObjectNotArray,
-  IsObject: () => IsObject,
-  IsNumber: () => IsNumber,
-  IsNull: () => IsNull,
-  IsMultipleOf: () => IsMultipleOf,
-  IsLessThan: () => IsLessThan,
-  IsLessEqualThan: () => IsLessEqualThan,
-  IsIterator: () => IsIterator,
-  IsInteger: () => IsInteger,
-  IsGreaterThan: () => IsGreaterThan,
-  IsGreaterEqualThan: () => IsGreaterEqualThan,
-  IsFunction: () => IsFunction,
-  IsEqual: () => IsEqual,
-  IsDeepEqual: () => IsDeepEqual,
-  IsConstructor: () => IsConstructor,
-  IsClassInstance: () => IsClassInstance,
-  IsBoolean: () => IsBoolean,
-  IsBigInt: () => IsBigInt,
-  IsAsyncIterator: () => IsAsyncIterator,
-  IsArray: () => IsArray,
-  HasPropertyKey: () => HasPropertyKey,
-  EveryAll: () => EveryAll,
-  Every: () => Every,
-  EntriesRegExp: () => EntriesRegExp,
-  Entries: () => Entries
+// node_modules/oxc-resolver/package.json
+var exports_package = {};
+__export(exports_package, {
+  version: () => version,
+  scripts: () => scripts,
+  repository: () => repository,
+  publishConfig: () => publishConfig,
+  packageManager: () => packageManager,
+  optionalDependencies: () => optionalDependencies,
+  napi: () => napi,
+  name: () => name,
+  main: () => main,
+  license: () => license,
+  homepage: () => homepage,
+  funding: () => funding,
+  files: () => files,
+  devDependencies: () => devDependencies,
+  description: () => description,
+  default: () => package_default,
+  browser: () => browser
 });
-function IsArray(value) {
-  return Array.isArray(value);
-}
-function IsAsyncIterator(value) {
+var name = "oxc-resolver", version = "11.16.0", description = "Oxc Resolver Node API", homepage = "https://oxc.rs", repository, funding, license = "MIT", main = "index.js", browser = "browser.js", files, scripts, devDependencies, napi, packageManager = "pnpm@10.25.0", publishConfig, optionalDependencies, package_default;
+var init_package = __esm(() => {
+  repository = {
+    type: "git",
+    url: "git+https://github.com/oxc-project/oxc-resolver.git"
+  };
+  funding = {
+    url: "https://github.com/sponsors/Boshen"
+  };
+  files = [
+    "browser.js",
+    "index.d.ts",
+    "index.js",
+    "webcontainer-fallback.js"
+  ];
+  scripts = {
+    test: "vitest run -r ./napi",
+    "build:debug": "napi build --platform --manifest-path napi/Cargo.toml",
+    build: "pnpm run build:debug --features allocator --release",
+    "postbuild:debug": "node napi/patch.mjs",
+    fmt: "oxfmt"
+  };
+  devDependencies = {
+    "@napi-rs/cli": "^3.3.1",
+    "@napi-rs/wasm-runtime": "^1.0.7",
+    "@types/node": "^25.0.0",
+    emnapi: "^1.6.0",
+    oxfmt: "^0.18.0",
+    typescript: "^5.9.3",
+    vitest: "^4.0.0"
+  };
+  napi = {
+    binaryName: "resolver",
+    packageName: "@oxc-resolver/binding",
+    targets: [
+      "aarch64-apple-darwin",
+      "aarch64-linux-android",
+      "aarch64-pc-windows-msvc",
+      "aarch64-unknown-linux-gnu",
+      "aarch64-unknown-linux-musl",
+      "aarch64-unknown-linux-ohos",
+      "armv7-linux-androideabi",
+      "armv7-unknown-linux-gnueabihf",
+      "armv7-unknown-linux-musleabihf",
+      "i686-pc-windows-msvc",
+      "powerpc64le-unknown-linux-gnu",
+      "riscv64gc-unknown-linux-gnu",
+      "riscv64gc-unknown-linux-musl",
+      "s390x-unknown-linux-gnu",
+      "wasm32-wasip1-threads",
+      "x86_64-apple-darwin",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl"
+    ],
+    wasm: {
+      browser: {
+        fs: true
+      }
+    }
+  };
+  publishConfig = {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  };
+  optionalDependencies = {
+    "@oxc-resolver/binding-darwin-arm64": "11.16.0",
+    "@oxc-resolver/binding-android-arm64": "11.16.0",
+    "@oxc-resolver/binding-win32-arm64-msvc": "11.16.0",
+    "@oxc-resolver/binding-linux-arm64-gnu": "11.16.0",
+    "@oxc-resolver/binding-linux-arm64-musl": "11.16.0",
+    "@oxc-resolver/binding-openharmony-arm64": "11.16.0",
+    "@oxc-resolver/binding-android-arm-eabi": "11.16.0",
+    "@oxc-resolver/binding-linux-arm-gnueabihf": "11.16.0",
+    "@oxc-resolver/binding-linux-arm-musleabihf": "11.16.0",
+    "@oxc-resolver/binding-win32-ia32-msvc": "11.16.0",
+    "@oxc-resolver/binding-linux-ppc64-gnu": "11.16.0",
+    "@oxc-resolver/binding-linux-riscv64-gnu": "11.16.0",
+    "@oxc-resolver/binding-linux-riscv64-musl": "11.16.0",
+    "@oxc-resolver/binding-linux-s390x-gnu": "11.16.0",
+    "@oxc-resolver/binding-wasm32-wasi": "11.16.0",
+    "@oxc-resolver/binding-darwin-x64": "11.16.0",
+    "@oxc-resolver/binding-win32-x64-msvc": "11.16.0",
+    "@oxc-resolver/binding-freebsd-x64": "11.16.0",
+    "@oxc-resolver/binding-linux-x64-gnu": "11.16.0",
+    "@oxc-resolver/binding-linux-x64-musl": "11.16.0"
+  };
+  package_default = {
+    name,
+    version,
+    description,
+    homepage,
+    repository,
+    funding,
+    license,
+    main,
+    browser,
+    files,
+    scripts,
+    devDependencies,
+    napi,
+    packageManager,
+    publishConfig,
+    optionalDependencies
+  };
+});
+
+// node_modules/oxc-resolver/webcontainer-fallback.js
+var require_webcontainer_fallback = __commonJS((exports, module3) => {
+  var fs = __require("node:fs");
+  var childProcess = __require("node:child_process");
+  var pkg = JSON.parse(fs.readFileSync(__require.resolve("/home/runner/work/eslint-cease-nonsense-rules/eslint-cease-nonsense-rules/node_modules/oxc-resolver/package.json"), "utf-8"));
+  var version2 = pkg.version;
+  var baseDir = `/tmp/oxc-resolver-${version2}`;
+  var bindingEntry = `${baseDir}/node_modules/@oxc-resolver/binding-wasm32-wasi/resolver.wasi.cjs`;
+  if (!fs.existsSync(bindingEntry)) {
+    fs.rmSync(baseDir, { recursive: true, force: true });
+    fs.mkdirSync(baseDir, { recursive: true });
+    const bindingPkg = `@oxc-resolver/binding-wasm32-wasi@${version2}`;
+    console.log(`[oxc-resolver] Downloading ${bindingPkg} on WebContainer...`);
+    childProcess.execFileSync("pnpm", ["i", bindingPkg], {
+      cwd: baseDir,
+      stdio: "inherit"
+    });
+  }
+  module3.exports = __require(bindingEntry);
+});
+
+// node_modules/oxc-resolver/index.js
+var require_oxc_resolver = __commonJS((exports, module3) => {
+  var { readFileSync: readFileSync3 } = __require("node:fs");
+  var nativeBinding2 = null;
+  var loadErrors2 = [];
+  var isMusl2 = () => {
+    let musl = false;
+    if (process.platform === "linux") {
+      musl = isMuslFromFilesystem2();
+      if (musl === null) {
+        musl = isMuslFromReport2();
+      }
+      if (musl === null) {
+        musl = isMuslFromChildProcess2();
+      }
+    }
+    return musl;
+  };
+  var isFileMusl2 = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var isMuslFromFilesystem2 = () => {
+    try {
+      return readFileSync3("/usr/bin/ldd", "utf-8").includes("musl");
+    } catch {
+      return null;
+    }
+  };
+  var isMuslFromReport2 = () => {
+    let report = null;
+    if (typeof process.report?.getReport === "function") {
+      process.report.excludeNetwork = true;
+      report = process.report.getReport();
+    }
+    if (!report) {
+      return null;
+    }
+    if (report.header && report.header.glibcVersionRuntime) {
+      return false;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl2)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  var isMuslFromChildProcess2 = () => {
+    try {
+      return __require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+    } catch (e) {
+      return false;
+    }
+  };
+  function requireNative2() {
+    if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+      try {
+        return __require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+      } catch (err) {
+        loadErrors2.push(err);
+      }
+    } else if (process.platform === "android") {
+      if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.android-arm64.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-android-arm64");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-android-arm64/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else if (process.arch === "arm") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.android-arm-eabi.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-android-arm-eabi");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-android-arm-eabi/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else {
+        loadErrors2.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+      }
+    } else if (process.platform === "win32") {
+      if (process.arch === "x64") {
+        if (process.config?.variables?.shlib_suffix === "dll.a" || process.config?.variables?.node_target_type === "shared_library") {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.win32-x64-gnu.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-x64-gnu");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-x64-gnu/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.win32-x64-msvc.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-x64-msvc");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-x64-msvc/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        }
+      } else if (process.arch === "ia32") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.win32-ia32-msvc.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-ia32-msvc");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-ia32-msvc/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.win32-arm64-msvc.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-arm64-msvc");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-win32-arm64-msvc/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else {
+        loadErrors2.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+      }
+    } else if (process.platform === "darwin") {
+      try {
+        return (()=>{throw new Error("Cannot require module "+"./resolver.darwin-universal.node");})();
+      } catch (e) {
+        loadErrors2.push(e);
+      }
+      try {
+        const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-darwin-universal");})();
+        const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-darwin-universal/package.json");})().version;
+        if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors2.push(e);
+      }
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.darwin-x64.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-darwin-x64");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-darwin-x64/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.darwin-arm64.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-darwin-arm64");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-darwin-arm64/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else {
+        loadErrors2.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+      }
+    } else if (process.platform === "freebsd") {
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.freebsd-x64.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-freebsd-x64");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-freebsd-x64/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.freebsd-arm64.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-freebsd-arm64");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-freebsd-arm64/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else {
+        loadErrors2.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+      }
+    } else if (process.platform === "linux") {
+      if (process.arch === "x64") {
+        if (isMusl2()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-x64-musl.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = require_resolver_linux_x64_musl();
+            const bindingPackageVersion = require_package().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-x64-gnu.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = require_resolver_linux_x64_gnu();
+            const bindingPackageVersion = require_package2().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        }
+      } else if (process.arch === "arm64") {
+        if (isMusl2()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-arm64-musl.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm64-musl");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm64-musl/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-arm64-gnu.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm64-gnu");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm64-gnu/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        }
+      } else if (process.arch === "arm") {
+        if (isMusl2()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-arm-musleabihf.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm-musleabihf");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm-musleabihf/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-arm-gnueabihf.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm-gnueabihf");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-arm-gnueabihf/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        }
+      } else if (process.arch === "loong64") {
+        if (isMusl2()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-loong64-musl.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-loong64-musl");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-loong64-musl/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-loong64-gnu.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-loong64-gnu");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-loong64-gnu/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        }
+      } else if (process.arch === "riscv64") {
+        if (isMusl2()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-riscv64-musl.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-riscv64-musl");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-riscv64-musl/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./resolver.linux-riscv64-gnu.node");})();
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+          try {
+            const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-riscv64-gnu");})();
+            const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-riscv64-gnu/package.json");})().version;
+            if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors2.push(e);
+          }
+        }
+      } else if (process.arch === "ppc64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.linux-ppc64-gnu.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-ppc64-gnu");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-ppc64-gnu/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else if (process.arch === "s390x") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.linux-s390x-gnu.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-s390x-gnu");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-linux-s390x-gnu/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else {
+        loadErrors2.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+      }
+    } else if (process.platform === "openharmony") {
+      if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.openharmony-arm64.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-openharmony-arm64");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-openharmony-arm64/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.openharmony-x64.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-openharmony-x64");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-openharmony-x64/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else if (process.arch === "arm") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./resolver.openharmony-arm.node");})();
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+        try {
+          const binding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-openharmony-arm");})();
+          const bindingPackageVersion = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-openharmony-arm/package.json");})().version;
+          if (bindingPackageVersion !== "11.16.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 11.16.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors2.push(e);
+        }
+      } else {
+        loadErrors2.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+      }
+    } else {
+      loadErrors2.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+    }
+  }
+  nativeBinding2 = requireNative2();
+  if (!nativeBinding2 || process.env.NAPI_RS_FORCE_WASI) {
+    let wasiBinding = null;
+    let wasiBindingError = null;
+    try {
+      wasiBinding = (()=>{throw new Error("Cannot require module "+"./resolver.wasi.cjs");})();
+      nativeBinding2 = wasiBinding;
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        wasiBindingError = err;
+      }
+    }
+    if (!nativeBinding2) {
+      try {
+        wasiBinding = (()=>{throw new Error("Cannot require module "+"@oxc-resolver/binding-wasm32-wasi");})();
+        nativeBinding2 = wasiBinding;
+      } catch (err) {
+        if (process.env.NAPI_RS_FORCE_WASI) {
+          wasiBindingError.cause = err;
+          loadErrors2.push(err);
+        }
+      }
+    }
+    if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+      const error2 = new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+      error2.cause = wasiBindingError;
+      throw error2;
+    }
+  }
+  if (!nativeBinding2 && globalThis.process?.versions?.["webcontainer"]) {
+    try {
+      nativeBinding2 = require_webcontainer_fallback();
+    } catch (err) {
+      loadErrors2.push(err);
+    }
+  }
+  if (!nativeBinding2) {
+    if (loadErrors2.length > 0) {
+      throw new Error(`Cannot find native binding. ` + `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + "Please try `npm i` again after removing both package-lock.json and node_modules directory.", {
+        cause: loadErrors2.reduce((err, cur) => {
+          cur.cause = err;
+          return cur;
+        })
+      });
+    }
+    throw new Error(`Failed to load native binding`);
+  }
+  module3.exports = nativeBinding2;
+  module3.exports.ResolverFactory = nativeBinding2.ResolverFactory;
+  module3.exports.EnforceExtension = nativeBinding2.EnforceExtension;
+  module3.exports.ModuleType = nativeBinding2.ModuleType;
+  module3.exports.sync = nativeBinding2.sync;
+  if (process.versions.pnp) {
+    process.env.OXC_RESOLVER_YARN_PNP = "1";
+  }
+});
+
+// src/rules/ban-instances.ts
+import { TSESTree } from "@typescript-eslint/types";
+
+// node_modules/typebox/build/system/memory/memory.mjs
+var exports_memory = {};
+__export(exports_memory, {
+  Update: () => Update,
+  Metrics: () => Metrics,
+  Discard: () => Discard,
+  Create: () => Create,
+  Clone: () => Clone,
+  Assign: () => Assign
+});
+
+// node_modules/typebox/build/system/memory/metrics.mjs
+var Metrics = {
+  assign: 0,
+  create: 0,
+  clone: 0,
+  discard: 0,
+  update: 0
+};
+
+// node_modules/typebox/build/system/memory/assign.mjs
+function Assign(left, right) {
+  Metrics.assign += 1;
+  return { ...left, ...right };
+}
+// node_modules/typebox/build/guard/emit.mjs
+var exports_emit = {};
+__export(exports_emit, {
+  Ternary: () => Ternary,
+  StringGraphemeCount: () => StringGraphemeCount2,
+  Statements: () => Statements,
+  Return: () => Return,
+  ReduceOr: () => ReduceOr,
+  ReduceAnd: () => ReduceAnd,
+  PrefixIncrement: () => PrefixIncrement,
+  Or: () => Or,
+  Not: () => Not,
+  New: () => New,
+  MultipleOf: () => MultipleOf,
+  Member: () => Member,
+  Keys: () => Keys2,
+  IsUndefined: () => IsUndefined2,
+  IsSymbol: () => IsSymbol2,
+  IsString: () => IsString2,
+  IsObjectNotArray: () => IsObjectNotArray2,
+  IsObject: () => IsObject2,
+  IsNumber: () => IsNumber2,
+  IsNull: () => IsNull2,
+  IsLessThan: () => IsLessThan2,
+  IsLessEqualThan: () => IsLessEqualThan2,
+  IsIterator: () => IsIterator2,
+  IsInteger: () => IsInteger2,
+  IsGreaterThan: () => IsGreaterThan2,
+  IsGreaterEqualThan: () => IsGreaterEqualThan2,
+  IsFunction: () => IsFunction2,
+  IsEqual: () => IsEqual2,
+  IsDeepEqual: () => IsDeepEqual2,
+  IsConstructor: () => IsConstructor2,
+  IsBoolean: () => IsBoolean2,
+  IsBigInt: () => IsBigInt2,
+  IsAsyncIterator: () => IsAsyncIterator2,
+  IsArray: () => IsArray2,
+  If: () => If,
+  HasPropertyKey: () => HasPropertyKey2,
+  Every: () => Every2,
+  Entries: () => Entries2,
+  Constant: () => Constant,
+  ConstDeclaration: () => ConstDeclaration,
+  Call: () => Call,
+  ArrowFunction: () => ArrowFunction,
+  ArrayLiteral: () => ArrayLiteral,
+  And: () => And
+});
+
+// node_modules/typebox/build/guard/guard.mjs
+var exports_guard = {};
+__export(exports_guard, {
+  Values: () => Values,
+  Symbols: () => Symbols,
+  StringGraphemeCount: () => StringGraphemeCount,
+  Keys: () => Keys,
+  IsValueLike: () => IsValueLike,
+  IsUndefined: () => IsUndefined,
+  IsSymbol: () => IsSymbol,
+  IsString: () => IsString,
+  IsObjectNotArray: () => IsObjectNotArray,
+  IsObject: () => IsObject,
+  IsNumber: () => IsNumber,
+  IsNull: () => IsNull,
+  IsMultipleOf: () => IsMultipleOf,
+  IsLessThan: () => IsLessThan,
+  IsLessEqualThan: () => IsLessEqualThan,
+  IsIterator: () => IsIterator,
+  IsInteger: () => IsInteger,
+  IsGreaterThan: () => IsGreaterThan,
+  IsGreaterEqualThan: () => IsGreaterEqualThan,
+  IsFunction: () => IsFunction,
+  IsEqual: () => IsEqual,
+  IsDeepEqual: () => IsDeepEqual,
+  IsConstructor: () => IsConstructor,
+  IsClassInstance: () => IsClassInstance,
+  IsBoolean: () => IsBoolean,
+  IsBigInt: () => IsBigInt,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsArray: () => IsArray,
+  HasPropertyKey: () => HasPropertyKey,
+  EveryAll: () => EveryAll,
+  Every: () => Every,
+  EntriesRegExp: () => EntriesRegExp,
+  Entries: () => Entries
+});
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsAsyncIterator(value) {
   return IsObject(value) && Symbol.asyncIterator in value;
 }
 function IsBigInt(value) {
@@ -15435,19 +16954,17 @@ function normalizeConfig(options3) {
   if (!isOptionsObject.Check(options3))
     return { bannedClasses: new Map };
   const { bannedInstances } = options3;
+  const bannedClasses = new Map;
   if (isArrayConfig.Check(bannedInstances)) {
-    const map = new Map;
-    for (const className of bannedInstances)
-      map.set(className.toLowerCase(), { message: undefined, originalName: className });
-    return { bannedClasses: map };
-  }
-  if (isObjectConfig.Check(bannedInstances)) {
-    const map = new Map;
-    for (const [className, message] of Object.entries(bannedInstances))
-      map.set(className.toLowerCase(), { message, originalName: className });
-    return { bannedClasses: map };
+    for (const className of bannedInstances) {
+      bannedClasses.set(className.toLowerCase(), { message: undefined, originalName: className });
+    }
+  } else if (isObjectConfig.Check(bannedInstances)) {
+    for (const [className, message] of Object.entries(bannedInstances)) {
+      bannedClasses.set(className.toLowerCase(), { message, originalName: className });
+    }
   }
-  return { bannedClasses: new Map };
+  return { bannedClasses };
 }
 var docs = {
   description: "Ban specified Roblox Instance classes in new Instance() calls and JSX elements.",
@@ -15554,10 +17071,11 @@ var banReactFC = {
           return;
         const { typeName } = inner;
         let isBannedFc = false;
-        if (typeName.type === TSESTree2.AST_NODE_TYPES.Identifier)
+        if (typeName.type === TSESTree2.AST_NODE_TYPES.Identifier) {
           isBannedFc = BANNED_FC_NAMES.has(typeName.name);
-        else if (typeName.type === TSESTree2.AST_NODE_TYPES.TSQualifiedName)
+        } else if (typeName.type === TSESTree2.AST_NODE_TYPES.TSQualifiedName) {
           isBannedFc = BANNED_FC_NAMES.has(typeName.right.name);
+        }
         if (!isBannedFc || node.init?.type !== TSESTree2.AST_NODE_TYPES.ArrowFunctionExpression)
           return;
         context.report({
@@ -15592,22 +17110,15 @@ var DEFAULT_CONFIGURATION = {
   performanceMode: true,
   warnThreshold: 15
 };
-var SHOULD_NOT_NOT_RETURN_TYPE = new Set([
-  TSESTree3.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree3.AST_NODE_TYPES.FunctionExpression
-]);
 function hasTypeAnnotationProperty(node) {
   return "typeAnnotation" in node;
 }
 function hasTypeAnnotation(node) {
-  if (node.type === TSESTree3.AST_NODE_TYPES.VariableDeclarator && node.id && typeof node.id === "object" && hasTypeAnnotationProperty(node.id))
-    return Boolean(node.id.typeAnnotation);
-  if (SHOULD_NOT_NOT_RETURN_TYPE.has(node.type))
-    return Boolean(node.returnType);
-  return false;
-}
-function getTypeName(node) {
-  return node.type === TSESTree3.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === TSESTree3.AST_NODE_TYPES.TSTypeAliasDeclaration ? node.id.name : undefined;
+  if (node.id.type !== TSESTree3.AST_NODE_TYPES.Identifier)
+    return false;
+  if (typeof node.id !== "object" || !hasTypeAnnotationProperty(node.id))
+    return false;
+  return Boolean(node.id.typeAnnotation);
 }
 function isIanitorValidator(node) {
   return node.type === TSESTree3.AST_NODE_TYPES.CallExpression && node.callee?.type === TSESTree3.AST_NODE_TYPES.MemberExpression && node.callee.object?.type === TSESTree3.AST_NODE_TYPES.Identifier && node.callee.object.name === "Ianitor";
@@ -15620,9 +17131,10 @@ function extractIanitorStaticVariable(typeAnnotation) {
   if (currentType.type !== TSESTree3.AST_NODE_TYPES.TSTypeReference)
     return;
   const { typeName, typeArguments } = currentType;
-  const firstParam = typeArguments?.params[0];
-  if (typeName.type === TSESTree3.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.left.name === "Ianitor" && typeName.right.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.right.name === "Static" && firstParam?.type === TSESTree3.AST_NODE_TYPES.TSTypeQuery && firstParam.exprName.type === TSESTree3.AST_NODE_TYPES.Identifier) {
-    return firstParam.exprName.name;
+  if (typeName.type === TSESTree3.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.left.name === "Ianitor" && typeName.right.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.right.name === "Static") {
+    const first = typeArguments?.params[0];
+    const name = first?.type === TSESTree3.AST_NODE_TYPES.TSTypeQuery && first.exprName.type === TSESTree3.AST_NODE_TYPES.Identifier ? first.exprName.name : undefined;
+    return name;
   }
   return;
 }
@@ -15728,8 +17240,9 @@ var enforceIanitorCheckType = createRule({
           score = addScore(score, body.length * 2);
           for (const member of body) {
             const typeAnnotation = "typeAnnotation" in member ? member.typeAnnotation : undefined;
-            if (typeAnnotation)
+            if (typeAnnotation !== undefined) {
               score = addScore(score, calculateStructuralComplexity(typeAnnotation.typeAnnotation, nextDepth));
+            }
           }
           break;
         }
@@ -15738,8 +17251,9 @@ var enforceIanitorCheckType = createRule({
           score = 2 + members.length * 0.5;
           for (const member of members) {
             const typeAnnotation = "typeAnnotation" in member ? member.typeAnnotation : undefined;
-            if (typeAnnotation)
+            if (typeAnnotation !== undefined) {
               score = addScore(score, calculateStructuralComplexity(typeAnnotation.typeAnnotation, nextDepth));
+            }
           }
           break;
         }
@@ -15764,9 +17278,10 @@ var enforceIanitorCheckType = createRule({
           const { elementTypes } = node;
           score = 1;
           for (const element of elementTypes) {
-            const elementType = element.type;
-            if (elementType !== "TSRestType" && elementType !== "TSOptionalType")
+            const { type: type3 } = element;
+            if (type3 !== "TSRestType" && type3 !== "TSOptionalType") {
               score = addScore(score, calculateStructuralComplexity(element, nextDepth));
+            }
           }
           score = addScore(score, 1.5 * elementTypes.length);
           break;
@@ -15774,9 +17289,10 @@ var enforceIanitorCheckType = createRule({
         case TSESTree3.AST_NODE_TYPES.TSTypeReference: {
           score = 2;
           const { typeArguments } = node;
-          if (typeArguments) {
-            for (const param of typeArguments.params)
-              score = addScore(score, calculateStructuralComplexity(param, nextDepth) + 2);
+          if (typeArguments !== undefined) {
+            for (const parameter2 of typeArguments.params) {
+              score = addScore(score, calculateStructuralComplexity(parameter2, nextDepth) + 2);
+            }
           }
           break;
         }
@@ -15790,22 +17306,26 @@ var enforceIanitorCheckType = createRule({
         }
         case TSESTree3.AST_NODE_TYPES.TSMappedType: {
           score = 5;
-          if (node.constraint)
+          if ("constraint" in node) {
             score = addScore(score, calculateStructuralComplexity(node.constraint, nextDepth));
-          if (node.typeAnnotation)
+          }
+          if (node.typeAnnotation !== undefined) {
             score = addScore(score, calculateStructuralComplexity(node.typeAnnotation, nextDepth));
+          }
           break;
         }
         case TSESTree3.AST_NODE_TYPES.TSFunctionType:
         case TSESTree3.AST_NODE_TYPES.TSMethodSignature: {
           score = 2;
-          for (const param of node.params) {
-            const typeAnnotation = "typeAnnotation" in param ? param.typeAnnotation : undefined;
-            if (typeAnnotation)
+          for (const parameter2 of node.params) {
+            const typeAnnotation = "typeAnnotation" in parameter2 ? parameter2.typeAnnotation : undefined;
+            if (typeAnnotation !== undefined) {
               score = addScore(score, calculateStructuralComplexity(typeAnnotation.typeAnnotation, nextDepth));
+            }
           }
-          if (node.returnType)
+          if (node.returnType !== undefined) {
             score = addScore(score, calculateStructuralComplexity(node.returnType.typeAnnotation, nextDepth));
+          }
           break;
         }
         default:
@@ -15820,8 +17340,9 @@ var enforceIanitorCheckType = createRule({
     return {
       "Program:exit"() {
         for (const [node, data] of variableDeclaratorsToCheck.entries()) {
-          if (node.id.type === TSESTree3.AST_NODE_TYPES.Identifier && ianitorStaticVariables.has(node.id.name))
+          if (node.id.type === TSESTree3.AST_NODE_TYPES.Identifier && ianitorStaticVariables.has(node.id.name)) {
             continue;
+          }
           context.report({
             data: { score: data.complexity.toFixed(1) },
             messageId: "missingIanitorCheckType",
@@ -15831,10 +17352,10 @@ var enforceIanitorCheckType = createRule({
       },
       TSInterfaceDeclaration(node) {
         const complexity = calculateStructuralComplexity(node);
-        const name = getTypeName(node);
+        const { name } = node.id;
         if (complexity >= config.interfacePenalty) {
           context.report({
-            data: { name: name ?? "unknown" },
+            data: { name },
             messageId: "complexInterfaceNeedsCheck",
             node
           });
@@ -15842,7 +17363,7 @@ var enforceIanitorCheckType = createRule({
       },
       TSTypeAliasDeclaration(node) {
         const variableName = extractIanitorStaticVariable(node.typeAnnotation);
-        if (variableName)
+        if (variableName !== undefined)
           ianitorStaticVariables.add(variableName);
         if (hasIanitorStaticType(node.typeAnnotation))
           return;
@@ -16336,23 +17857,29 @@ function h(n, l) {
   const g = K(n, l?.errors, l);
   return N(n, g, l), g;
 }
+// src/utilities/format-utilities.ts
+var import_fast_diff = __toESM(require_diff(), 1);
+
 // src/oxfmt-sync.ts
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { MessageChannel, receiveMessageOnPort, Worker } from "node:worker_threads";
 var FORMAT_TIMEOUT = 30000;
 var workerState;
-function resolveWorkerPath() {
-  const jsPath = new URL("./oxfmt-worker.js", import.meta.url);
+function __testingResolveWorkerPath(baseUrl, exists) {
+  const jsPath = new URL("./oxfmt-worker.js", baseUrl);
   const jsFilePath = fileURLToPath(jsPath);
-  if (existsSync(jsFilePath))
+  if (exists(jsFilePath))
     return jsPath;
-  const tsPath = new URL("./oxfmt-worker.ts", import.meta.url);
+  const tsPath = new URL("./oxfmt-worker.ts", baseUrl);
   const tsFilePath = fileURLToPath(tsPath);
-  if (existsSync(tsFilePath))
+  if (exists(tsFilePath))
     return tsPath;
   throw new Error(`Oxfmt worker not found at ${jsFilePath} or ${tsFilePath}. Did you run 'bun run build'?`);
 }
+function resolveWorkerPath() {
+  return __testingResolveWorkerPath(import.meta.url, existsSync);
+}
 function getWorker() {
   if (workerState !== undefined)
     return workerState;
@@ -16417,22 +17944,38 @@ function loadOxfmtConfig() {
   }
 }
 function getExtension(filePath) {
-  if (filePath.endsWith(".tsx"))
-    return ".tsx";
-  if (filePath.endsWith(".ts"))
-    return ".ts";
-  if (filePath.endsWith(".jsx"))
-    return ".jsx";
-  if (filePath.endsWith(".js"))
-    return ".js";
-  if (filePath.endsWith(".mts"))
-    return ".mts";
-  if (filePath.endsWith(".mjs"))
-    return ".mjs";
-  if (filePath.endsWith(".cts"))
-    return ".cts";
-  if (filePath.endsWith(".cjs"))
-    return ".cjs";
+  const { length } = filePath;
+  if (length >= 3 && filePath.codePointAt(length - 3) === 46 /* Period */) {
+    const character1 = filePath.codePointAt(length - 2);
+    const character2 = filePath.codePointAt(length - 1);
+    if (character1 === 116 /* LowerT */ && character2 === 115 /* LowerS */)
+      return ".ts";
+    if (character1 === 106 /* LowerJ */ && character2 === 115 /* LowerS */)
+      return ".js";
+  }
+  if (length >= 4 && filePath.codePointAt(length - 4) === 46 /* Period */) {
+    const character1 = filePath.codePointAt(length - 3);
+    const character2 = filePath.codePointAt(length - 2);
+    const character3 = filePath.codePointAt(length - 1);
+    if (character3 === 120 /* LowerX */) {
+      if (character1 === 116 /* LowerT */ && character2 === 115 /* LowerS */)
+        return ".tsx";
+      if (character1 === 106 /* LowerJ */ && character2 === 115 /* LowerS */)
+        return ".jsx";
+    } else if (character3 === 115 /* LowerS */) {
+      if (character2 === 116 /* LowerT */) {
+        if (character1 === 109 /* LowerM */)
+          return ".mts";
+        if (character1 === 99 /* LowerC */)
+          return ".cts";
+      } else if (character2 === 106 /* LowerJ */) {
+        if (character1 === 109 /* LowerM */)
+          return ".mjs";
+        if (character1 === 99 /* LowerC */)
+          return ".cjs";
+      }
+    }
+  }
   return;
 }
 function formatWithOxfmtSync(source, filePath) {
@@ -16445,14 +17988,51 @@ function formatWithOxfmtSync(source, filePath) {
 function generateDifferences(original, formatted) {
   if (original === formatted)
     return [];
-  return [
-    {
-      deleteText: original,
-      insertText: formatted,
-      offset: 0,
-      operation: "REPLACE"
+  const diffs = import_fast_diff.default(original, formatted);
+  const differences = new Array;
+  let size = 0;
+  let offset = 0;
+  let index2 = 0;
+  while (index2 < diffs.length) {
+    const diff2 = diffs[index2];
+    if (diff2 === undefined)
+      break;
+    const [type3, text] = diff2;
+    if (type3 === 0) {
+      offset += text.length;
+      index2 += 1;
+    } else if (type3 === -1) {
+      let adjustedOffset = offset;
+      const previous = diffs[index2 - 1];
+      if (previous !== undefined && previous[0] === 0) {
+        const [, prevText] = previous;
+        let shiftCount = 0;
+        while (shiftCount < prevText.length && shiftCount < text.length && prevText[prevText.length - 1 - shiftCount] === text[shiftCount]) {
+          shiftCount += 1;
+        }
+        adjustedOffset -= shiftCount;
+      }
+      const next = diffs[index2 + 1];
+      if (next !== undefined && next[0] === 1) {
+        const [, nextText] = next;
+        differences[size++] = {
+          deleteText: text,
+          insertText: nextText,
+          offset: adjustedOffset,
+          operation: "REPLACE"
+        };
+        index2 += 2;
+      } else {
+        differences[size++] = { deleteText: text, offset: adjustedOffset, operation: "DELETE" };
+        index2 += 1;
+      }
+      offset += text.length;
+    } else {
+      differences[size++] = { insertText: text, offset, operation: "INSERT" };
+      index2 += 1;
     }
-  ];
+  }
+  return differences;
 }
 var MAX_LENGTH = 60;
 var SYMBOLS = {
@@ -18112,15 +19692,11 @@ function tryParse(value, filename) {
 function containsCode(value, filename) {
   if (!couldBeJsCode(value))
     return false;
-  try {
-    const result = tryParse(value, filename);
-    if (!result)
-      return false;
-    const statements = toParsedStatements(result.program.body);
-    return !isExclusion(statements, value);
-  } catch {
+  const result = tryParse(value, filename);
+  if (!result)
     return false;
-  }
+  const statements = toParsedStatements(result.program.body);
+  return !isExclusion(statements, value);
 }
 var noCommentedCode = {
   create(context) {
@@ -18181,24 +19757,17 @@ var FUNCTION_BOUNDARIES = new Set([
   TSESTree5.AST_NODE_TYPES.FunctionExpression,
   TSESTree5.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
-var RUNTIME_TS_WRAPPERS = new Set([
-  "ParenthesizedExpression",
-  "TSAsExpression",
-  "TSSatisfiesExpression",
-  "TSTypeAssertion",
-  "TSNonNullExpression",
-  "TSInstantiationExpression",
-  "ChainExpression"
-]);
 function isComponentName(name) {
   return COMPONENT_NAME_PATTERN.test(name);
 }
 function isReactComponentHOC(callExpr) {
   const { callee } = callExpr;
-  if (callee.type === TSESTree5.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree5.AST_NODE_TYPES.Identifier) {
     return callee.name === "forwardRef" || callee.name === "memo";
-  if (callee.type === TSESTree5.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree5.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree5.AST_NODE_TYPES.Identifier)
+  }
+  if (callee.type === TSESTree5.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree5.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree5.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "forwardRef" || callee.property.name === "memo";
+  }
   return false;
 }
 function getComponentNameFromFunction(node) {
@@ -18231,13 +19800,14 @@ function getComponentNameFromCallParent(callExpr) {
   if (parent.type === TSESTree5.AST_NODE_TYPES.AssignmentExpression && parent.left.type === TSESTree5.AST_NODE_TYPES.Identifier && isComponentName(parent.left.name)) {
     return parent.left.name;
   }
+  let nameFromExportDefault;
   if (parent.type === TSESTree5.AST_NODE_TYPES.ExportDefaultDeclaration && callExpr.arguments.length > 0) {
     const [firstArg] = callExpr.arguments;
     if (firstArg && firstArg.type === TSESTree5.AST_NODE_TYPES.FunctionExpression && firstArg.id && isComponentName(firstArg.id.name)) {
-      return firstArg.id.name;
+      nameFromExportDefault = firstArg.id.name;
     }
   }
-  return;
+  return nameFromExportDefault;
 }
 function getHookName(callExpression) {
   const { callee } = callExpression;
@@ -18270,11 +19840,7 @@ function isTypeOnlyNullLiteral(node) {
   const { parent } = node;
   if (parent === null || parent === undefined)
     return false;
-  if (typeof parent.type === "string" && parent.type.startsWith("TS") && !RUNTIME_TS_WRAPPERS.has(parent.type))
-    return true;
-  if (parent.type === TSESTree5.AST_NODE_TYPES.TSLiteralType)
-    return true;
-  return false;
+  return parent.type === TSESTree5.AST_NODE_TYPES.TSLiteralType;
 }
 function analyzeComponentBody(functionNode, sourceCode, stateHooks) {
   let maxJsxDepth = 0;
@@ -18300,14 +19866,10 @@ function analyzeComponentBody(functionNode, sourceCode, stateHooks) {
         nullLiterals.push(literalNode);
     }
     function getVisitorKeysForNodeType(nodeType) {
-      const visitorKeysUnknown = sourceCode.visitorKeys;
-      if (visitorKeysUnknown === null || visitorKeysUnknown === undefined || typeof visitorKeysUnknown !== "object")
-        return [];
-      const visitorKeysRecord = visitorKeysUnknown;
-      const keysUnknown = visitorKeysRecord[nodeType];
-      if (!Array.isArray(keysUnknown))
-        return [];
       const keys3 = new Array;
+      const keysUnknown = sourceCode.visitorKeys[nodeType];
+      if (!Array.isArray(keysUnknown))
+        return keys3;
       for (const key of keysUnknown)
         if (typeof key === "string")
           keys3.push(key);
@@ -18319,9 +19881,10 @@ function analyzeComponentBody(functionNode, sourceCode, stateHooks) {
       const value = currentRecord[key];
       if (Array.isArray(value)) {
         for (const item of value) {
-          if (typeof item === "object" && item !== null && "type" in item) {
+          if (typeof item !== "object" || item === null)
+            continue;
+          if ("type" in item)
             visit(item, nextDepth);
-          }
         }
         continue;
       }
@@ -18548,41 +20111,35 @@ function isBlockReturningIdentity(body, paramName) {
   return statement.argument.name === paramName;
 }
 function isIdentityCallback(callback) {
-  if (callback.type === AST_NODE_TYPES2.ArrowFunctionExpression) {
-    if (callback.params.length !== 1)
-      return false;
-    const [param] = callback.params;
-    if (param === undefined)
-      return false;
-    const paramName = getParameterName(param);
-    if (paramName === undefined || paramName === "")
-      return false;
-    if (callback.body.type === AST_NODE_TYPES2.Identifier) {
-      return callback.body.name === paramName;
-    }
-    if (callback.body.type === AST_NODE_TYPES2.BlockStatement) {
-      return isBlockReturningIdentity(callback.body, paramName);
+  let isIdentity = false;
+  if (callback.type === AST_NODE_TYPES2.ArrowFunctionExpression && callback.params.length === 1) {
+    const [parameter2] = callback.params;
+    if (parameter2 !== undefined) {
+      const name = getParameterName(parameter2);
+      if (name !== undefined) {
+        const { body } = callback;
+        if (body.type === AST_NODE_TYPES2.Identifier)
+          isIdentity = body.name === name;
+        if (body.type === AST_NODE_TYPES2.BlockStatement)
+          isIdentity = isBlockReturningIdentity(body, name);
+      }
     }
-    return false;
   }
-  if (callback.type === AST_NODE_TYPES2.FunctionExpression) {
-    if (callback.params.length !== 1)
-      return false;
-    const [param] = callback.params;
-    if (param === undefined)
-      return false;
-    const paramName = getParameterName(param);
-    if (paramName === undefined || paramName === "")
-      return false;
-    return isBlockReturningIdentity(callback.body, paramName);
+  if (callback.type === AST_NODE_TYPES2.FunctionExpression && callback.params.length === 1) {
+    const [parameter2] = callback.params;
+    if (parameter2 !== undefined) {
+      const name = getParameterName(parameter2);
+      if (name !== undefined)
+        isIdentity = isBlockReturningIdentity(callback.body, name);
+    }
   }
-  return false;
+  return isIdentity;
 }
 function findVariable(context, identifier3) {
   let scope = context.sourceCode.getScope(identifier3);
   while (scope) {
     const variable = scope.set.get(identifier3.name);
-    if (variable)
+    if (variable !== undefined)
       return variable;
     scope = scope.upper ?? undefined;
   }
@@ -18590,9 +20147,8 @@ function findVariable(context, identifier3) {
 }
 function getHookName2(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES2.Identifier) {
+  if (callee.type === AST_NODE_TYPES2.Identifier)
     return callee.name;
-  }
   if (callee.type === AST_NODE_TYPES2.MemberExpression && callee.property.type === AST_NODE_TYPES2.Identifier) {
     return callee.property.name;
   }
@@ -18600,9 +20156,8 @@ function getHookName2(node) {
 }
 function isJoinBindingsCall(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES2.Identifier) {
+  if (callee.type === AST_NODE_TYPES2.Identifier)
     return callee.name === "joinBindings";
-  }
   if (callee.type === AST_NODE_TYPES2.MemberExpression && callee.property.type === AST_NODE_TYPES2.Identifier) {
     return callee.property.name === "joinBindings";
   }
@@ -18616,9 +20171,7 @@ function isBindingInitialization(variable) {
     if (!init || init.type !== AST_NODE_TYPES2.CallExpression)
       continue;
     const hookName = getHookName2(init);
-    if (hookName === "useBinding")
-      return true;
-    if (isJoinBindingsCall(init))
+    if (hookName === "useBinding" || isJoinBindingsCall(init))
       return true;
     if (init.callee.type === AST_NODE_TYPES2.MemberExpression && init.callee.property.type === AST_NODE_TYPES2.Identifier && init.callee.property.name === "map") {
       return true;
@@ -18630,26 +20183,21 @@ function isLikelyBinding(context, callee, patterns2) {
   const { object: object3 } = callee;
   if (object3.type === AST_NODE_TYPES2.Identifier) {
     const lowerName = object3.name.toLowerCase();
-    for (const pattern4 of patterns2) {
+    for (const pattern4 of patterns2)
       if (lowerName.includes(pattern4.toLowerCase()))
         return true;
-    }
     const variable = findVariable(context, object3);
-    if (variable && isBindingInitialization(variable))
+    if (variable !== undefined && isBindingInitialization(variable))
       return true;
   }
   if (object3.type === AST_NODE_TYPES2.CallExpression && object3.callee.type === AST_NODE_TYPES2.MemberExpression && object3.callee.property.type === AST_NODE_TYPES2.Identifier && object3.callee.property.name === "map") {
     return true;
   }
-  if (object3.type === AST_NODE_TYPES2.CallExpression && isJoinBindingsCall(object3)) {
-    return true;
-  }
-  return false;
+  return object3.type === AST_NODE_TYPES2.CallExpression && isJoinBindingsCall(object3);
 }
 var noIdentityMap = {
   create(context) {
-    const [rawOptions] = context.options;
-    const patterns2 = rawOptions?.bindingPatterns ?? DEFAULT_BINDING_PATTERNS;
+    const [{ bindingPatterns = DEFAULT_BINDING_PATTERNS } = {}] = context.options;
     return {
       CallExpression(node) {
         const { callee } = node;
@@ -18668,7 +20216,7 @@ var noIdentityMap = {
           return;
         if (!isIdentityCallback(callback))
           return;
-        const isBinding = isLikelyBinding(context, callee, patterns2);
+        const isBinding = isLikelyBinding(context, callee, bindingPatterns);
         context.report({
           fix(fixer) {
             const objectText = context.sourceCode.getText(callee.object);
@@ -19396,31 +20944,226 @@ var noUselessUseSpring = {
   defaultOptions: [DEFAULT_OPTION_VALUES],
   meta: {
     docs: {
-      description: "Disallow useSpring hooks whose config and dependencies are entirely static"
+      description: "Disallow useSpring hooks whose config and dependencies are entirely static"
+    },
+    messages: {
+      uselessSpring: "useSpring call has only static inputs and non-updating dependencies; replace it with a constant or remove the hook."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          springHooks: {
+            description: "Hook identifiers that should be treated as spring hooks",
+            items: { type: "string" },
+            type: "array"
+          },
+          staticGlobalFactories: {
+            default: [...DEFAULT_STATIC_GLOBAL_FACTORIES],
+            description: "Global factory identifiers that are treated as static constructors",
+            items: { type: "string" },
+            type: "array"
+          },
+          treatEmptyDepsAsViolation: {
+            default: true,
+            description: "Treat static config with an empty dependency array as a violation",
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+};
+var no_useless_use_spring_default = noUselessUseSpring;
+
+// src/rules/no-warn.ts
+var noWarn = {
+  create(context) {
+    return {
+      'CallExpression[callee.type="Identifier"][callee.name="warn"]'(node) {
+        context.report({
+          messageId: "useLog",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Ban warn() function calls. Use Log instead.",
+      recommended: false
+    },
+    messages: {
+      useLog: "Use Log instead of warn()"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_warn_default = noWarn;
+
+// src/rules/prefer-class-properties.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+function isExpression(node) {
+  return node.type !== AST_NODE_TYPES5.AssignmentPattern && node.type !== AST_NODE_TYPES5.TSEmptyBodyFunctionExpression;
+}
+function isSimpleLiteralProperty({ computed, value }) {
+  return !computed && isExpression(value) && isSimpleLiteral(value);
+}
+function isSimpleLiteral(node) {
+  if (!node)
+    return false;
+  switch (node.type) {
+    case AST_NODE_TYPES5.Literal:
+      return true;
+    case AST_NODE_TYPES5.MemberExpression:
+      return isSimpleLiteral(node.object);
+    case AST_NODE_TYPES5.CallExpression:
+      return node.callee.type === AST_NODE_TYPES5.MemberExpression && isSimpleLiteral(node.callee.object);
+    case AST_NODE_TYPES5.ArrayExpression:
+      return node.elements.every((element) => {
+        if (element === null)
+          return true;
+        if (element.type === AST_NODE_TYPES5.SpreadElement)
+          return false;
+        return isSimpleLiteral(element);
+      });
+    case AST_NODE_TYPES5.ObjectExpression:
+      return node.properties.every((property) => property.type === AST_NODE_TYPES5.SpreadElement || property.type !== AST_NODE_TYPES5.Property ? false : isSimpleLiteralProperty(property));
+    default:
+      return false;
+  }
+}
+function isStaticMemberExpression(node) {
+  let current = node;
+  while (current.type === AST_NODE_TYPES5.MemberExpression) {
+    if (current.computed && current.property.type !== AST_NODE_TYPES5.Literal)
+      return false;
+    current = current.object;
+  }
+  return true;
+}
+function isConstructor(node) {
+  return node.type === AST_NODE_TYPES5.MethodDefinition && node.kind === "constructor" && node.key.type === AST_NODE_TYPES5.Identifier && node.key.name === "constructor";
+}
+var preferClassProperties = {
+  create(context) {
+    const option = context.options[0] ?? "always";
+    if (option === "never") {
+      return {
+        PropertyDefinition(node) {
+          if (node.static)
+            return;
+          context.report({
+            messageId: "unexpectedClassProperty",
+            node
+          });
+        }
+      };
+    }
+    return {
+      ClassDeclaration(node) {
+        checkClass(node.body);
+      },
+      ClassExpression(node) {
+        checkClass(node.body);
+      }
+    };
+    function checkClass(body) {
+      for (const member of body.body) {
+        if (!isConstructor(member))
+          continue;
+        if (member.type !== AST_NODE_TYPES5.MethodDefinition)
+          continue;
+        if (!member.value || member.value.type !== AST_NODE_TYPES5.FunctionExpression)
+          continue;
+        for (const statement of member.value.body.body) {
+          if (statement.type !== AST_NODE_TYPES5.ExpressionStatement)
+            continue;
+          const { expression } = statement;
+          if (expression.type !== AST_NODE_TYPES5.AssignmentExpression)
+            continue;
+          if (expression.left.type !== AST_NODE_TYPES5.MemberExpression)
+            continue;
+          if (expression.left.object.type !== AST_NODE_TYPES5.ThisExpression)
+            continue;
+          if ((expression.left.property.type === AST_NODE_TYPES5.Identifier || expression.left.property.type === AST_NODE_TYPES5.Literal) && isSimpleLiteral(expression.right) && isStaticMemberExpression(expression.left)) {
+            context.report({
+              messageId: "unexpectedAssignment",
+              node: expression
+            });
+          }
+        }
+      }
+    }
+  },
+  defaultOptions: ["always"],
+  meta: {
+    docs: {
+      description: "Prefer class properties to assignment of literals in constructors."
+    },
+    messages: {
+      unexpectedAssignment: "Unexpected assignment of literal instance member.",
+      unexpectedClassProperty: "Unexpected class property."
+    },
+    schema: [{ enum: ["always", "never"], type: "string" }],
+    type: "suggestion"
+  }
+};
+var prefer_class_properties_default = preferClassProperties;
+
+// src/rules/prefer-early-return.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+var DEFAULT_MAXIMUM_STATEMENTS = 1;
+function isLonelyIfStatement(statement) {
+  return statement.alternate === null;
+}
+function isOffendingConsequent(consequent, maxStatements) {
+  return consequent.type === AST_NODE_TYPES6.ExpressionStatement && maxStatements === 0 || consequent.type === AST_NODE_TYPES6.BlockStatement && consequent.body.length > maxStatements;
+}
+function canSimplifyConditionalBody(body, maxStatements) {
+  if (body.body.length !== 1)
+    return false;
+  const [statement] = body.body;
+  if (statement === undefined || statement.type !== AST_NODE_TYPES6.IfStatement || !isLonelyIfStatement(statement)) {
+    return false;
+  }
+  return isOffendingConsequent(statement.consequent, maxStatements);
+}
+var preferEarlyReturn = {
+  create(context) {
+    const options3 = context.options[0] ?? {};
+    const maxStatements = options3.maximumStatements ?? DEFAULT_MAXIMUM_STATEMENTS;
+    function checkFunctionBody(node) {
+      const { body } = node;
+      if (body.type !== AST_NODE_TYPES6.BlockStatement || !canSimplifyConditionalBody(body, maxStatements))
+        return;
+      context.report({
+        messageId: "preferEarlyReturn",
+        node: body
+      });
+    }
+    return {
+      ArrowFunctionExpression: checkFunctionBody,
+      FunctionDeclaration: checkFunctionBody,
+      FunctionExpression: checkFunctionBody
+    };
+  },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description: "Prefer early returns over full-body conditional wrapping in function declarations."
     },
     messages: {
-      uselessSpring: "useSpring call has only static inputs and non-updating dependencies; replace it with a constant or remove the hook."
+      preferEarlyReturn: "Prefer an early return to a conditionally-wrapped function body"
     },
     schema: [
       {
         additionalProperties: false,
         properties: {
-          springHooks: {
-            description: "Hook identifiers that should be treated as spring hooks",
-            items: { type: "string" },
-            type: "array"
-          },
-          staticGlobalFactories: {
-            default: [...DEFAULT_STATIC_GLOBAL_FACTORIES],
-            description: "Global factory identifiers that are treated as static constructors",
-            items: { type: "string" },
-            type: "array"
-          },
-          treatEmptyDepsAsViolation: {
-            default: true,
-            description: "Treat static config with an empty dependency array as a violation",
-            type: "boolean"
-          }
+          maximumStatements: { type: "integer" }
         },
         type: "object"
       }
@@ -19428,42 +21171,162 @@ var noUselessUseSpring = {
     type: "suggestion"
   }
 };
-var no_useless_use_spring_default = noUselessUseSpring;
-
-// src/rules/no-warn.ts
-var noWarn = {
+var prefer_early_return_default = preferEarlyReturn;
+
+// src/rules/prefer-module-scope-constants.ts
+var import_scope_manager3 = __toESM(require_dist2(), 1);
+import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+var SCREAMING_SNAKE_CASE = /^[A-Z][A-Z0-9_]*$/;
+function isTopScope(scope) {
+  const { type: type3 } = scope;
+  if (type3 === import_scope_manager3.ScopeType.module || type3 === import_scope_manager3.ScopeType.global)
+    return true;
+  if (scope.upper?.type === import_scope_manager3.ScopeType.global) {
+    const { block } = scope.upper;
+    if (block.type === AST_NODE_TYPES7.Program && block.sourceType === "script")
+      return true;
+  }
+  return false;
+}
+var preferModuleScopeConstants = {
   create(context) {
+    let inConstDeclaration = false;
     return {
-      'CallExpression[callee.type="Identifier"][callee.name="warn"]'(node) {
+      VariableDeclaration(node) {
+        inConstDeclaration = node.kind === "const";
+      },
+      "VariableDeclaration:exit"() {
+        inConstDeclaration = false;
+      },
+      VariableDeclarator(node) {
+        const { id: id2 } = node;
+        if (id2.type !== AST_NODE_TYPES7.Identifier || !SCREAMING_SNAKE_CASE.test(id2.name))
+          return;
+        if (!inConstDeclaration) {
+          context.report({
+            messageId: "mustUseConst",
+            node
+          });
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        if (isTopScope(scope))
+          return;
         context.report({
-          messageId: "useLog",
+          messageId: "mustBeModuleScope",
           node
         });
       }
     };
   },
+  defaultOptions: [],
   meta: {
     docs: {
-      description: "Ban warn() function calls. Use Log instead.",
-      recommended: false
+      description: "Prefer that screaming snake case variables always be defined using `const`, and always appear at module scope."
     },
     messages: {
-      useLog: "Use Log instead of warn()"
+      mustBeModuleScope: "You must place screaming snake case at module scope. If this is not meant to be a module-scoped variable, use camelcase instead.",
+      mustUseConst: "You must use `const` when defining screaming snake case variables. If this is not a constant, use camelcase instead."
     },
     schema: [],
-    type: "problem"
+    type: "suggestion"
   }
 };
-var no_warn_default = noWarn;
+var prefer_module_scope_constants_default = preferModuleScopeConstants;
+
+// src/rules/prefer-pascal-case-enums.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+
+// src/utilities/casing-utilities.ts
+var SPLIT_LOWER_TO_UPPER = regex2("([\\p{Ll}\\d])(\\p{Lu})", "gu");
+var SPLIT_UPPER_TO_UPPER = regex2("(\\p{Lu})([\\p{Lu}][\\p{Ll}])", "gu");
+var SPLIT_MARKER = "\x00";
+var SPLIT_REPLACE_VALUE = `$1${SPLIT_MARKER}$2`;
+function toPascalCase(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0)
+    return "";
+  const marked = trimmed.replace(SPLIT_LOWER_TO_UPPER, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_TO_UPPER, SPLIT_REPLACE_VALUE);
+  let start = 0;
+  let { length } = marked;
+  while (marked.charCodeAt(start) === 0)
+    start += 1;
+  if (start === length)
+    return "";
+  while (marked.charCodeAt(length - 1) === 0)
+    length -= 1;
+  let result = "";
+  let wordStart = start;
+  for (let index2 = start;index2 <= length; index2 += 1) {
+    if (index2 !== length && marked.charCodeAt(index2) !== 0)
+      continue;
+    if (index2 > wordStart) {
+      const word = marked.slice(wordStart, index2);
+      const firstByte = word.charCodeAt(0);
+      if (result.length > 0 && firstByte >= 48 && firstByte <= 57)
+        result += "_";
+      result += word[0].toUpperCase() + word.slice(1).toLowerCase();
+    }
+    wordStart = index2 + 1;
+  }
+  return result;
+}
+
+// src/rules/prefer-pascal-case-enums.ts
+var STARTS_WITH_DIGIT = regex2("^\\d");
+function getIdentifierName(node) {
+  if (node.type === AST_NODE_TYPES8.Identifier)
+    return node.name;
+  if (node.type !== AST_NODE_TYPES8.Literal || typeof node.value !== "string")
+    return;
+  return STARTS_WITH_DIGIT.test(node.value) ? undefined : node.value;
+}
+var preferPascalCaseEnums = {
+  create(context) {
+    function report(node, identifier3) {
+      context.report({
+        data: { identifier: identifier3 },
+        messageId: "notPascalCase",
+        node
+      });
+    }
+    return {
+      TSEnumDeclaration(node) {
+        const { name } = node.id;
+        if (toPascalCase(name) === name)
+          return;
+        report(node.id, name);
+      },
+      TSEnumMember(node) {
+        const name = getIdentifierName(node.id);
+        if (name === undefined || toPascalCase(name) === name)
+          return;
+        report(node.id, name);
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforce Pascal case when naming enums."
+    },
+    messages: {
+      notPascalCase: "Enum '{{ identifier }}' should use Pascal case."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+var prefer_pascal_case_enums_default = preferPascalCaseEnums;
 
 // src/rules/prefer-sequence-overloads.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES5.Identifier)
+  if (node.type !== AST_NODE_TYPES9.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -19477,16 +21340,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES5.Literal),
+  type: build_default.Literal(AST_NODE_TYPES9.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES5.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES9.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES5.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES9.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES5.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES9.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -19516,7 +21379,7 @@ var preferSequenceOverloads = {
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES5.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES9.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -19562,6 +21425,147 @@ var preferSequenceOverloads = {
 };
 var prefer_sequence_overloads_default = preferSequenceOverloads;
 
+// src/rules/prefer-singular-enums.ts
+var IRREGULAR_PLURALS = new Set([
+  "children",
+  "dice",
+  "feet",
+  "geese",
+  "men",
+  "mice",
+  "people",
+  "teeth",
+  "women",
+  "criteria",
+  "data",
+  "media",
+  "phenomena",
+  "indices",
+  "matrices",
+  "vertices",
+  "axes",
+  "alumni",
+  "cacti",
+  "fungi",
+  "octopi"
+]);
+var SINGULAR_EXCEPTIONS = new Set([
+  "news",
+  "status",
+  "alias",
+  "analysis",
+  "basis",
+  "thesis",
+  "crisis",
+  "axis",
+  "class",
+  "glass",
+  "series",
+  "species",
+  "business"
+]);
+var PROGRAMMING_PLURALS = new Set([
+  "args",
+  "params",
+  "parameters",
+  "options",
+  "settings",
+  "props",
+  "components",
+  "hooks",
+  "types",
+  "enums",
+  "services",
+  "controllers",
+  "models",
+  "repositories",
+  "dto",
+  "dtos",
+  "vo",
+  "vos",
+  "keys",
+  "values",
+  "entries",
+  "items",
+  "orders",
+  "pages"
+]);
+var SINGULAR_ENUM_REGEX = regex2("[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\\d+", "g");
+function tokenizeIdentifier(name) {
+  const parts = name.split("_");
+  const tokens = new Array;
+  for (const part of parts) {
+    const matches = part.match(SINGULAR_ENUM_REGEX);
+    if (matches)
+      tokens.push(...matches);
+  }
+  return tokens;
+}
+var INTEGER_REGEXP = regex2("^\\d+$");
+function getLastAlphaToken(name) {
+  const tokens = tokenizeIdentifier(name);
+  let alphaToken;
+  for (let index2 = tokens.length - 1;index2 >= 0; index2 -= 1) {
+    const token = tokens[index2];
+    if (token === undefined || INTEGER_REGEXP.test(token))
+      continue;
+    alphaToken = { lower: token.toLowerCase(), original: token };
+    break;
+  }
+  return alphaToken;
+}
+var ACRONYM_REGEXP = regex2("^[A-Z]{2,}[sS]$");
+function isAcronymPlural(original) {
+  return ACRONYM_REGEXP.test(original);
+}
+var ES_VOWELS_REGEXP = regex2("((ch|sh|x|z|ss|o)es|xes|zes|ches|shes|sses|oes)$");
+function isPluralWord(lower, original) {
+  if (IRREGULAR_PLURALS.has(lower) || PROGRAMMING_PLURALS.has(lower))
+    return true;
+  if (SINGULAR_EXCEPTIONS.has(lower))
+    return false;
+  if (isAcronymPlural(original) || lower.endsWith("ies") || lower.endsWith("ves") || ES_VOWELS_REGEXP.test(lower) || lower.endsWith("es")) {
+    return true;
+  }
+  if (lower.endsWith("s"))
+    return !(lower.endsWith("ss") || lower.endsWith("us") || lower.endsWith("is"));
+  return false;
+}
+function isPlural(name) {
+  if (ACRONYM_REGEXP.test(name))
+    return true;
+  const last = getLastAlphaToken(name);
+  return last ? isPluralWord(last.lower, last.original) : false;
+}
+var preferSingularEnums = {
+  create(context) {
+    return {
+      TSEnumDeclaration(node) {
+        const { name } = node.id;
+        if (!isPlural(name))
+          return;
+        context.report({
+          data: { name },
+          messageId: "notSingular",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Prefer singular TypeScript enums."
+    },
+    messages: {
+      notSingular: "Enum '{{ name }}' should be singular."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+var prefer_singular_enums_default = preferSingularEnums;
+
 // src/rules/prefer-udim2-shorthand.ts
 import { TSESTree as TSESTree7 } from "@typescript-eslint/utils";
 function isNumber(value) {
@@ -19576,83 +21580,79 @@ function hasTypeProperty(object3) {
 var OPERATORS2 = new Set(["+", "-", "*", "/", "%"]);
 function reconstructText(node) {
   const nodeType = node.type;
+  let text;
   if (nodeType === TSESTree7.AST_NODE_TYPES.Literal) {
     const { value } = node;
-    return isNumber(value) ? String(value) : undefined;
+    text = isNumber(value) ? String(value) : undefined;
   }
   if (nodeType === TSESTree7.AST_NODE_TYPES.Identifier) {
     const { name } = node;
-    return typeof name === "string" ? name : undefined;
+    text = typeof name === "string" ? name : undefined;
   }
   if (nodeType === TSESTree7.AST_NODE_TYPES.UnaryExpression) {
     const { operator } = node;
-    if (typeof operator !== "string")
-      return;
-    const { argument } = node;
-    if (!isRecord3(argument))
-      return;
-    const text = reconstructText(argument);
-    return text === undefined ? undefined : `${operator}${text}`;
+    if (typeof operator === "string") {
+      const { argument } = node;
+      if (isRecord3(argument)) {
+        const argumentText = reconstructText(argument);
+        if (argumentText !== undefined)
+          text = `${operator}${argumentText}`;
+      }
+    }
   }
   if (nodeType === TSESTree7.AST_NODE_TYPES.BinaryExpression) {
     const { operator } = node;
-    if (typeof operator !== "string" || !OPERATORS2.has(operator))
-      return;
-    const { left, right } = node;
-    if (!(isRecord3(left) && isRecord3(right)))
-      return;
-    const leftText = reconstructText(left);
-    const rightText = reconstructText(right);
-    return leftText === undefined || rightText === undefined ? undefined : `${leftText} ${operator} ${rightText}`;
+    if (typeof operator === "string" && OPERATORS2.has(operator)) {
+      const { left, right } = node;
+      if (isRecord3(left) && isRecord3(right)) {
+        const leftText = reconstructText(left);
+        const rightText = reconstructText(right);
+        if (leftText !== undefined && rightText !== undefined)
+          text = `${leftText} ${operator} ${rightText}`;
+      }
+    }
   }
-  return;
+  return text;
 }
 function evaluateExpression(node) {
   if (!isRecord3(node))
     return;
   const nodeType = node.type;
+  let value;
   if (nodeType === TSESTree7.AST_NODE_TYPES.Literal) {
-    const { value } = node;
-    return isNumber(value) ? value : undefined;
+    const { value: literalValue } = node;
+    value = isNumber(literalValue) ? literalValue : undefined;
   }
   if (nodeType === TSESTree7.AST_NODE_TYPES.UnaryExpression) {
     const { argument, operator } = node;
-    if (typeof argument === "object" && argument !== null) {
-      const value = evaluateExpression(argument);
-      if (value === undefined)
-        return;
-      if (operator === "-")
-        return -value;
-      if (operator === "+")
-        return value;
+    if (isRecord3(argument)) {
+      const argumentValue = evaluateExpression(argument);
+      if (operator === "-" && argumentValue !== undefined)
+        value = -argumentValue;
+      if (operator === "+" && argumentValue !== undefined)
+        value = argumentValue;
     }
-    return;
   }
   if (nodeType === TSESTree7.AST_NODE_TYPES.BinaryExpression) {
     const { right, left, operator } = node;
-    if (typeof left === "object" && left !== null && typeof right === "object" && right !== null) {
+    if (isRecord3(left) && isRecord3(right) && typeof operator === "string" && OPERATORS2.has(operator)) {
       const leftValue = evaluateExpression(left);
       const rightValue = evaluateExpression(right);
-      if (leftValue === undefined || rightValue === undefined)
-        return;
-      switch (operator) {
-        case "+":
-          return leftValue + rightValue;
-        case "-":
-          return leftValue - rightValue;
-        case "*":
-          return leftValue * rightValue;
-        case "/":
-          return rightValue === 0 ? undefined : leftValue / rightValue;
-        case "%":
-          return rightValue === 0 ? undefined : leftValue % rightValue;
-        default:
-          return;
+      if (leftValue !== undefined && rightValue !== undefined) {
+        if (operator === "+")
+          value = leftValue + rightValue;
+        if (operator === "-")
+          value = leftValue - rightValue;
+        if (operator === "*")
+          value = leftValue * rightValue;
+        if (operator === "/")
+          value = rightValue === 0 ? undefined : leftValue / rightValue;
+        if (operator === "%")
+          value = rightValue === 0 ? undefined : leftValue % rightValue;
       }
     }
-    return;
   }
-  return;
+  return value;
 }
 function collectArguments(_context2, parameters3) {
   if (parameters3.length !== 4)
@@ -19724,6 +21724,145 @@ var preferUDim2Shorthand = {
 };
 var prefer_udim2_shorthand_default = preferUDim2Shorthand;
 
+// src/rules/react-hooks-strict-return.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
+var MAX_RETURN_ELEMENTS = 2;
+var HOOK_PATTERN = /^use[A-Z0-9].*$/;
+function isHookNode(node) {
+  let name;
+  if (node.type === AST_NODE_TYPES10.VariableDeclarator && node.id.type === AST_NODE_TYPES10.Identifier) {
+    ({ name } = node.id);
+  } else if (node.type === AST_NODE_TYPES10.FunctionDeclaration && node.id)
+    ({ name } = node.id);
+  else if (node.type === AST_NODE_TYPES10.FunctionExpression && node.id)
+    ({ name } = node.id);
+  return name !== undefined && HOOK_PATTERN.test(name);
+}
+function getVariableByName(scope, name) {
+  let current = scope;
+  while (current) {
+    const variable = current.set.get(name);
+    if (variable)
+      return variable;
+    current = current.upper;
+  }
+  return;
+}
+function getArrayElementsFromVariable(scope, name) {
+  const variable = getVariableByName(scope, name);
+  if (!variable)
+    return [];
+  const elements = new Array;
+  for (const ref6 of variable.references) {
+    const { identifier: identifier3 } = ref6;
+    if (!identifier3.parent)
+      continue;
+    const { parent } = identifier3;
+    if (parent.type !== AST_NODE_TYPES10.VariableDeclarator)
+      continue;
+    if (!parent.init || parent.init.type !== AST_NODE_TYPES10.ArrayExpression)
+      continue;
+    elements.push(...parent.init.elements);
+  }
+  return elements;
+}
+function countReturnElements(argument, scope) {
+  if (argument.type === AST_NODE_TYPES10.Identifier)
+    return getArrayElementsFromVariable(scope, argument.name).length;
+  if (argument.type !== AST_NODE_TYPES10.ArrayExpression)
+    return 0;
+  let count = 0;
+  for (const element of argument.elements) {
+    if (element === null)
+      count += 1;
+    else if (element.type === AST_NODE_TYPES10.SpreadElement) {
+      if (element.argument.type === AST_NODE_TYPES10.Identifier) {
+        count += getArrayElementsFromVariable(scope, element.argument.name).length;
+      } else if (element.argument.type === AST_NODE_TYPES10.ArrayExpression) {
+        count += element.argument.elements.length;
+      } else
+        count += 1;
+    } else
+      count += 1;
+  }
+  return count;
+}
+function exceedsMaxReturnProperties(node, scope) {
+  const { argument } = node;
+  if (argument === null)
+    return false;
+  if (argument.type === AST_NODE_TYPES10.ObjectExpression)
+    return false;
+  if (argument.type === AST_NODE_TYPES10.Identifier) {
+    const variable = getVariableByName(scope, argument.name);
+    if (variable) {
+      for (const { identifier: identifier3 } of variable.references) {
+        const { parent } = identifier3;
+        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.init?.type === AST_NODE_TYPES10.ObjectExpression) {
+          return false;
+        }
+      }
+    }
+  }
+  return countReturnElements(argument, scope) > MAX_RETURN_ELEMENTS;
+}
+var reactHooksStrictReturn = {
+  create(context) {
+    let hookDepth = 0;
+    function enterHook(node) {
+      if (isHookNode(node))
+        hookDepth += 1;
+    }
+    function exitHook(node) {
+      if (isHookNode(node))
+        hookDepth -= 1;
+    }
+    return {
+      ArrowFunctionExpression(node) {
+        const { parent } = node;
+        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.id.type === AST_NODE_TYPES10.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+          hookDepth += 1;
+        }
+      },
+      "ArrowFunctionExpression:exit"(node) {
+        const { parent } = node;
+        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.id.type === AST_NODE_TYPES10.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+          hookDepth -= 1;
+        }
+      },
+      FunctionDeclaration: enterHook,
+      "FunctionDeclaration:exit": exitHook,
+      FunctionExpression: enterHook,
+      "FunctionExpression:exit": exitHook,
+      ReturnStatement(node) {
+        if (hookDepth === 0)
+          return;
+        const scope = context.sourceCode.getScope(node);
+        if (exceedsMaxReturnProperties(node, scope)) {
+          context.report({
+            messageId: "hooksStrictReturn",
+            node
+          });
+        }
+      },
+      VariableDeclarator: enterHook,
+      "VariableDeclarator:exit": exitHook
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Restrict the number of returned items from React hooks."
+    },
+    messages: {
+      hooksStrictReturn: "React hooks must return a tuple of two or fewer values or a single object."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+var react_hooks_strict_return_default = reactHooksStrictReturn;
+
 // src/rules/require-named-effect-functions.ts
 import { TSESTree as TSESTree8 } from "@typescript-eslint/types";
 var DEFAULT_HOOKS = [
@@ -20057,7 +22196,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
 var isStringArray = Compile(build_default.Readonly(build_default.Array(build_default.String())));
 var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   alternatives: build_default.Optional(isStringArray),
@@ -20075,20 +22214,20 @@ var isRuleOptions3 = Compile(build_default.Partial(build_default.Readonly(build_
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES6.DoWhileStatement,
-  AST_NODE_TYPES6.ForInStatement,
-  AST_NODE_TYPES6.ForOfStatement,
-  AST_NODE_TYPES6.ForStatement,
-  AST_NODE_TYPES6.WhileStatement
+  AST_NODE_TYPES11.DoWhileStatement,
+  AST_NODE_TYPES11.ForInStatement,
+  AST_NODE_TYPES11.ForOfStatement,
+  AST_NODE_TYPES11.ForStatement,
+  AST_NODE_TYPES11.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES6.Identifier)
+  if (callee.type === AST_NODE_TYPES11.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES6.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES6.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES6.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES11.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES11.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES11.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -20124,12 +22263,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES6.SwitchStatement;
+  return node?.type === AST_NODE_TYPES11.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES6.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES11.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -20382,7 +22521,7 @@ var rule = {
     function onIfConsequentExit(node) {
       const consequentNode = node;
       const { parent } = consequentNode;
-      if (parent?.type === AST_NODE_TYPES6.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES11.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -20397,7 +22536,7 @@ var rule = {
     function onIfAlternateExit(node) {
       const alternateNode = node;
       const { parent } = alternateNode;
-      if (parent?.type === AST_NODE_TYPES6.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES11.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -20446,7 +22585,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES6.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES11.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -20465,7 +22604,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES6.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES11.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -20528,7 +22667,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES6.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES11.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -20559,7 +22698,7 @@ var rule = {
       for (const { opener, config, node: node2 } of openerStack) {
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES6.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES11.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -20576,7 +22715,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES6.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES11.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -20584,7 +22723,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES6.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES11.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -20722,7 +22861,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const asyncType = asyncNode.type === AST_NODE_TYPES6.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES11.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -21244,6 +23383,116 @@ var requireReactComponentKeys = {
 };
 var require_react_component_keys_default = requireReactComponentKeys;
 
+// src/rules/strict-component-boundaries.ts
+import { basename, extname, relative } from "node:path";
+
+// src/utilities/resolve-import.ts
+var import_oxc_resolver = __toESM(require_oxc_resolver(), 1);
+import { dirname } from "node:path";
+var resolver = new import_oxc_resolver.ResolverFactory({
+  extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".node"]
+});
+function resolveRelativeImport(importSource, sourceFile) {
+  if (!importSource.startsWith("."))
+    return { found: false };
+  const { path: path2 } = resolver.sync(dirname(sourceFile), importSource);
+  if (path2 === undefined || path2 === "")
+    return { found: false };
+  return { found: true, path: path2 };
+}
+
+// src/rules/strict-component-boundaries.ts
+function toRegExp(pattern4) {
+  return new RegExp(pattern4, "i");
+}
+function pathSegmentsFromSource(source) {
+  return source.split("/").filter((part) => !part.startsWith("."));
+}
+function countParentTraversals(pathDiff) {
+  return pathDiff.split("/").filter((part) => part === "..").length;
+}
+function hasAnotherComponentInPath(pathParts) {
+  return pathParts.some((part) => part === toPascalCase(part) && !part.includes("."));
+}
+function hasDirectoryInPath(pathParts, directory) {
+  return pathParts.includes(directory);
+}
+function isIndexFile(filePath) {
+  return basename(filePath, extname(filePath)) === "index";
+}
+function isValidFixtureImport(pathParts) {
+  if (!hasDirectoryInPath(pathParts, "fixtures"))
+    return false;
+  const fixtureIndex = pathParts.indexOf("fixtures");
+  const partsBeforeFixture = pathParts.slice(0, fixtureIndex);
+  return !hasAnotherComponentInPath(partsBeforeFixture);
+}
+var strictComponentBoundaries = {
+  create(context) {
+    const [{ allow = [], maxDepth = 1 } = {}] = context.options;
+    const allowPatterns = allow.map(toRegExp);
+    return {
+      ImportDeclaration(node) {
+        const importSource = node.source.value;
+        if (typeof importSource !== "string" || !importSource.startsWith("."))
+          return;
+        if (allowPatterns.some((regexp) => regexp.test(importSource)))
+          return;
+        const filename = context.filename ?? "";
+        if (filename === "")
+          return;
+        const resolved = resolveRelativeImport(importSource, filename);
+        if (!resolved.found)
+          return;
+        const pathDifference = relative(filename, resolved.path);
+        const pathParts = pathSegmentsFromSource(pathDifference);
+        const traversals = countParentTraversals(pathDifference);
+        const isDescendingOnly = traversals <= 1;
+        const hasComponentsDir = hasDirectoryInPath(pathParts, "components");
+        if ((!isDescendingOnly || hasComponentsDir) && hasAnotherComponentInPath(pathParts) && pathParts.length > maxDepth && !isIndexFile(pathDifference) && !isValidFixtureImport(pathParts)) {
+          context.report({
+            messageId: "noReachingIntoComponent",
+            node
+          });
+          return;
+        }
+        if (hasDirectoryInPath(pathParts, "components") && pathParts.length > maxDepth + 1 && !isValidFixtureImport(pathParts)) {
+          context.report({
+            messageId: "noReachingIntoComponent",
+            node
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description: "Prevent module imports between components."
+    },
+    messages: {
+      noReachingIntoComponent: "Do not reach into an individual component's folder for nested modules. Import from the closest shared components folder instead."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allow: {
+            items: { type: "string" },
+            type: "array"
+          },
+          maxDepth: {
+            type: "integer"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var strict_component_boundaries_default = strictComponentBoundaries;
+
 // src/rules/use-exhaustive-dependencies.ts
 import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
 var FUNCTION_DECLARATIONS = new Set([
@@ -21569,13 +23818,13 @@ function collectCaptures(node, sourceCode) {
   const captureSet = new Set;
   function visit(current) {
     if (current.type === TSESTree10.AST_NODE_TYPES.Identifier) {
-      const { name } = current;
-      if (captureSet.has(name) || GLOBAL_BUILTINS.has(name) || isInTypePosition(current))
+      const { name: name2 } = current;
+      if (captureSet.has(name2) || GLOBAL_BUILTINS.has(name2) || isInTypePosition(current))
         return;
       let variable;
       let currentScope = sourceCode.getScope(current);
       while (currentScope) {
-        variable = currentScope.set.get(name);
+        variable = currentScope.set.get(name2);
         if (variable)
           break;
         currentScope = currentScope.upper;
@@ -21595,14 +23844,14 @@ function collectCaptures(node, sourceCode) {
             testingMetrics.outerScopeSkip += 1;
             return;
           }
-          captureSet.add(name);
+          captureSet.add(name2);
           const depthNode = findTopmostMemberExpression(current);
           const usagePath = nodeToSafeDependencyPath(depthNode, sourceCode);
           const depth = getMemberExpressionDepth(depthNode);
           captures.push({
             depth,
             forceDependency: isComputedPropertyIdentifier(current),
-            name,
+            name: name2,
             node: depthNode,
             usagePath,
             variable
@@ -21650,18 +23899,18 @@ function parseDependencies(node, sourceCode) {
     if (!element)
       continue;
     const actualNode = element.type === TSESTree10.AST_NODE_TYPES.SpreadElement ? element.argument : element;
-    const name = nodeToDependencyString(actualNode, sourceCode);
+    const name2 = nodeToDependencyString(actualNode, sourceCode);
     const depth = getMemberExpressionDepth(actualNode);
     dependencies4.push({
       depth,
-      name,
+      name: name2,
       node: actualNode
     });
   }
   return dependencies4;
 }
-function returnName({ name }) {
-  return name;
+function returnName({ name: name2 }) {
+  return name2;
 }
 function isUnstableValue(node) {
   return node ? UNSTABLE_VALUES.has(node.type) : false;
@@ -21795,7 +24044,7 @@ var useExhaustiveDependencies = {
           }
           const maxCaptureDepth = Math.max(...matchingCaptures.map(({ depth }) => depth));
           if (dependency.depth > maxCaptureDepth && options3.reportUnnecessaryDependencies) {
-            const newDependencies = dependencies4.filter(({ name }) => name !== dependency.name).map(returnName);
+            const newDependencies = dependencies4.filter(({ name: name2 }) => name2 !== dependency.name).map(returnName);
             const dependencyString = `[${newDependencies.join(", ")}]`;
             context.report({
               data: { name: dependency.name },
@@ -21833,7 +24082,7 @@ var useExhaustiveDependencies = {
             missingCaptures.push(capture);
         }
         if (missingCaptures.length > 0) {
-          const dependencyNames = dependencies4.map(({ name }) => name);
+          const dependencyNames = dependencies4.map(({ name: name2 }) => name2);
           const missingPaths = missingCaptures.map(({ usagePath }) => usagePath);
           const newDependencies = [...dependencyNames, ...missingPaths].toSorted();
           const newDependenciesString = `[${newDependencies.join(", ")}]`;
@@ -21975,32 +24224,32 @@ var use_exhaustive_dependencies_default = useExhaustiveDependencies;
 import { TSESTree as TSESTree11 } from "@typescript-eslint/types";
 var HOOK_NAME_PATTERN = /^use[A-Z]/;
 var COMPONENT_NAME_PATTERN2 = /^[A-Z]/;
-function isReactHook(name) {
-  return HOOK_NAME_PATTERN.test(name);
+function isReactHook(name2) {
+  return HOOK_NAME_PATTERN.test(name2);
 }
-function isComponent(name) {
-  return COMPONENT_NAME_PATTERN2.test(name);
+function isComponent(name2) {
+  return COMPONENT_NAME_PATTERN2.test(name2);
 }
 function isComponentOrHook(node) {
   if (node.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration && node.id) {
-    const { name } = node.id;
-    return isComponent(name) || isReactHook(name);
+    const { name: name2 } = node.id;
+    return isComponent(name2) || isReactHook(name2);
   }
   if (node.type === TSESTree11.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
-    if (!parent)
+    if (parent === undefined)
       return false;
     if (parent.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree11.AST_NODE_TYPES.Identifier) {
-      const { name } = parent.id;
-      return isComponent(name) || isReactHook(name);
+      const { name: name2 } = parent.id;
+      return isComponent(name2) || isReactHook(name2);
     }
     if (parent.type === TSESTree11.AST_NODE_TYPES.Property && parent.key.type === TSESTree11.AST_NODE_TYPES.Identifier) {
-      const { name } = parent.key;
-      return isComponent(name) || isReactHook(name);
+      const { name: name2 } = parent.key;
+      return isComponent(name2) || isReactHook(name2);
     }
     if (parent.type === TSESTree11.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree11.AST_NODE_TYPES.Identifier) {
-      const { name } = parent.key;
-      return isComponent(name) || isReactHook(name);
+      const { name: name2 } = parent.key;
+      return isComponent(name2) || isReactHook(name2);
     }
   }
   return false;
@@ -22021,21 +24270,24 @@ var FUNCTION_BOUNDARIES2 = new Set([
 function isInFinallyBlock(node) {
   let current = node.parent;
   const maxDepth = 20;
+  let inFinallyBlock = false;
   for (let depth = 0;depth < maxDepth && current; depth += 1) {
     if (FUNCTION_BOUNDARIES2.has(current.type))
-      return false;
+      break;
     if (current.type === TSESTree11.AST_NODE_TYPES.TryStatement) {
       let checkNode = node;
       while (checkNode && checkNode !== current) {
-        if (checkNode === current.finalizer)
-          return true;
+        if (checkNode === current.finalizer) {
+          inFinallyBlock = true;
+          break;
+        }
         checkNode = checkNode.parent;
       }
-      return false;
+      break;
     }
     current = current.parent;
   }
-  return false;
+  return inFinallyBlock;
 }
 function isRecursiveCall(node, functionName) {
   if (!functionName)
@@ -22094,8 +24346,9 @@ var useHookAtTopLevel = {
       const current = getCurrentContext();
       const depth = current ? current.functionDepth + 1 : 0;
       const isComponentOrHookFlag = isComponentOrHook(functionNode);
-      if (functionNode.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration && functionNode.id)
+      if (functionNode.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration && functionNode.id) {
         currentFunctionName = functionNode.id.name;
+      }
       if (current?.isComponentOrHook) {
         pushContext({
           afterEarlyReturn: false,
@@ -22348,8 +24601,8 @@ function createNoShorthandOptions(options3 = {}) {
 function createEffectFunctionOptions(options3 = {}) {
   return { environment: "standard", hooks: [], ...options3 };
 }
-function createHookConfiguration(name, options3 = {}) {
-  return { allowAsync: false, name, ...options3 };
+function createHookConfiguration(name2, options3 = {}) {
+  return { allowAsync: false, name: name2, ...options3 };
 }
 function createRequirePairedCallsOptions(options3 = {}) {
   return {
@@ -22423,11 +24676,18 @@ var rules = {
   "no-shorthand-names": no_shorthand_names_default,
   "no-useless-use-spring": no_useless_use_spring_default,
   "no-warn": no_warn_default,
+  "prefer-class-properties": prefer_class_properties_default,
+  "prefer-early-return": prefer_early_return_default,
+  "prefer-module-scope-constants": prefer_module_scope_constants_default,
+  "prefer-pascal-case-enums": prefer_pascal_case_enums_default,
   "prefer-sequence-overloads": prefer_sequence_overloads_default,
+  "prefer-singular-enums": prefer_singular_enums_default,
   "prefer-udim2-shorthand": prefer_udim2_shorthand_default,
+  "react-hooks-strict-return": react_hooks_strict_return_default,
   "require-named-effect-functions": require_named_effect_functions_default,
   "require-paired-calls": require_paired_calls_default,
   "require-react-component-keys": require_react_component_keys_default,
+  "strict-component-boundaries": strict_component_boundaries_default,
   "use-exhaustive-dependencies": use_exhaustive_dependencies_default,
   "use-hook-at-top-level": use_hook_at_top_level_default
 };
@@ -22478,4 +24738,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=7DA0BA55D13FFCAD64756E2164756E21
+//# debugId=746CFBCF1D469D6C64756E2164756E21