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

package/dist/index.js

@@ -25,9 +25,732 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
-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 = {
@@ -6306,11 +7029,11 @@ var require_Visitor = __commonJS((exports) => {
   var PatternVisitor_1 = require_PatternVisitor();
   var VisitorBase_1 = require_VisitorBase();
 
-  class Visitor2 extends VisitorBase_1.VisitorBase {
+  class Visitor extends VisitorBase_1.VisitorBase {
     #options;
     constructor(optionsOrVisitor) {
-      super(optionsOrVisitor instanceof Visitor2 ? optionsOrVisitor.#options : optionsOrVisitor);
-      this.#options = optionsOrVisitor instanceof Visitor2 ? optionsOrVisitor.#options : optionsOrVisitor;
+      super(optionsOrVisitor instanceof Visitor ? optionsOrVisitor.#options : optionsOrVisitor);
+      this.#options = optionsOrVisitor instanceof Visitor ? optionsOrVisitor.#options : optionsOrVisitor;
     }
     visitPattern(node, callback, options3 = { processRightHandNodes: false }) {
       const visitor = new PatternVisitor_1.PatternVisitor(this.#options, node, callback);
@@ -6320,7 +7043,7 @@ var require_Visitor = __commonJS((exports) => {
       }
     }
   }
-  exports.Visitor = Visitor2;
+  exports.Visitor = Visitor;
   var VisitorBase_2 = require_VisitorBase();
   Object.defineProperty(exports, "VisitorBase", { enumerable: true, get: function() {
     return VisitorBase_2.VisitorBase;
@@ -15435,19 +16158,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 +16275,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 +16314,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 +16335,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 +16444,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 +16455,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 +16482,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 +16493,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 +16510,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 +16544,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 +16556,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 +16567,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 +17061,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 +17148,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 +17192,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 = {
@@ -16892,955 +17676,68 @@ var no_color3_constructor_default = noColor3Constructor;
 
 // src/rules/no-commented-code.ts
 import path from "node:path";
+import { parseSync } from "oxc-parser";
 
-// node_modules/oxc-parser/src-js/index.js
-import { createRequire as createRequire4 } from "node:module";
+// src/recognizers/detector.ts
+function recognize(detector, line) {
+  const matches = detector.scan(line);
+  if (matches === 0)
+    return 0;
+  return 1 - (1 - detector.probability) ** matches;
+}
 
-// node_modules/oxc-parser/src-js/bindings.js
-import { createRequire as createRequire2 } from "node:module";
-var require2 = createRequire2(import.meta.url);
-var __dirname2 = new URL(".", import.meta.url).pathname;
-var { readFileSync: readFileSync2 } = require2("node:fs");
-var nativeBinding = null;
-var loadErrors = [];
-var isMusl = () => {
-  let musl = false;
-  if (process.platform === "linux") {
-    musl = isMuslFromFilesystem();
-    if (musl === null) {
-      musl = isMuslFromReport();
-    }
-    if (musl === null) {
-      musl = isMuslFromChildProcess();
-    }
-  }
-  return musl;
-};
-var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
-var isMuslFromFilesystem = () => {
-  try {
-    return readFileSync2("/usr/bin/ldd", "utf-8").includes("musl");
-  } catch {
-    return null;
-  }
-};
-var isMuslFromReport = () => {
-  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(isFileMusl)) {
-      return true;
-    }
-  }
-  return false;
-};
-var isMuslFromChildProcess = () => {
-  try {
-    return require2("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
-  } catch (e) {
-    return false;
+// src/recognizers/code-recognizer.ts
+var PROBABILITY_THRESHOLD = 0.9;
+function computeProbability(detectors, line) {
+  let probability = 0;
+  for (const detector of detectors) {
+    const detected = recognize(detector, line);
+    probability = 1 - (1 - probability) * (1 - detected);
   }
-};
-function requireNative() {
-  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
-    try {
-      return require2(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
-    } catch (err) {
-      loadErrors.push(err);
-    }
-  } else if (process.platform === "android") {
-    if (process.arch === "arm64") {
-      try {
-        return require2("./parser.android-arm64.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-android-arm64");
-        const bindingPackageVersion = require2("@oxc-parser/binding-android-arm64/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+  return probability;
+}
+function isLikelyCode(detectors, line) {
+  return computeProbability(detectors, line) >= PROBABILITY_THRESHOLD;
+}
+function hasCodeLines(detectors, lines) {
+  return lines.some((line) => isLikelyCode(detectors, line));
+}
+
+// src/recognizers/camel-case-detector.ts
+function createCamelCaseDetector(probability) {
+  return {
+    probability,
+    scan(line) {
+      for (let index2 = 0;index2 < line.length - 1; index2 += 1) {
+        const current = line.charAt(index2);
+        const next = line.charAt(index2 + 1);
+        if (current === current.toLowerCase() && next === next.toUpperCase() && next !== next.toLowerCase()) {
+          return 1;
         }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else if (process.arch === "arm") {
-      try {
-        return require2("./parser.android-arm-eabi.node");
-      } catch (e) {
-        loadErrors.push(e);
       }
-      try {
-        const binding = require2("@oxc-parser/binding-android-arm-eabi");
-        const bindingPackageVersion = require2("@oxc-parser/binding-android-arm-eabi/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else {
-      loadErrors.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 require2("./parser.win32-x64-gnu.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-win32-x64-gnu");
-          const bindingPackageVersion = require2("@oxc-parser/binding-win32-x64-gnu/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        try {
-          return require2("./parser.win32-x64-msvc.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-win32-x64-msvc");
-          const bindingPackageVersion = require2("@oxc-parser/binding-win32-x64-msvc/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      }
-    } else if (process.arch === "ia32") {
-      try {
-        return require2("./parser.win32-ia32-msvc.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-win32-ia32-msvc");
-        const bindingPackageVersion = require2("@oxc-parser/binding-win32-ia32-msvc/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else if (process.arch === "arm64") {
-      try {
-        return require2("./parser.win32-arm64-msvc.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-win32-arm64-msvc");
-        const bindingPackageVersion = require2("@oxc-parser/binding-win32-arm64-msvc/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
-    }
-  } else if (process.platform === "darwin") {
-    try {
-      return require2("./parser.darwin-universal.node");
-    } catch (e) {
-      loadErrors.push(e);
-    }
-    try {
-      const binding = require2("@oxc-parser/binding-darwin-universal");
-      const bindingPackageVersion = require2("@oxc-parser/binding-darwin-universal/package.json").version;
-      if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-      }
-      return binding;
-    } catch (e) {
-      loadErrors.push(e);
-    }
-    if (process.arch === "x64") {
-      try {
-        return require2("./parser.darwin-x64.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-darwin-x64");
-        const bindingPackageVersion = require2("@oxc-parser/binding-darwin-x64/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else if (process.arch === "arm64") {
-      try {
-        return require2("./parser.darwin-arm64.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-darwin-arm64");
-        const bindingPackageVersion = require2("@oxc-parser/binding-darwin-arm64/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
-    }
-  } else if (process.platform === "freebsd") {
-    if (process.arch === "x64") {
-      try {
-        return require2("./parser.freebsd-x64.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-freebsd-x64");
-        const bindingPackageVersion = require2("@oxc-parser/binding-freebsd-x64/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else if (process.arch === "arm64") {
-      try {
-        return require2("./parser.freebsd-arm64.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-freebsd-arm64");
-        const bindingPackageVersion = require2("@oxc-parser/binding-freebsd-arm64/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
-    }
-  } else if (process.platform === "linux") {
-    if (process.arch === "x64") {
-      if (isMusl()) {
-        try {
-          return require2("./parser.linux-x64-musl.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-x64-musl");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-x64-musl/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        try {
-          return require2("./parser.linux-x64-gnu.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-x64-gnu");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-x64-gnu/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      }
-    } else if (process.arch === "arm64") {
-      if (isMusl()) {
-        try {
-          return require2("./parser.linux-arm64-musl.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-arm64-musl");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm64-musl/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        try {
-          return require2("./parser.linux-arm64-gnu.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-arm64-gnu");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm64-gnu/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      }
-    } else if (process.arch === "arm") {
-      if (isMusl()) {
-        try {
-          return require2("./parser.linux-arm-musleabihf.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-arm-musleabihf");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm-musleabihf/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        try {
-          return require2("./parser.linux-arm-gnueabihf.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-arm-gnueabihf");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-arm-gnueabihf/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      }
-    } else if (process.arch === "loong64") {
-      if (isMusl()) {
-        try {
-          return require2("./parser.linux-loong64-musl.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-loong64-musl");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-loong64-musl/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        try {
-          return require2("./parser.linux-loong64-gnu.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-loong64-gnu");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-loong64-gnu/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      }
-    } else if (process.arch === "riscv64") {
-      if (isMusl()) {
-        try {
-          return require2("./parser.linux-riscv64-musl.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-riscv64-musl");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-riscv64-musl/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      } else {
-        try {
-          return require2("./parser.linux-riscv64-gnu.node");
-        } catch (e) {
-          loadErrors.push(e);
-        }
-        try {
-          const binding = require2("@oxc-parser/binding-linux-riscv64-gnu");
-          const bindingPackageVersion = require2("@oxc-parser/binding-linux-riscv64-gnu/package.json").version;
-          if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-          }
-          return binding;
-        } catch (e) {
-          loadErrors.push(e);
-        }
-      }
-    } else if (process.arch === "ppc64") {
-      try {
-        return require2("./parser.linux-ppc64-gnu.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-linux-ppc64-gnu");
-        const bindingPackageVersion = require2("@oxc-parser/binding-linux-ppc64-gnu/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else if (process.arch === "s390x") {
-      try {
-        return require2("./parser.linux-s390x-gnu.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-linux-s390x-gnu");
-        const bindingPackageVersion = require2("@oxc-parser/binding-linux-s390x-gnu/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
-    }
-  } else if (process.platform === "openharmony") {
-    if (process.arch === "arm64") {
-      try {
-        return require2("./parser.openharmony-arm64.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-openharmony-arm64");
-        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-arm64/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else if (process.arch === "x64") {
-      try {
-        return require2("./parser.openharmony-x64.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-openharmony-x64");
-        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-x64/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else if (process.arch === "arm") {
-      try {
-        return require2("./parser.openharmony-arm.node");
-      } catch (e) {
-        loadErrors.push(e);
-      }
-      try {
-        const binding = require2("@oxc-parser/binding-openharmony-arm");
-        const bindingPackageVersion = require2("@oxc-parser/binding-openharmony-arm/package.json").version;
-        if (bindingPackageVersion !== "0.104.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 0.104.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
-        }
-        return binding;
-      } catch (e) {
-        loadErrors.push(e);
-      }
-    } else {
-      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
-    }
-  } else {
-    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
-  }
-}
-nativeBinding = requireNative();
-if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
-  let wasiBinding = null;
-  let wasiBindingError = null;
-  try {
-    wasiBinding = require2("./parser.wasi.cjs");
-    nativeBinding = wasiBinding;
-  } catch (err) {
-    if (process.env.NAPI_RS_FORCE_WASI) {
-      wasiBindingError = err;
-    }
-  }
-  if (!nativeBinding) {
-    try {
-      wasiBinding = require2("@oxc-parser/binding-wasm32-wasi");
-      nativeBinding = wasiBinding;
-    } catch (err) {
-      if (process.env.NAPI_RS_FORCE_WASI) {
-        wasiBindingError.cause = err;
-        loadErrors.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 (!nativeBinding && globalThis.process?.versions?.["webcontainer"]) {
-  try {
-    nativeBinding = require2("./webcontainer-fallback.cjs");
-  } catch (err) {
-    loadErrors.push(err);
-  }
-}
-if (!nativeBinding) {
-  if (loadErrors.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: loadErrors.reduce((err, cur) => {
-        cur.cause = err;
-        return cur;
-      })
-    });
-  }
-  throw new Error(`Failed to load native binding`);
-}
-var { Severity, ParseResult, ExportExportNameKind, ExportImportNameKind, ExportLocalNameKind, ImportNameKind, parse: parse3, parseSync, rawTransferSupported } = nativeBinding;
-
-// node_modules/oxc-parser/src-js/wrap.js
-function wrap(result) {
-  let program, module3, comments, errors4;
-  return {
-    get program() {
-      if (!program)
-        program = jsonParseAst(result.program);
-      return program;
-    },
-    get module() {
-      if (!module3)
-        module3 = result.module;
-      return module3;
-    },
-    get comments() {
-      if (!comments)
-        comments = result.comments;
-      return comments;
-    },
-    get errors() {
-      if (!errors4)
-        errors4 = result.errors;
-      return errors4;
-    }
-  };
-}
-function jsonParseAst(programJson) {
-  const { node: program, fixes } = JSON.parse(programJson);
-  for (const fixPath of fixes) {
-    applyFix(program, fixPath);
-  }
-  return program;
-}
-function applyFix(program, fixPath) {
-  let node = program;
-  for (const key of fixPath) {
-    node = node[key];
-  }
-  if (node.bigint) {
-    node.value = BigInt(node.bigint);
-  } else {
-    try {
-      node.value = RegExp(node.regex.pattern, node.regex.flags);
-    } catch {}
-  }
-}
-
-// node_modules/oxc-parser/src-js/generated/visit/keys.js
-var { freeze } = Object;
-var $EMPTY = freeze([]);
-var DECORATORS__KEY__TYPE_ANNOTATION__VALUE = freeze([
-  "decorators",
-  "key",
-  "typeAnnotation",
-  "value"
-]);
-var LEFT__RIGHT = freeze(["left", "right"]);
-var ARGUMENT = freeze(["argument"]);
-var BODY = freeze(["body"]);
-var LABEL = freeze(["label"]);
-var CALLEE__TYPE_ARGUMENTS__ARGUMENTS = freeze(["callee", "typeArguments", "arguments"]);
-var EXPRESSION = freeze(["expression"]);
-var DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY = freeze([
-  "decorators",
-  "id",
-  "typeParameters",
-  "superClass",
-  "superTypeArguments",
-  "implements",
-  "body"
-]);
-var TEST__CONSEQUENT__ALTERNATE = freeze(["test", "consequent", "alternate"]);
-var LEFT__RIGHT__BODY = freeze(["left", "right", "body"]);
-var ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY = freeze([
-  "id",
-  "typeParameters",
-  "params",
-  "returnType",
-  "body"
-]);
-var KEY__VALUE = freeze(["key", "value"]);
-var LOCAL = freeze(["local"]);
-var OBJECT__PROPERTY = freeze(["object", "property"]);
-var DECORATORS__KEY__TYPE_ANNOTATION = freeze(["decorators", "key", "typeAnnotation"]);
-var EXPRESSION__TYPE_ANNOTATION = freeze(["expression", "typeAnnotation"]);
-var TYPE_PARAMETERS__PARAMS__RETURN_TYPE = freeze(["typeParameters", "params", "returnType"]);
-var EXPRESSION__TYPE_ARGUMENTS = freeze(["expression", "typeArguments"]);
-var MEMBERS = freeze(["members"]);
-var ID__BODY = freeze(["id", "body"]);
-var TYPES = freeze(["types"]);
-var TYPE_ANNOTATION = freeze(["typeAnnotation"]);
-var PARAMS = freeze(["params"]);
-var keys_default = freeze({
-  DebuggerStatement: $EMPTY,
-  EmptyStatement: $EMPTY,
-  Literal: $EMPTY,
-  PrivateIdentifier: $EMPTY,
-  Super: $EMPTY,
-  TemplateElement: $EMPTY,
-  ThisExpression: $EMPTY,
-  JSXClosingFragment: $EMPTY,
-  JSXEmptyExpression: $EMPTY,
-  JSXIdentifier: $EMPTY,
-  JSXOpeningFragment: $EMPTY,
-  JSXText: $EMPTY,
-  TSAnyKeyword: $EMPTY,
-  TSBigIntKeyword: $EMPTY,
-  TSBooleanKeyword: $EMPTY,
-  TSIntrinsicKeyword: $EMPTY,
-  TSJSDocUnknownType: $EMPTY,
-  TSNeverKeyword: $EMPTY,
-  TSNullKeyword: $EMPTY,
-  TSNumberKeyword: $EMPTY,
-  TSObjectKeyword: $EMPTY,
-  TSStringKeyword: $EMPTY,
-  TSSymbolKeyword: $EMPTY,
-  TSThisType: $EMPTY,
-  TSUndefinedKeyword: $EMPTY,
-  TSUnknownKeyword: $EMPTY,
-  TSVoidKeyword: $EMPTY,
-  AccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
-  ArrayExpression: freeze(["elements"]),
-  ArrayPattern: freeze(["decorators", "elements", "typeAnnotation"]),
-  ArrowFunctionExpression: freeze(["typeParameters", "params", "returnType", "body"]),
-  AssignmentExpression: LEFT__RIGHT,
-  AssignmentPattern: freeze(["decorators", "left", "right", "typeAnnotation"]),
-  AwaitExpression: ARGUMENT,
-  BinaryExpression: LEFT__RIGHT,
-  BlockStatement: BODY,
-  BreakStatement: LABEL,
-  CallExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
-  CatchClause: freeze(["param", "body"]),
-  ChainExpression: EXPRESSION,
-  ClassBody: BODY,
-  ClassDeclaration: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
-  ClassExpression: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
-  ConditionalExpression: TEST__CONSEQUENT__ALTERNATE,
-  ContinueStatement: LABEL,
-  Decorator: EXPRESSION,
-  DoWhileStatement: freeze(["body", "test"]),
-  ExportAllDeclaration: freeze(["exported", "source", "attributes"]),
-  ExportDefaultDeclaration: freeze(["declaration"]),
-  ExportNamedDeclaration: freeze(["declaration", "specifiers", "source", "attributes"]),
-  ExportSpecifier: freeze(["local", "exported"]),
-  ExpressionStatement: EXPRESSION,
-  ForInStatement: LEFT__RIGHT__BODY,
-  ForOfStatement: LEFT__RIGHT__BODY,
-  ForStatement: freeze(["init", "test", "update", "body"]),
-  FunctionDeclaration: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
-  FunctionExpression: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
-  Identifier: freeze(["decorators", "typeAnnotation"]),
-  IfStatement: TEST__CONSEQUENT__ALTERNATE,
-  ImportAttribute: KEY__VALUE,
-  ImportDeclaration: freeze(["specifiers", "source", "attributes"]),
-  ImportDefaultSpecifier: LOCAL,
-  ImportExpression: freeze(["source", "options"]),
-  ImportNamespaceSpecifier: LOCAL,
-  ImportSpecifier: freeze(["imported", "local"]),
-  LabeledStatement: freeze(["label", "body"]),
-  LogicalExpression: LEFT__RIGHT,
-  MemberExpression: OBJECT__PROPERTY,
-  MetaProperty: freeze(["meta", "property"]),
-  MethodDefinition: freeze(["decorators", "key", "value"]),
-  NewExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
-  ObjectExpression: freeze(["properties"]),
-  ObjectPattern: freeze(["decorators", "properties", "typeAnnotation"]),
-  ParenthesizedExpression: EXPRESSION,
-  Program: BODY,
-  Property: KEY__VALUE,
-  PropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
-  RestElement: freeze(["decorators", "argument", "typeAnnotation"]),
-  ReturnStatement: ARGUMENT,
-  SequenceExpression: freeze(["expressions"]),
-  SpreadElement: ARGUMENT,
-  StaticBlock: BODY,
-  SwitchCase: freeze(["test", "consequent"]),
-  SwitchStatement: freeze(["discriminant", "cases"]),
-  TaggedTemplateExpression: freeze(["tag", "typeArguments", "quasi"]),
-  TemplateLiteral: freeze(["quasis", "expressions"]),
-  ThrowStatement: ARGUMENT,
-  TryStatement: freeze(["block", "handler", "finalizer"]),
-  UnaryExpression: ARGUMENT,
-  UpdateExpression: ARGUMENT,
-  V8IntrinsicExpression: freeze(["name", "arguments"]),
-  VariableDeclaration: freeze(["declarations"]),
-  VariableDeclarator: freeze(["id", "init"]),
-  WhileStatement: freeze(["test", "body"]),
-  WithStatement: freeze(["object", "body"]),
-  YieldExpression: ARGUMENT,
-  JSXAttribute: freeze(["name", "value"]),
-  JSXClosingElement: freeze(["name"]),
-  JSXElement: freeze(["openingElement", "children", "closingElement"]),
-  JSXExpressionContainer: EXPRESSION,
-  JSXFragment: freeze(["openingFragment", "children", "closingFragment"]),
-  JSXMemberExpression: OBJECT__PROPERTY,
-  JSXNamespacedName: freeze(["namespace", "name"]),
-  JSXOpeningElement: freeze(["name", "typeArguments", "attributes"]),
-  JSXSpreadAttribute: ARGUMENT,
-  JSXSpreadChild: EXPRESSION,
-  TSAbstractAccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION,
-  TSAbstractMethodDefinition: KEY__VALUE,
-  TSAbstractPropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION,
-  TSArrayType: freeze(["elementType"]),
-  TSAsExpression: EXPRESSION__TYPE_ANNOTATION,
-  TSCallSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
-  TSClassImplements: EXPRESSION__TYPE_ARGUMENTS,
-  TSConditionalType: freeze(["checkType", "extendsType", "trueType", "falseType"]),
-  TSConstructSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
-  TSConstructorType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
-  TSDeclareFunction: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
-  TSEmptyBodyFunctionExpression: freeze(["id", "typeParameters", "params", "returnType"]),
-  TSEnumBody: MEMBERS,
-  TSEnumDeclaration: ID__BODY,
-  TSEnumMember: freeze(["id", "initializer"]),
-  TSExportAssignment: EXPRESSION,
-  TSExternalModuleReference: EXPRESSION,
-  TSFunctionType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
-  TSImportEqualsDeclaration: freeze(["id", "moduleReference"]),
-  TSImportType: freeze(["source", "options", "qualifier", "typeArguments"]),
-  TSIndexSignature: freeze(["parameters", "typeAnnotation"]),
-  TSIndexedAccessType: freeze(["objectType", "indexType"]),
-  TSInferType: freeze(["typeParameter"]),
-  TSInstantiationExpression: EXPRESSION__TYPE_ARGUMENTS,
-  TSInterfaceBody: BODY,
-  TSInterfaceDeclaration: freeze(["id", "typeParameters", "extends", "body"]),
-  TSInterfaceHeritage: EXPRESSION__TYPE_ARGUMENTS,
-  TSIntersectionType: TYPES,
-  TSJSDocNonNullableType: TYPE_ANNOTATION,
-  TSJSDocNullableType: TYPE_ANNOTATION,
-  TSLiteralType: freeze(["literal"]),
-  TSMappedType: freeze(["key", "constraint", "nameType", "typeAnnotation"]),
-  TSMethodSignature: freeze(["key", "typeParameters", "params", "returnType"]),
-  TSModuleBlock: BODY,
-  TSModuleDeclaration: ID__BODY,
-  TSNamedTupleMember: freeze(["label", "elementType"]),
-  TSNamespaceExportDeclaration: freeze(["id"]),
-  TSNonNullExpression: EXPRESSION,
-  TSOptionalType: TYPE_ANNOTATION,
-  TSParameterProperty: freeze(["decorators", "parameter"]),
-  TSParenthesizedType: TYPE_ANNOTATION,
-  TSPropertySignature: freeze(["key", "typeAnnotation"]),
-  TSQualifiedName: LEFT__RIGHT,
-  TSRestType: TYPE_ANNOTATION,
-  TSSatisfiesExpression: EXPRESSION__TYPE_ANNOTATION,
-  TSTemplateLiteralType: freeze(["quasis", "types"]),
-  TSTupleType: freeze(["elementTypes"]),
-  TSTypeAliasDeclaration: freeze(["id", "typeParameters", "typeAnnotation"]),
-  TSTypeAnnotation: TYPE_ANNOTATION,
-  TSTypeAssertion: freeze(["typeAnnotation", "expression"]),
-  TSTypeLiteral: MEMBERS,
-  TSTypeOperator: TYPE_ANNOTATION,
-  TSTypeParameter: freeze(["name", "constraint", "default"]),
-  TSTypeParameterDeclaration: PARAMS,
-  TSTypeParameterInstantiation: PARAMS,
-  TSTypePredicate: freeze(["parameterName", "typeAnnotation"]),
-  TSTypeQuery: freeze(["exprName", "typeArguments"]),
-  TSTypeReference: freeze(["typeName", "typeArguments"]),
-  TSUnionType: TYPES
-});
-// node_modules/oxc-parser/src-js/visit/index.js
-import { createRequire as createRequire3 } from "node:module";
-var walkProgram = null;
-var addVisitorToCompiled;
-var createCompiledVisitor;
-var finalizeCompiledVisitor;
-
-class Visitor {
-  #compiledVisitor = null;
-  constructor(visitor) {
-    if (walkProgram === null) {
-      const require3 = createRequire3(import.meta.url);
-      ({ walkProgram } = require3("../generated/visit/walk.js"));
-      ({
-        addVisitorToCompiled,
-        createCompiledVisitor,
-        finalizeCompiledVisitor
-      } = require3("./visitor.js"));
-    }
-    const compiledVisitor = createCompiledVisitor();
-    addVisitorToCompiled(visitor);
-    const needsVisit = finalizeCompiledVisitor();
-    if (needsVisit)
-      this.#compiledVisitor = compiledVisitor;
-  }
-  visit(program) {
-    const compiledVisitor = this.#compiledVisitor;
-    if (compiledVisitor !== null)
-      walkProgram(program, compiledVisitor);
-  }
-}
-
-// node_modules/oxc-parser/src-js/index.js
-var require3 = createRequire4(import.meta.url);
-var parseSyncRaw = null;
-var parseRaw;
-var parseSyncLazy = null;
-var parseLazy;
-var LazyVisitor;
-function loadRawTransfer() {
-  if (parseSyncRaw === null) {
-    ({ parseSyncRaw, parse: parseRaw } = require3("./raw-transfer/eager.js"));
-  }
-}
-function loadRawTransferLazy() {
-  if (parseSyncLazy === null) {
-    ({ parseSyncLazy, parse: parseLazy, Visitor: LazyVisitor } = require3("./raw-transfer/lazy.js"));
-  }
-}
-function parseSync2(filename, sourceText, options3) {
-  if (options3?.experimentalRawTransfer) {
-    loadRawTransfer();
-    return parseSyncRaw(filename, sourceText, options3);
-  }
-  if (options3?.experimentalLazy) {
-    loadRawTransferLazy();
-    return parseSyncLazy(filename, sourceText, options3);
-  }
-  return wrap(parseSync(filename, sourceText, options3));
-}
-
-// src/recognizers/detector.ts
-function recognize(detector, line) {
-  const matches = detector.scan(line);
-  if (matches === 0)
-    return 0;
-  return 1 - (1 - detector.probability) ** matches;
-}
-
-// src/recognizers/code-recognizer.ts
-var PROBABILITY_THRESHOLD = 0.9;
-function computeProbability(detectors, line) {
-  let probability = 0;
-  for (const detector of detectors) {
-    const detected = recognize(detector, line);
-    probability = 1 - (1 - probability) * (1 - detected);
-  }
-  return probability;
-}
-function isLikelyCode(detectors, line) {
-  return computeProbability(detectors, line) >= PROBABILITY_THRESHOLD;
-}
-function hasCodeLines(detectors, lines) {
-  return lines.some((line) => isLikelyCode(detectors, line));
-}
-
-// src/recognizers/camel-case-detector.ts
-function createCamelCaseDetector(probability) {
-  return {
-    probability,
-    scan(line) {
-      for (let index2 = 0;index2 < line.length - 1; index2 += 1) {
-        const current = line.charAt(index2);
-        const next = line.charAt(index2 + 1);
-        if (current === current.toLowerCase() && next === next.toUpperCase() && next !== next.toLowerCase()) {
-          return 1;
-        }
-      }
-      return 0;
-    }
-  };
-}
-
-// src/recognizers/contains-detector.ts
-var WHITESPACE_GLOBAL_REGEX = regex2("\\s+", "g");
-var ESCAPE = regex2("[-/\\^$*+?.()|[\\]{}]", "g");
-function escapeForRegex(value) {
-  return value.replaceAll(ESCAPE, String.raw`\$&`);
-}
-function createContainsDetector(probability, patterns2) {
-  const compiledPatterns = patterns2.map((pattern4) => typeof pattern4 === "string" ? new RegExp(escapeForRegex(pattern4), "g") : new RegExp(pattern4.source, "g"));
-  return {
-    probability,
-    scan(line) {
-      const compressed = line.replace(WHITESPACE_GLOBAL_REGEX, "");
-      let total = 0;
-      for (const pattern4 of compiledPatterns) {
-        pattern4.lastIndex = 0;
-        const matches = compressed.match(pattern4);
-        if (matches)
-          total += matches.length;
+      return 0;
+    }
+  };
+}
+
+// src/recognizers/contains-detector.ts
+var WHITESPACE_GLOBAL_REGEX = regex2("\\s+", "g");
+var ESCAPE = regex2("[-/\\^$*+?.()|[\\]{}]", "g");
+function escapeForRegex(value) {
+  return value.replaceAll(ESCAPE, String.raw`\$&`);
+}
+function createContainsDetector(probability, patterns2) {
+  const compiledPatterns = patterns2.map((pattern4) => typeof pattern4 === "string" ? new RegExp(escapeForRegex(pattern4), "g") : new RegExp(pattern4.source, "g"));
+  return {
+    probability,
+    scan(line) {
+      const compressed = line.replace(WHITESPACE_GLOBAL_REGEX, "");
+      let total = 0;
+      for (const pattern4 of compiledPatterns) {
+        pattern4.lastIndex = 0;
+        const matches = compressed.match(pattern4);
+        if (matches)
+          total += matches.length;
       }
       return total;
     }
@@ -18099,11 +17996,11 @@ function isValidParseResult(result) {
 function tryParse(value, filename) {
   const ext = path.extname(filename);
   const parseFilename = `file${ext || ".js"}`;
-  const result = parseSync2(parseFilename, value);
+  const result = parseSync(parseFilename, value);
   if (isValidParseResult(result))
     return result;
   if (ext !== ".tsx" && ext !== ".jsx") {
-    const jsxResult = parseSync2("file.tsx", value);
+    const jsxResult = parseSync("file.tsx", value);
     if (isValidParseResult(jsxResult))
       return jsxResult;
   }
@@ -18112,15 +18009,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 +18074,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 +18117,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 +18157,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 +18183,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 +18198,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 +18428,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 +18464,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 +18473,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 +18488,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 +18500,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 +18533,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 +19261,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 +19488,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 +19657,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 +19696,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 +19742,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 +19897,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 +20041,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 +20513,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 +20531,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 +20580,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 +20838,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 +20853,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 +20902,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 +20921,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 +20984,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 +21015,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 +21032,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 +21040,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 +21178,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 +21700,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
+import { dirname } from "node:path";
+import { ResolverFactory } from "oxc-resolver";
+var resolver = new 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([
@@ -21988,7 +22554,7 @@ function isComponentOrHook(node) {
   }
   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;
@@ -22021,21 +22587,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 +22663,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,
@@ -22423,11 +22993,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 +23055,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=7DA0BA55D13FFCAD64756E2164756E21
+//# debugId=C1BEC810E1B754DD64756E2164756E21