@isentinel/eslint-config 1.2.0 → 1.2.3

package/dist/dist-3XXODFPQ.js

@@ -0,0 +1,1760 @@
+import {
+  __commonJS,
+  __export,
+  __toESM,
+  init_esm_shims
+} from "./chunk-YSIDNL3J.js";
+
+// node_modules/.pnpm/fast-diff@1.3.0/node_modules/fast-diff/diff.js
+var require_diff = __commonJS({
+  "node_modules/.pnpm/fast-diff@1.3.0/node_modules/fast-diff/diff.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    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 x = 0; x < v_length; x++) {
+        v1[x] = -1;
+        v2[x] = -1;
+      }
+      v1[v_offset + 1] = 0;
+      v2[v_offset + 1] = 0;
+      var delta = text1_length - text2_length;
+      var front = delta % 2 !== 0;
+      var k1start = 0;
+      var k1end = 0;
+      var k2start = 0;
+      var k2end = 0;
+      for (var d = 0; d < max_d; d++) {
+        for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+          var k1_offset = v_offset + k1;
+          var x1;
+          if (k1 === -d || k1 !== d && 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 + delta - k1;
+            if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] !== -1) {
+              var x2 = text1_length - v2[k2_offset];
+              if (x1 >= x2) {
+                return diff_bisectSplit_(text1, text2, x1, y1);
+              }
+            }
+          }
+        }
+        for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+          var k2_offset = v_offset + k2;
+          var x2;
+          if (k2 === -d || k2 !== d && v2[k2_offset - 1] < v2[k2_offset + 1]) {
+            x2 = v2[k2_offset + 1];
+          } else {
+            x2 = v2[k2_offset - 1] + 1;
+          }
+          var y2 = x2 - k2;
+          while (x2 < text1_length && y2 < text2_length && text1.charAt(text1_length - x2 - 1) === text2.charAt(text2_length - y2 - 1)) {
+            x2++;
+            y2++;
+          }
+          v2[k2_offset] = x2;
+          if (x2 > text1_length) {
+            k2end += 2;
+          } else if (y2 > text2_length) {
+            k2start += 2;
+          } else if (!front) {
+            var k1_offset = v_offset + delta - 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;
+              x2 = text1_length - x2;
+              if (x1 >= x2) {
+                return diff_bisectSplit_(text1, text2, x1, y1);
+              }
+            }
+          }
+        }
+      }
+      return [
+        [DIFF_DELETE, text1],
+        [DIFF_INSERT, text2]
+      ];
+    }
+    function diff_bisectSplit_(text1, text2, x, y) {
+      var text1a = text1.substring(0, x);
+      var text2a = text2.substring(0, y);
+      var text1b = text1.substring(x);
+      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 pattern = text1.substring(text_length - length);
+        var found = text2.indexOf(pattern);
+        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 pointer = 0;
+      var length_insertions1 = 0;
+      var length_deletions1 = 0;
+      var length_insertions2 = 0;
+      var length_deletions2 = 0;
+      while (pointer < diffs.length) {
+        if (diffs[pointer][0] == DIFF_EQUAL) {
+          equalities[equalitiesLength++] = pointer;
+          length_insertions1 = length_insertions2;
+          length_deletions1 = length_deletions2;
+          length_insertions2 = 0;
+          length_deletions2 = 0;
+          lastequality = diffs[pointer][1];
+        } else {
+          if (diffs[pointer][0] == DIFF_INSERT) {
+            length_insertions2 += diffs[pointer][1].length;
+          } else {
+            length_deletions2 += diffs[pointer][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--;
+            pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
+            length_insertions1 = 0;
+            length_deletions1 = 0;
+            length_insertions2 = 0;
+            length_deletions2 = 0;
+            lastequality = null;
+            changes = true;
+          }
+        }
+        pointer++;
+      }
+      if (changes) {
+        diff_cleanupMerge(diffs);
+      }
+      diff_cleanupSemanticLossless(diffs);
+      pointer = 1;
+      while (pointer < diffs.length) {
+        if (diffs[pointer - 1][0] == DIFF_DELETE && diffs[pointer][0] == DIFF_INSERT) {
+          var deletion = diffs[pointer - 1][1];
+          var insertion = diffs[pointer][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(pointer, 0, [
+                DIFF_EQUAL,
+                insertion.substring(0, overlap_length1)
+              ]);
+              diffs[pointer - 1][1] = deletion.substring(
+                0,
+                deletion.length - overlap_length1
+              );
+              diffs[pointer + 1][1] = insertion.substring(overlap_length1);
+              pointer++;
+            }
+          } else {
+            if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
+              diffs.splice(pointer, 0, [
+                DIFF_EQUAL,
+                deletion.substring(0, overlap_length2)
+              ]);
+              diffs[pointer - 1][0] = DIFF_INSERT;
+              diffs[pointer - 1][1] = insertion.substring(
+                0,
+                insertion.length - overlap_length2
+              );
+              diffs[pointer + 1][0] = DIFF_DELETE;
+              diffs[pointer + 1][1] = deletion.substring(overlap_length2);
+              pointer++;
+            }
+          }
+          pointer++;
+        }
+        pointer++;
+      }
+    }
+    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 pointer = 1;
+      while (pointer < diffs.length - 1) {
+        if (diffs[pointer - 1][0] == DIFF_EQUAL && diffs[pointer + 1][0] == DIFF_EQUAL) {
+          var equality1 = diffs[pointer - 1][1];
+          var edit = diffs[pointer][1];
+          var equality2 = diffs[pointer + 1][1];
+          var commonOffset = diff_commonSuffix(equality1, edit);
+          if (commonOffset) {
+            var commonString = edit.substring(edit.length - commonOffset);
+            equality1 = equality1.substring(0, equality1.length - commonOffset);
+            edit = commonString + edit.substring(0, edit.length - commonOffset);
+            equality2 = commonString + equality2;
+          }
+          var bestEquality1 = equality1;
+          var bestEdit = edit;
+          var bestEquality2 = equality2;
+          var bestScore = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);
+          while (edit.charAt(0) === equality2.charAt(0)) {
+            equality1 += edit.charAt(0);
+            edit = edit.substring(1) + equality2.charAt(0);
+            equality2 = equality2.substring(1);
+            var score = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);
+            if (score >= bestScore) {
+              bestScore = score;
+              bestEquality1 = equality1;
+              bestEdit = edit;
+              bestEquality2 = equality2;
+            }
+          }
+          if (diffs[pointer - 1][1] != bestEquality1) {
+            if (bestEquality1) {
+              diffs[pointer - 1][1] = bestEquality1;
+            } else {
+              diffs.splice(pointer - 1, 1);
+              pointer--;
+            }
+            diffs[pointer][1] = bestEdit;
+            if (bestEquality2) {
+              diffs[pointer + 1][1] = bestEquality2;
+            } else {
+              diffs.splice(pointer + 1, 1);
+              pointer--;
+            }
+          }
+        }
+        pointer++;
+      }
+    }
+    function diff_cleanupMerge(diffs, fix_unicode) {
+      diffs.push([DIFF_EQUAL, ""]);
+      var pointer = 0;
+      var count_delete = 0;
+      var count_insert = 0;
+      var text_delete = "";
+      var text_insert = "";
+      var commonlength;
+      while (pointer < diffs.length) {
+        if (pointer < diffs.length - 1 && !diffs[pointer][1]) {
+          diffs.splice(pointer, 1);
+          continue;
+        }
+        switch (diffs[pointer][0]) {
+          case DIFF_INSERT:
+            count_insert++;
+            text_insert += diffs[pointer][1];
+            pointer++;
+            break;
+          case DIFF_DELETE:
+            count_delete++;
+            text_delete += diffs[pointer][1];
+            pointer++;
+            break;
+          case DIFF_EQUAL:
+            var previous_equality = pointer - 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);
+                  pointer--;
+                  var k = previous_equality - 1;
+                  if (diffs[k] && diffs[k][0] === DIFF_INSERT) {
+                    count_insert++;
+                    text_insert = diffs[k][1] + text_insert;
+                    k--;
+                  }
+                  if (diffs[k] && diffs[k][0] === DIFF_DELETE) {
+                    count_delete++;
+                    text_delete = diffs[k][1] + text_delete;
+                    k--;
+                  }
+                  previous_equality = k;
+                }
+              }
+              if (starts_with_pair_end(diffs[pointer][1])) {
+                var stray = diffs[pointer][1].charAt(0);
+                diffs[pointer][1] = diffs[pointer][1].slice(1);
+                text_delete += stray;
+                text_insert += stray;
+              }
+            }
+            if (pointer < diffs.length - 1 && !diffs[pointer][1]) {
+              diffs.splice(pointer, 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)
+                    ]);
+                    pointer++;
+                  }
+                  text_insert = text_insert.substring(commonlength);
+                  text_delete = text_delete.substring(commonlength);
+                }
+                commonlength = diff_commonSuffix(text_insert, text_delete);
+                if (commonlength !== 0) {
+                  diffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][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(pointer - n, n);
+                pointer = pointer - n;
+              } else if (text_delete.length === 0) {
+                diffs.splice(pointer - n, n, [DIFF_INSERT, text_insert]);
+                pointer = pointer - n + 1;
+              } else if (text_insert.length === 0) {
+                diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete]);
+                pointer = pointer - n + 1;
+              } else {
+                diffs.splice(
+                  pointer - n,
+                  n,
+                  [DIFF_DELETE, text_delete],
+                  [DIFF_INSERT, text_insert]
+                );
+                pointer = pointer - n + 2;
+              }
+            }
+            if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {
+              diffs[pointer - 1][1] += diffs[pointer][1];
+              diffs.splice(pointer, 1);
+            } else {
+              pointer++;
+            }
+            count_insert = 0;
+            count_delete = 0;
+            text_delete = "";
+            text_insert = "";
+            break;
+        }
+      }
+      if (diffs[diffs.length - 1][1] === "") {
+        diffs.pop();
+      }
+      var changes = false;
+      pointer = 1;
+      while (pointer < diffs.length - 1) {
+        if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+          if (diffs[pointer][1].substring(
+            diffs[pointer][1].length - diffs[pointer - 1][1].length
+          ) === diffs[pointer - 1][1]) {
+            diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(
+              0,
+              diffs[pointer][1].length - diffs[pointer - 1][1].length
+            );
+            diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
+            diffs.splice(pointer - 1, 1);
+            changes = true;
+          } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) == diffs[pointer + 1][1]) {
+            diffs[pointer - 1][1] += diffs[pointer + 1][1];
+            diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1];
+            diffs.splice(pointer + 1, 1);
+            changes = true;
+          }
+        }
+        pointer++;
+      }
+      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 diff(text1, text2, cursor_pos, cleanup) {
+      return diff_main(text1, text2, cursor_pos, cleanup, true);
+    }
+    diff.INSERT = DIFF_INSERT;
+    diff.DELETE = DIFF_DELETE;
+    diff.EQUAL = DIFF_EQUAL;
+    module.exports = diff;
+  }
+});
+
+// node_modules/.pnpm/prettier-linter-helpers@1.0.0/node_modules/prettier-linter-helpers/index.js
+var require_prettier_linter_helpers = __commonJS({
+  "node_modules/.pnpm/prettier-linter-helpers@1.0.0/node_modules/prettier-linter-helpers/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var diff = require_diff();
+    var LINE_ENDING_RE = /\r\n|[\r\n\u2028\u2029]/;
+    function showInvisibles2(str) {
+      let ret = "";
+      for (let i = 0; i < str.length; i++) {
+        switch (str[i]) {
+          case " ":
+            ret += "\xB7";
+            break;
+          case "\n":
+            ret += "\u23CE";
+            break;
+          case "	":
+            ret += "\u21B9";
+            break;
+          case "\r":
+            ret += "\u240D";
+            break;
+          default:
+            ret += str[i];
+            break;
+        }
+      }
+      return ret;
+    }
+    function generateDifferences2(source, prettierSource) {
+      const results = diff(source, prettierSource);
+      const differences = [];
+      const batch = [];
+      let offset = 0;
+      while (results.length) {
+        const result = results.shift();
+        const op = result[0];
+        const text = result[1];
+        switch (op) {
+          case diff.INSERT:
+          case diff.DELETE:
+            batch.push(result);
+            break;
+          case diff.EQUAL:
+            if (results.length) {
+              if (batch.length) {
+                if (LINE_ENDING_RE.test(text)) {
+                  flush();
+                  offset += text.length;
+                } else {
+                  batch.push(result);
+                }
+              } else {
+                offset += text.length;
+              }
+            }
+            break;
+          default:
+            throw new Error(`Unexpected fast-diff operation "${op}"`);
+        }
+        if (batch.length && !results.length) {
+          flush();
+        }
+      }
+      return differences;
+      function flush() {
+        let aheadDeleteText = "";
+        let aheadInsertText = "";
+        while (batch.length) {
+          const next = batch.shift();
+          const op = next[0];
+          const text = next[1];
+          switch (op) {
+            case diff.INSERT:
+              aheadInsertText += text;
+              break;
+            case diff.DELETE:
+              aheadDeleteText += text;
+              break;
+            case diff.EQUAL:
+              aheadDeleteText += text;
+              aheadInsertText += text;
+              break;
+          }
+        }
+        if (aheadDeleteText && aheadInsertText) {
+          differences.push({
+            offset,
+            operation: generateDifferences2.REPLACE,
+            insertText: aheadInsertText,
+            deleteText: aheadDeleteText
+          });
+        } else if (!aheadDeleteText && aheadInsertText) {
+          differences.push({
+            offset,
+            operation: generateDifferences2.INSERT,
+            insertText: aheadInsertText
+          });
+        } else if (aheadDeleteText && !aheadInsertText) {
+          differences.push({
+            offset,
+            operation: generateDifferences2.DELETE,
+            deleteText: aheadDeleteText
+          });
+        }
+        offset += aheadDeleteText.length;
+      }
+    }
+    generateDifferences2.INSERT = "insert";
+    generateDifferences2.DELETE = "delete";
+    generateDifferences2.REPLACE = "replace";
+    module.exports = {
+      showInvisibles: showInvisibles2,
+      generateDifferences: generateDifferences2
+    };
+  }
+});
+
+// node_modules/.pnpm/eslint-plugin-format-lua@1.0.0_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-format-lua/dist/index.mjs
+init_esm_shims();
+
+// node_modules/.pnpm/eslint-parser-plain@0.1.1/node_modules/eslint-parser-plain/dist/index.mjs
+var dist_exports = {};
+__export(dist_exports, {
+  meta: () => meta,
+  parseForESLint: () => parseForESLint
+});
+init_esm_shims();
+var name = "eslint-parser-plain";
+var version = "0.1.1";
+var parseForESLint = (code) => ({
+  ast: {
+    type: "Program",
+    loc: { start: 0, end: code.length },
+    range: [0, code.length],
+    body: [],
+    comments: [],
+    tokens: []
+  },
+  services: { isPlain: true },
+  scopeManager: null,
+  visitorKeys: {
+    Program: []
+  }
+});
+var meta = {
+  name,
+  version
+};
+
+// node_modules/.pnpm/@johnnymorganz+stylua@2.1.0/node_modules/@johnnymorganz/stylua/stylua_lib.mjs
+init_esm_shims();
+import fs from "node:fs";
+
+// node_modules/.pnpm/@johnnymorganz+stylua@2.1.0/node_modules/@johnnymorganz/stylua/stylua.web/stylua_lib.js
+init_esm_shims();
+var wasm;
+var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
+  throw Error("TextDecoder not available");
+} };
+if (typeof TextDecoder !== "undefined") {
+  cachedTextDecoder.decode();
+}
+var cachedUint8Memory0 = null;
+function getUint8Memory0() {
+  if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+    cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8Memory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+var heap = new Array(128).fill(void 0);
+heap.push(void 0, null, true, false);
+var heap_next = heap.length;
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  const idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+var cachedInt32Memory0 = null;
+function getInt32Memory0() {
+  if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+    cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+  }
+  return cachedInt32Memory0;
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+  return instance.ptr;
+}
+var WASM_VECTOR_LEN = 0;
+var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
+  throw Error("TextEncoder not available");
+} };
+var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+  return cachedTextEncoder.encodeInto(arg, view);
+} : function(arg, view) {
+  const buf = cachedTextEncoder.encode(arg);
+  view.set(buf);
+  return {
+    read: arg.length,
+    written: buf.length
+  };
+};
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8Memory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8Memory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+    const ret = encodeString(arg, view);
+    offset += ret.written;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function getObject(idx) {
+  return heap[idx];
+}
+function dropObject(idx) {
+  if (idx < 132) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+function formatCode(code, config, range, verify_output) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(config, Config);
+    var ptr1 = config.__destroy_into_raw();
+    let ptr2 = 0;
+    if (!isLikeNone(range)) {
+      _assertClass(range, Range);
+      ptr2 = range.__destroy_into_raw();
+    }
+    wasm.formatCode(retptr, ptr0, len0, ptr1, ptr2, verify_output);
+    var r0 = getInt32Memory0()[retptr / 4 + 0];
+    var r1 = getInt32Memory0()[retptr / 4 + 1];
+    var r2 = getInt32Memory0()[retptr / 4 + 2];
+    var r3 = getInt32Memory0()[retptr / 4 + 3];
+    var ptr4 = r0;
+    var len4 = r1;
+    if (r3) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeObject(r2);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+var LineEndings = Object.freeze({
+  /**
+  * Unix Line Endings (LF) - `\n`
+  */
+  Unix: 0,
+  "0": "Unix",
+  /**
+  * Windows Line Endings (CRLF) - `\r\n`
+  */
+  Windows: 1,
+  "1": "Windows"
+});
+var OutputVerification = Object.freeze({
+  /**
+  * Reparse the generated output to detect any changes to code correctness.
+  */
+  Full: 0,
+  "0": "Full",
+  /**
+  * Perform no verification of the output.
+  */
+  None: 1,
+  "1": "None"
+});
+var LuaVersion = Object.freeze({
+  /**
+  * Parse all syntax versions at the same time. This allows most general usage.
+  * For overlapping syntaxes (e.g., Lua5.2 label syntax and Luau type assertions), select a
+  * specific syntax version
+  */
+  All: 0,
+  "0": "All",
+  /**
+  * Parse Lua 5.1 code
+  */
+  Lua51: 1,
+  "1": "Lua51",
+  /**
+  * Parse Lua 5.2 code
+  */
+  Lua52: 2,
+  "2": "Lua52",
+  /**
+  * Parse Lua 5.3 code
+  */
+  Lua53: 3,
+  "3": "Lua53",
+  /**
+  * Parse Lua 5.4 code
+  */
+  Lua54: 4,
+  "4": "Lua54",
+  /**
+  * Parse Luau code
+  */
+  Luau: 5,
+  "5": "Luau",
+  /**
+  * Parse LuaJIT code
+  */
+  LuaJIT: 6,
+  "6": "LuaJIT",
+  /**
+  * Parse Cfx Lua code
+  */
+  CfxLua: 7,
+  "7": "CfxLua"
+});
+var SpaceAfterFunctionNames = Object.freeze({
+  /**
+  * Never use spaces after function names.
+  */
+  Never: 0,
+  "0": "Never",
+  /**
+  * Use spaces after function names only for function definitions.
+  */
+  Definitions: 1,
+  "1": "Definitions",
+  /**
+  * Use spaces after function names only for function calls.
+  */
+  Calls: 2,
+  "2": "Calls",
+  /**
+  * Use spaces after function names in definitions and calls.
+  */
+  Always: 3,
+  "3": "Always"
+});
+var IndentType = Object.freeze({
+  /**
+  * Indent using tabs (`\t`)
+  */
+  Tabs: 0,
+  "0": "Tabs",
+  /**
+  * Indent using spaces (` `)
+  */
+  Spaces: 1,
+  "1": "Spaces"
+});
+var QuoteStyle = Object.freeze({
+  /**
+  * Use double quotes where possible, but change to single quotes if it produces less escapes
+  */
+  AutoPreferDouble: 0,
+  "0": "AutoPreferDouble",
+  /**
+  * Use single quotes where possible, but change to double quotes if it produces less escapes
+  */
+  AutoPreferSingle: 1,
+  "1": "AutoPreferSingle",
+  /**
+  * Always use double quotes in all strings
+  */
+  ForceDouble: 2,
+  "2": "ForceDouble",
+  /**
+  * Always use single quotes in all strings
+  */
+  ForceSingle: 3,
+  "3": "ForceSingle"
+});
+var CallParenType = Object.freeze({
+  /**
+  * Use call parentheses all the time
+  */
+  Always: 0,
+  "0": "Always",
+  /**
+  * Skip call parentheses when only a string argument is used.
+  */
+  NoSingleString: 1,
+  "1": "NoSingleString",
+  /**
+  * Skip call parentheses when only a table argument is used.
+  */
+  NoSingleTable: 2,
+  "2": "NoSingleTable",
+  /**
+  * Skip call parentheses when only a table or string argument is used.
+  */
+  None: 3,
+  "3": "None",
+  /**
+  * Keep call parentheses based on its presence in input code.
+  */
+  Input: 4,
+  "4": "Input"
+});
+var CollapseSimpleStatement = Object.freeze({
+  /**
+  * Never collapse
+  */
+  Never: 0,
+  "0": "Never",
+  /**
+  * Collapse simple functions onto a single line
+  */
+  FunctionOnly: 1,
+  "1": "FunctionOnly",
+  /**
+  * Collapse simple if guards onto a single line
+  */
+  ConditionalOnly: 2,
+  "2": "ConditionalOnly",
+  /**
+  * Collapse all simple statements onto a single line
+  */
+  Always: 3,
+  "3": "Always"
+});
+var Config = class _Config {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_Config.prototype);
+    obj.__wbg_ptr = ptr;
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_config_free(ptr);
+  }
+  /**
+  * The type of Lua syntax to parse.
+  * @returns {LuaVersion}
+  */
+  get syntax() {
+    const ret = wasm.__wbg_get_config_syntax(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * The type of Lua syntax to parse.
+  * @param {LuaVersion} arg0
+  */
+  set syntax(arg0) {
+    wasm.__wbg_set_config_syntax(this.__wbg_ptr, arg0);
+  }
+  /**
+  * The approximate line length to use when printing the code.
+  * This is used as a guide to determine when to wrap lines, but note
+  * that this is not a hard upper bound.
+  * @returns {number}
+  */
+  get column_width() {
+    const ret = wasm.__wbg_get_config_column_width(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+  * The approximate line length to use when printing the code.
+  * This is used as a guide to determine when to wrap lines, but note
+  * that this is not a hard upper bound.
+  * @param {number} arg0
+  */
+  set column_width(arg0) {
+    wasm.__wbg_set_config_column_width(this.__wbg_ptr, arg0);
+  }
+  /**
+  * The type of line endings to use.
+  * @returns {LineEndings}
+  */
+  get line_endings() {
+    const ret = wasm.__wbg_get_config_line_endings(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * The type of line endings to use.
+  * @param {LineEndings} arg0
+  */
+  set line_endings(arg0) {
+    wasm.__wbg_set_config_line_endings(this.__wbg_ptr, arg0);
+  }
+  /**
+  * The type of indents to use.
+  * @returns {IndentType}
+  */
+  get indent_type() {
+    const ret = wasm.__wbg_get_config_indent_type(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * The type of indents to use.
+  * @param {IndentType} arg0
+  */
+  set indent_type(arg0) {
+    wasm.__wbg_set_config_indent_type(this.__wbg_ptr, arg0);
+  }
+  /**
+  * The width of a single indentation level.
+  * If `indent_type` is set to [`IndentType::Spaces`], then this is the number of spaces to use.
+  * If `indent_type` is set to [`IndentType::Tabs`], then this is used as a heuristic to guide when to wrap lines.
+  * @returns {number}
+  */
+  get indent_width() {
+    const ret = wasm.__wbg_get_config_indent_width(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+  * The width of a single indentation level.
+  * If `indent_type` is set to [`IndentType::Spaces`], then this is the number of spaces to use.
+  * If `indent_type` is set to [`IndentType::Tabs`], then this is used as a heuristic to guide when to wrap lines.
+  * @param {number} arg0
+  */
+  set indent_width(arg0) {
+    wasm.__wbg_set_config_indent_width(this.__wbg_ptr, arg0);
+  }
+  /**
+  * The style of quotes to use in string literals.
+  * @returns {QuoteStyle}
+  */
+  get quote_style() {
+    const ret = wasm.__wbg_get_config_quote_style(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * The style of quotes to use in string literals.
+  * @param {QuoteStyle} arg0
+  */
+  set quote_style(arg0) {
+    wasm.__wbg_set_config_quote_style(this.__wbg_ptr, arg0);
+  }
+  /**
+  * Whether to omit parentheses around function calls which take a single string literal or table.
+  * This is added for adoption reasons only, and is not recommended for new work.
+  * @returns {boolean}
+  */
+  get no_call_parentheses() {
+    const ret = wasm.__wbg_get_config_no_call_parentheses(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+  * Whether to omit parentheses around function calls which take a single string literal or table.
+  * This is added for adoption reasons only, and is not recommended for new work.
+  * @param {boolean} arg0
+  */
+  set no_call_parentheses(arg0) {
+    wasm.__wbg_set_config_no_call_parentheses(this.__wbg_ptr, arg0);
+  }
+  /**
+  * When to use call parentheses.
+  * if call_parentheses is set to [`CallParenType::Always`] call parentheses is always applied.
+  * if call_parentheses is set to [`CallParenType::NoSingleTable`] call parentheses is omitted when
+  * function is called with only one string argument.
+  * if call_parentheses is set to [`CallParenType::NoSingleTable`] call parentheses is omitted when
+  * function is called with only one table argument.
+  * if call_parentheses is set to [`CallParenType::None`] call parentheses is omitted when
+  * function is called with only one table or string argument (same as no_call_parentheses).
+  * @returns {CallParenType}
+  */
+  get call_parentheses() {
+    const ret = wasm.__wbg_get_config_call_parentheses(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * When to use call parentheses.
+  * if call_parentheses is set to [`CallParenType::Always`] call parentheses is always applied.
+  * if call_parentheses is set to [`CallParenType::NoSingleTable`] call parentheses is omitted when
+  * function is called with only one string argument.
+  * if call_parentheses is set to [`CallParenType::NoSingleTable`] call parentheses is omitted when
+  * function is called with only one table argument.
+  * if call_parentheses is set to [`CallParenType::None`] call parentheses is omitted when
+  * function is called with only one table or string argument (same as no_call_parentheses).
+  * @param {CallParenType} arg0
+  */
+  set call_parentheses(arg0) {
+    wasm.__wbg_set_config_call_parentheses(this.__wbg_ptr, arg0);
+  }
+  /**
+  * Whether we should collapse simple structures like functions or guard statements
+  * if set to [`CollapseSimpleStatement::None`] structures are never collapsed.
+  * if set to [`CollapseSimpleStatement::FunctionOnly`] then simple functions (i.e., functions with a single laststmt) can be collapsed
+  * @returns {CollapseSimpleStatement}
+  */
+  get collapse_simple_statement() {
+    const ret = wasm.__wbg_get_config_collapse_simple_statement(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * Whether we should collapse simple structures like functions or guard statements
+  * if set to [`CollapseSimpleStatement::None`] structures are never collapsed.
+  * if set to [`CollapseSimpleStatement::FunctionOnly`] then simple functions (i.e., functions with a single laststmt) can be collapsed
+  * @param {CollapseSimpleStatement} arg0
+  */
+  set collapse_simple_statement(arg0) {
+    wasm.__wbg_set_config_collapse_simple_statement(this.__wbg_ptr, arg0);
+  }
+  /**
+  * Configuration for the sort requires codemod
+  * @returns {SortRequiresConfig}
+  */
+  get sort_requires() {
+    const ret = wasm.__wbg_get_config_sort_requires(this.__wbg_ptr);
+    return SortRequiresConfig.__wrap(ret);
+  }
+  /**
+  * Configuration for the sort requires codemod
+  * @param {SortRequiresConfig} arg0
+  */
+  set sort_requires(arg0) {
+    _assertClass(arg0, SortRequiresConfig);
+    var ptr0 = arg0.__destroy_into_raw();
+    wasm.__wbg_set_config_sort_requires(this.__wbg_ptr, ptr0);
+  }
+  /**
+  * Whether we should include a space between the function name and arguments.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Never`] a space is never used.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Definitions`] a space is used only for definitions.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Calls`] a space is used only for calls.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Always`] a space is used for both definitions and calls.
+  * @returns {SpaceAfterFunctionNames}
+  */
+  get space_after_function_names() {
+    const ret = wasm.__wbg_get_config_space_after_function_names(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+  * Whether we should include a space between the function name and arguments.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Never`] a space is never used.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Definitions`] a space is used only for definitions.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Calls`] a space is used only for calls.
+  * * if space_after_function_names is set to [`SpaceAfterFunctionNames::Always`] a space is used for both definitions and calls.
+  * @param {SpaceAfterFunctionNames} arg0
+  */
+  set space_after_function_names(arg0) {
+    wasm.__wbg_set_config_space_after_function_names(this.__wbg_ptr, arg0);
+  }
+  /**
+  * Creates a new Config with the default values
+  * @returns {Config}
+  */
+  static new() {
+    const ret = wasm.config_new();
+    return _Config.__wrap(ret);
+  }
+};
+var Range = class _Range {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_Range.prototype);
+    obj.__wbg_ptr = ptr;
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_range_free(ptr);
+  }
+  /**
+  * @returns {number | undefined}
+  */
+  get start() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_range_start(retptr, this.__wbg_ptr);
+      var r0 = getInt32Memory0()[retptr / 4 + 0];
+      var r1 = getInt32Memory0()[retptr / 4 + 1];
+      return r0 === 0 ? void 0 : r1 >>> 0;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+  * @param {number | undefined} [arg0]
+  */
+  set start(arg0) {
+    wasm.__wbg_set_range_start(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+  }
+  /**
+  * @returns {number | undefined}
+  */
+  get end() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_range_end(retptr, this.__wbg_ptr);
+      var r0 = getInt32Memory0()[retptr / 4 + 0];
+      var r1 = getInt32Memory0()[retptr / 4 + 1];
+      return r0 === 0 ? void 0 : r1 >>> 0;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+  * @param {number | undefined} [arg0]
+  */
+  set end(arg0) {
+    wasm.__wbg_set_range_end(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? 0 : arg0);
+  }
+  /**
+  * Creates a new formatting range from the given start and end point.
+  * All content within these boundaries (inclusive) will be formatted.
+  * @param {number | undefined} [start]
+  * @param {number | undefined} [end]
+  * @returns {Range}
+  */
+  static from_values(start, end) {
+    const ret = wasm.range_from_values(!isLikeNone(start), isLikeNone(start) ? 0 : start, !isLikeNone(end), isLikeNone(end) ? 0 : end);
+    return _Range.__wrap(ret);
+  }
+};
+var SortRequiresConfig = class _SortRequiresConfig {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_SortRequiresConfig.prototype);
+    obj.__wbg_ptr = ptr;
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_sortrequiresconfig_free(ptr);
+  }
+  /**
+  * Whether the sort requires codemod is enabled
+  * @returns {boolean}
+  */
+  get enabled() {
+    const ret = wasm.__wbg_get_sortrequiresconfig_enabled(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+  * Whether the sort requires codemod is enabled
+  * @param {boolean} arg0
+  */
+  set enabled(arg0) {
+    wasm.__wbg_set_sortrequiresconfig_enabled(this.__wbg_ptr, arg0);
+  }
+  /**
+  * @returns {SortRequiresConfig}
+  */
+  static new() {
+    const ret = wasm.sortrequiresconfig_new();
+    return _SortRequiresConfig.__wrap(ret);
+  }
+  /**
+  * @param {boolean} enabled
+  * @returns {SortRequiresConfig}
+  */
+  set_enabled(enabled) {
+    const ret = wasm.sortrequiresconfig_set_enabled(this.__wbg_ptr, enabled);
+    return _SortRequiresConfig.__wrap(ret);
+  }
+};
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        if (module.headers.get("Content-Type") != "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+}
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  return imports;
+}
+function __wbg_init_memory(imports, maybe_memory) {
+}
+function __wbg_finalize_init(instance, module) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module;
+  cachedInt32Memory0 = null;
+  cachedUint8Memory0 = null;
+  return wasm;
+}
+function initSync(module) {
+  if (wasm !== void 0) return wasm;
+  const imports = __wbg_get_imports();
+  __wbg_init_memory(imports);
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(input) {
+  if (wasm !== void 0) return wasm;
+  if (typeof input === "undefined") {
+    input = new URL("stylua_lib_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof input === "string" || typeof Request === "function" && input instanceof Request || typeof URL === "function" && input instanceof URL) {
+    input = fetch(input);
+  }
+  __wbg_init_memory(imports);
+  const { instance, module } = await __wbg_load(await input, imports);
+  return __wbg_finalize_init(instance, module);
+}
+
+// node_modules/.pnpm/@johnnymorganz+stylua@2.1.0/node_modules/@johnnymorganz/stylua/stylua_lib.mjs
+var wasm2 = new URL("./stylua.web/stylua_lib_bg.wasm", import.meta.url);
+initSync(fs.readFileSync(wasm2));
+
+// node_modules/.pnpm/eslint-formatting-reporter@0.0.0_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-formatting-reporter/dist/index.mjs
+init_esm_shims();
+var import_prettier_linter_helpers = __toESM(require_prettier_linter_helpers(), 1);
+var { INSERT, DELETE, REPLACE } = import_prettier_linter_helpers.generateDifferences;
+var messages = {
+  [INSERT]: "Insert `{{ insertText }}`",
+  [DELETE]: "Delete `{{ deleteText }}`",
+  [REPLACE]: "Replace `{{ deleteText }}` with `{{ insertText }}`"
+};
+function _reportDifference(context, difference, rangeOffset = 0) {
+  const { operation, offset, deleteText = "", insertText = "" } = difference;
+  const range = [
+    offset + rangeOffset,
+    offset + rangeOffset + deleteText.length
+  ];
+  const [start, end] = range.map((index2) => context.sourceCode.getLocFromIndex(index2));
+  context.report({
+    messageId: operation,
+    data: {
+      deleteText: (0, import_prettier_linter_helpers.showInvisibles)(deleteText),
+      insertText: (0, import_prettier_linter_helpers.showInvisibles)(insertText)
+    },
+    loc: { start, end },
+    fix: (fixer) => fixer.replaceTextRange(range, insertText)
+  });
+}
+function reportDifferences(context, source, formatted, offset = 0) {
+  if (source !== formatted) {
+    const differences = (0, import_prettier_linter_helpers.generateDifferences)(source, formatted);
+    for (const difference of differences)
+      _reportDifference(context, difference, offset);
+  }
+}
+
+// node_modules/.pnpm/eslint-plugin-format-lua@1.0.0_eslint@9.25.1_jiti@2.4.2_/node_modules/eslint-plugin-format-lua/dist/index.mjs
+var stylua = {
+  create(context) {
+    const config = Config.new();
+    const range = Range.from_values();
+    return {
+      Program() {
+        const sourceCode = context.sourceCode.text;
+        try {
+          const formatted = formatCode(
+            sourceCode,
+            config,
+            range,
+            OutputVerification.None
+          );
+          reportDifferences(context, sourceCode, formatted);
+        } catch (err) {
+          console.log(err);
+          context.report({
+            loc: {
+              end: { column: 0, line: 1 },
+              start: { column: 0, line: 1 }
+            },
+            message: "Failed to format the code"
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Stylistic",
+      description: "Use stylua to format lua files"
+    },
+    fixable: "whitespace",
+    messages,
+    schema: [
+      {
+        additionalProperties: true,
+        properties: {
+          language: {
+            required: true,
+            type: "string"
+          },
+          languageOptions: {
+            type: "object"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "layout"
+  }
+};
+var parserPlain = {
+  meta: {
+    name: "eslint-parser-plain"
+  },
+  ...dist_exports
+};
+var index = {
+  parserPlain,
+  rules: {
+    stylua
+  }
+};
+export {
+  index as default
+};