eslint-plugin-perfectionist 2.5.0 → 2.7.0

package/dist/index.mjs

@@ -1,139 +1,139 @@
-import _ from "node:path";
-import { ESLintUtils as ue, ASTUtils as W } from "@typescript-eslint/utils";
-import { minimatch as $ } from "minimatch";
-import de from "natural-compare-lite";
-import { builtinModules as ce } from "node:module";
-let v = ue.RuleCreator(
-  (t) => `https://eslint-plugin-perfectionist.azat.io/rules/${t}`
-), E = (t, o) => {
-  for (let s = 0, l = t.length; s < l; s++) {
-    let r = t[s];
-    if (o.group === r || Array.isArray(r) && typeof o.group == "string" && r.includes(o.group))
+import W from "node:path";
+import { ESLintUtils as de, ASTUtils as K } from "@typescript-eslint/utils";
+import { minimatch as D } from "minimatch";
+import ce from "natural-compare-lite";
+import { builtinModules as fe } from "node:module";
+let A = de.RuleCreator(
+  (e) => `https://eslint-plugin-perfectionist.azat.io/rules/${e}`
+), h = (e, i) => {
+  for (let s = 0, l = e.length; s < l; s++) {
+    let r = e[s];
+    if (i.group === r || Array.isArray(r) && typeof i.group == "string" && r.includes(i.group))
       return s;
   }
-  return t.length;
-}, O = (t) => {
-  let [o, s] = t;
-  return s - o;
-}, j = (t) => t > 0;
-var i = /* @__PURE__ */ ((t) => (t.alphabetical = "alphabetical", t["line-length"] = "line-length", t.natural = "natural", t))(i || {}), c = /* @__PURE__ */ ((t) => (t.desc = "desc", t.asc = "asc", t))(c || {});
-let M = (t) => {
-  let o, s = (r) => {
-    !o && t.flat().includes(r) && (o = r);
+  return e.length;
+}, I = (e) => {
+  let [i, s] = e;
+  return s - i;
+}, O = (e) => e > 0;
+var u = /* @__PURE__ */ ((e) => (e.alphabetical = "alphabetical", e["line-length"] = "line-length", e.natural = "natural", e))(u || {}), g = /* @__PURE__ */ ((e) => (e.desc = "desc", e.asc = "asc", e))(g || {}), L = /* @__PURE__ */ ((e) => (e["values-first"] = "values-first", e["types-first"] = "types-first", e.mixed = "mixed", e))(L || {});
+let G = (e) => {
+  let i, s = (r) => {
+    !i && e.flat().includes(r) && (i = r);
   };
   return {
-    getGroup: () => o ?? "unknown",
-    setCustomGroups: (r, e) => {
+    getGroup: () => i ?? "unknown",
+    setCustomGroups: (r, t) => {
       if (r)
-        for (let [a, p] of Object.entries(r))
-          Array.isArray(p) && p.some(
-            (n) => $(e, n, {
+        for (let [a, n] of Object.entries(r))
+          Array.isArray(n) && n.some(
+            (o) => D(t, o, {
               nocomment: !0
             })
-          ) && s(a), typeof p == "string" && $(e, p, {
+          ) && s(a), typeof n == "string" && D(t, n, {
             nocomment: !0
           }) && s(a);
     },
     defineGroup: s
   };
-}, A = (t, o, s) => {
-  var a, p;
-  if ((a = o.dependencies) != null && a.includes(t.name))
+}, S = (e, i, s) => {
+  var a, n;
+  if ((a = i.dependencies) != null && a.includes(e.name))
     return -1;
-  if ((p = t.dependencies) != null && p.includes(o.name))
+  if ((n = e.dependencies) != null && n.includes(i.name))
     return 1;
-  let l = s.order === "asc" ? 1 : -1, r, e = (n) => s["ignore-case"] ? n.toLowerCase() : n;
-  return s.type === i.alphabetical ? r = (n, u) => e(n.name).localeCompare(e(u.name)) : s.type === i.natural ? r = (n, u) => de(e(n.name), e(u.name)) : r = (n, u) => {
-    let y = n.size, m = u.size, f = s["max-line-length"];
-    if (f) {
-      let d = (g, b) => g > f && b.hasMultipleImportDeclarations;
-      d(y, n) && (y = n.name.length + 10), d(m, u) && (m = u.name.length + 10);
+  let l = s.order === "asc" ? 1 : -1, r, t = (o) => s["ignore-case"] ? o.toLowerCase() : o;
+  return s.type === u.alphabetical ? r = (o, p) => t(o.name).localeCompare(t(p.name)) : s.type === u.natural ? r = (o, p) => ce(t(o.name), t(p.name)) : r = (o, p) => {
+    let f = o.size, y = p.size, d = s["max-line-length"];
+    if (d) {
+      let c = (m, x) => m > d && x.hasMultipleImportDeclarations;
+      c(f, o) && (f = o.name.length + 10), c(y, p) && (y = p.name.length + 10);
     }
-    return y - m;
-  }, l * r(t, o);
-}, w = (t, o) => [...t].sort((s, l) => A(s, l, o)), fe = (t, o) => {
-  let s = o.getTokenAfter(t, {
+    return f - y;
+  }, l * r(e, i);
+}, v = (e, i) => [...e].sort((s, l) => S(s, l, i)), ge = (e, i) => {
+  let s = i.getTokenAfter(e, {
     filter: ({ value: l, type: r }) => !(r === "Punctuator" && [",", ";"].includes(l)),
     includeComments: !0
   });
-  return ((s == null ? void 0 : s.type) === "Block" || (s == null ? void 0 : s.type) === "Line") && t.loc.end.line === s.loc.end.line ? s : null;
-}, pe = (t, o) => Array.isArray(t) && t.some(
-  (s) => $(o.trim(), s, {
+  return ((s == null ? void 0 : s.type) === "Block" || (s == null ? void 0 : s.type) === "Line") && e.loc.end.line === s.loc.end.line ? s : null;
+}, X = (e, i) => Array.isArray(e) && e.some(
+  (s) => D(i.trim(), s, {
     nocomment: !0
   })
-) || typeof t == "string" && $(o.trim(), t, {
+) || typeof e == "string" && D(i.trim(), e, {
   nocomment: !0
-}) || t === !0, J = (t, o) => {
-  let [s, l] = o.getTokensBefore(t, {
-    filter: ({ value: r, type: e }) => !(e === "Punctuator" && [",", ";"].includes(r)),
+}) || e === !0, V = (e, i) => {
+  let [s, l] = i.getTokensBefore(e, {
+    filter: ({ value: r, type: t }) => !(t === "Punctuator" && [",", ";"].includes(r)),
     includeComments: !0,
     count: 2
   });
-  return ((l == null ? void 0 : l.type) === "Block" || (l == null ? void 0 : l.type) === "Line") && t.loc.start.line - l.loc.end.line <= 1 && (s == null ? void 0 : s.loc.end.line) !== l.loc.start.line ? l : null;
-}, T = (t, o, s) => {
-  var p;
-  let l = t.range.at(0), r = t.range.at(1), e = o.text.slice(l, r);
-  if (W.isParenthesized(t, o)) {
-    let n = o.getTokenBefore(
-      t,
-      W.isOpeningParenToken
-    ), u = o.getTokenAfter(
-      t,
-      W.isClosingParenToken
+  return ((l == null ? void 0 : l.type) === "Block" || (l == null ? void 0 : l.type) === "Line") && e.loc.start.line - l.loc.end.line <= 1 && (s == null ? void 0 : s.loc.end.line) !== l.loc.start.line ? l : null;
+}, T = (e, i, s) => {
+  var n;
+  let l = e.range.at(0), r = e.range.at(1), t = i.text.slice(l, r);
+  if (K.isParenthesized(e, i)) {
+    let o = i.getTokenBefore(
+      e,
+      K.isOpeningParenToken
+    ), p = i.getTokenAfter(
+      e,
+      K.isClosingParenToken
     );
-    l = n.range.at(0), r = u.range.at(1);
+    l = o.range.at(0), r = p.range.at(1);
   }
-  let a = J(t, o);
-  if (e.endsWith(";") || e.endsWith(",")) {
-    let n = o.getTokensAfter(t, {
+  let a = V(e, i);
+  if (t.endsWith(";") || t.endsWith(",")) {
+    let o = i.getTokensAfter(e, {
       includeComments: !0,
       count: 2
     });
-    t.loc.start.line === ((p = n.at(1)) == null ? void 0 : p.loc.start.line) && (r -= 1);
+    e.loc.start.line === ((n = o.at(1)) == null ? void 0 : n.loc.start.line) && (r -= 1);
   }
-  return a && !pe(
+  return a && !X(
     (s == null ? void 0 : s.partitionComment) ?? !1,
     a.value
   ) && (l = a.range.at(0)), [l, r];
-}, L = (t, o, s, l, r) => {
-  var p, n;
-  let e = [], a = ((p = o.at(0)) == null ? void 0 : p.node.loc.start.line) === ((n = o.at(-1)) == null ? void 0 : n.node.loc.end.line);
-  for (let u = 0, y = o.length; u < y; u++) {
-    let { node: m } = o.at(u);
-    e.push(
-      t.replaceTextRange(
-        T(m, l, r),
+}, M = (e, i, s, l, r) => {
+  var n, o;
+  let t = [], a = ((n = i.at(0)) == null ? void 0 : n.node.loc.start.line) === ((o = i.at(-1)) == null ? void 0 : o.node.loc.end.line);
+  for (let p = 0, f = i.length; p < f; p++) {
+    let { node: y } = i.at(p);
+    t.push(
+      e.replaceTextRange(
+        T(y, l, r),
         l.text.slice(
-          ...T(s.at(u).node, l, r)
+          ...T(s.at(p).node, l, r)
         )
       )
     );
-    let f = fe(s.at(u).node, l);
-    if (f && !a) {
-      let g = [
-        l.getTokenBefore(f).range.at(1),
-        f.range.at(1)
+    let d = ge(s.at(p).node, l);
+    if (d && !a) {
+      let m = [
+        l.getTokenBefore(d).range.at(1),
+        d.range.at(1)
       ];
-      e.push(t.replaceTextRange(g, ""));
-      let b = l.getTokenAfter(m);
-      e.push(
-        t.insertTextAfter(
-          (b == null ? void 0 : b.loc.end.line) === m.loc.end.line ? b : m,
-          l.text.slice(...g)
+      t.push(e.replaceTextRange(m, ""));
+      let x = l.getTokenAfter(y);
+      t.push(
+        e.insertTextAfter(
+          (x == null ? void 0 : x.loc.end.line) === y.loc.end.line ? x : y,
+          l.text.slice(...m)
         )
       );
     }
   }
-  return e;
-}, k = (t = {}, o) => Object.assign(o, t), P = (t, o) => {
-  if (t.length > 1)
-    for (let s = 1; s < t.length; s++) {
-      let l = t.at(s - 1), r = t.at(s);
-      l && r && o(l, r, s - 1);
+  return t;
+}, j = (e = {}, i) => Object.assign(i, e), P = (e, i) => {
+  if (e.length > 1)
+    for (let s = 1; s < e.length; s++) {
+      let l = e.at(s - 1), r = e.at(s);
+      l && r && i(l, r, s - 1);
     }
 };
-const X = "sort-svelte-attributes", ge = v({
-  name: X,
+const q = "sort-svelte-attributes", ye = A({
+  name: q,
   meta: {
     type: "suggestion",
     docs: {
@@ -149,16 +149,16 @@ const X = "sort-svelte-attributes", ge = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -178,64 +178,64 @@ const X = "sort-svelte-attributes", ge = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => _.extname(t.filename) !== ".svelte" ? {} : {
-    SvelteStartTag: (o) => {
-      if (o.attributes.length > 1) {
-        let s = k(t.options.at(0), {
-          type: i.alphabetical,
-          order: c.asc,
+  create: (e) => W.extname(e.filename) !== ".svelte" ? {} : {
+    SvelteStartTag: (i) => {
+      if (i.attributes.length > 1) {
+        let s = j(e.options.at(0), {
+          type: u.alphabetical,
+          order: g.asc,
           "ignore-case": !1,
           "custom-groups": {},
           groups: []
-        }), l = o.attributes.reduce(
-          (r, e) => {
-            if (e.type === "SvelteSpreadAttribute")
+        }), l = i.attributes.reduce(
+          (r, t) => {
+            if (t.type === "SvelteSpreadAttribute")
               return r.push([]), r;
-            let a, { getGroup: p, defineGroup: n, setCustomGroups: u } = M(
+            let a, { getGroup: n, defineGroup: o, setCustomGroups: p } = G(
               s.groups
             );
-            return e.key.type === "SvelteSpecialDirectiveKey" ? a = t.sourceCode.text.slice(...e.key.range) : typeof e.key.name == "string" ? { name: a } = e.key : a = t.sourceCode.text.slice(...e.key.range), u(s["custom-groups"], a), e.type === "SvelteShorthandAttribute" && (n("svelte-shorthand"), n("shorthand")), (!("value" in e) || Array.isArray(e.value) && !e.value.at(0)) && n("shorthand"), e.loc.start.line !== e.loc.end.line && n("multiline"), r.at(-1).push({
-              size: O(e.range),
-              node: e,
-              group: p(),
+            return t.key.type === "SvelteSpecialDirectiveKey" ? a = e.sourceCode.text.slice(...t.key.range) : typeof t.key.name == "string" ? { name: a } = t.key : a = e.sourceCode.text.slice(...t.key.range), p(s["custom-groups"], a), t.type === "SvelteShorthandAttribute" && (o("svelte-shorthand"), o("shorthand")), (!("value" in t) || Array.isArray(t.value) && !t.value.at(0)) && o("shorthand"), t.loc.start.line !== t.loc.end.line && o("multiline"), r.at(-1).push({
+              size: I(t.range),
+              node: t,
+              group: n(),
               name: a
             }), r;
           },
           [[]]
         );
         for (let r of l)
-          P(r, (e, a) => {
-            let p = E(s.groups, e), n = E(s.groups, a);
-            (p > n || p === n && j(A(e, a, s))) && t.report({
+          P(r, (t, a) => {
+            let n = h(s.groups, t), o = h(s.groups, a);
+            (n > o || n === o && O(S(t, a, s))) && e.report({
               messageId: "unexpectedSvelteAttributesOrder",
               data: {
-                left: e.name,
+                left: t.name,
                 right: a.name
               },
               node: a.node,
-              fix: (u) => {
-                let y = {};
-                for (let f of r) {
-                  let d = E(s.groups, f);
-                  d in y ? y[d] = w(
-                    [...y[d], f],
+              fix: (p) => {
+                let f = {};
+                for (let d of r) {
+                  let c = h(s.groups, d);
+                  c in f ? f[c] = v(
+                    [...f[c], d],
                     s
-                  ) : y[d] = [f];
+                  ) : f[c] = [d];
                 }
-                let m = [];
-                for (let f of Object.keys(y).sort(
-                  (d, g) => Number(d) - Number(g)
+                let y = [];
+                for (let d of Object.keys(f).sort(
+                  (c, m) => Number(c) - Number(m)
                 ))
-                  m.push(...w(y[f], s));
-                return L(
-                  u,
+                  y.push(...v(f[d], s));
+                return M(
+                  p,
                   r,
-                  m,
-                  t.sourceCode
+                  y,
+                  e.sourceCode
                 );
               }
             });
@@ -243,8 +243,8 @@ const X = "sort-svelte-attributes", ge = v({
       }
     }
   }
-}), q = "sort-astro-attributes", ye = v({
-  name: q,
+}), H = "sort-astro-attributes", me = A({
+  name: H,
   meta: {
     type: "suggestion",
     docs: {
@@ -260,16 +260,16 @@ const X = "sort-svelte-attributes", ge = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -289,66 +289,66 @@ const X = "sort-svelte-attributes", ge = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
   // @ts-ignore
-  create: (t) => _.extname(t.filename) !== ".astro" ? {} : {
-    JSXElement: (o) => {
-      let { attributes: s } = o.openingElement;
+  create: (e) => W.extname(e.filename) !== ".astro" ? {} : {
+    JSXElement: (i) => {
+      let { attributes: s } = i.openingElement;
       if (s.length > 1) {
-        let l = k(t.options.at(0), {
-          type: i.alphabetical,
-          order: c.asc,
+        let l = j(e.options.at(0), {
+          type: u.alphabetical,
+          order: g.asc,
           "ignore-case": !1,
           "custom-groups": {},
           groups: []
         }), r = s.reduce(
-          (e, a) => {
+          (t, a) => {
             if (a.type === "JSXSpreadAttribute")
-              return e.push([]), e;
-            let p = typeof a.name.name == "string" ? a.name.name : t.sourceCode.text.slice(...a.name.range), { getGroup: n, defineGroup: u, setCustomGroups: y } = M(
+              return t.push([]), t;
+            let n = typeof a.name.name == "string" ? a.name.name : e.sourceCode.text.slice(...a.name.range), { getGroup: o, defineGroup: p, setCustomGroups: f } = G(
               l.groups
             );
-            return y(l["custom-groups"], p), a.type === "AstroShorthandAttribute" && (u("astro-shorthand"), u("shorthand")), a.value === null && u("shorthand"), a.loc.start.line !== a.loc.end.line && u("multiline"), e.at(-1).push({
-              size: O(a.range),
+            return f(l["custom-groups"], n), a.type === "AstroShorthandAttribute" && (p("astro-shorthand"), p("shorthand")), a.value === null && p("shorthand"), a.loc.start.line !== a.loc.end.line && p("multiline"), t.at(-1).push({
+              size: I(a.range),
               node: a,
-              group: n(),
-              name: p
-            }), e;
+              group: o(),
+              name: n
+            }), t;
           },
           [[]]
         );
-        for (let e of r)
-          P(e, (a, p) => {
-            let n = E(l.groups, a), u = E(l.groups, p);
-            (n > u || n === u && j(A(a, p, l))) && t.report({
+        for (let t of r)
+          P(t, (a, n) => {
+            let o = h(l.groups, a), p = h(l.groups, n);
+            (o > p || o === p && O(S(a, n, l))) && e.report({
               messageId: "unexpectedAstroAttributesOrder",
               data: {
                 left: a.name,
-                right: p.name
+                right: n.name
               },
-              node: p.node,
-              fix: (y) => {
-                let m = {};
-                for (let d of e) {
-                  let g = E(l.groups, d);
-                  g in m ? m[g] = w(
-                    [...m[g], d],
+              node: n.node,
+              fix: (f) => {
+                let y = {};
+                for (let c of t) {
+                  let m = h(l.groups, c);
+                  m in y ? y[m] = v(
+                    [...y[m], c],
                     l
-                  ) : m[g] = [d];
+                  ) : y[m] = [c];
                 }
-                let f = [];
-                for (let d of Object.keys(m).sort(
-                  (g, b) => Number(g) - Number(b)
+                let d = [];
+                for (let c of Object.keys(y).sort(
+                  (m, x) => Number(m) - Number(x)
                 ))
-                  f.push(...w(m[d], l));
-                return L(
-                  y,
-                  e,
+                  d.push(...v(y[c], l));
+                return M(
                   f,
-                  t.sourceCode
+                  t,
+                  d,
+                  e.sourceCode
                 );
               }
             });
@@ -357,9 +357,9 @@ const X = "sort-svelte-attributes", ge = v({
     }
   }
 });
-let I = (t) => t.replaceAll(/\s\s+/g, " ").trim();
-const K = "sort-array-includes", me = v({
-  name: K,
+let k = (e) => e.replaceAll(/\s\s+/g, " ").trim();
+const Q = "sort-array-includes", he = A({
+  name: Q,
   meta: {
     type: "suggestion",
     docs: {
@@ -372,16 +372,16 @@ const K = "sort-array-includes", me = v({
         properties: {
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -402,48 +402,48 @@ const K = "sort-array-includes", me = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    MemberExpression: (o) => {
-      if ((o.object.type === "ArrayExpression" || o.object.type === "NewExpression") && o.property.type === "Identifier" && o.property.name === "includes") {
-        let s = o.object.type === "ArrayExpression" ? o.object.elements : o.object.arguments;
+  create: (e) => ({
+    MemberExpression: (i) => {
+      if ((i.object.type === "ArrayExpression" || i.object.type === "NewExpression") && i.property.type === "Identifier" && i.property.name === "includes") {
+        let s = i.object.type === "ArrayExpression" ? i.object.elements : i.object.arguments;
         if (s.length > 1) {
-          let l = k(t.options.at(0), {
-            type: i.alphabetical,
-            order: c.asc,
+          let l = j(e.options.at(0), {
+            type: u.alphabetical,
+            order: g.asc,
             "ignore-case": !1,
             "spread-last": !1
           }), r = s.reduce(
-            (e, a) => (a !== null && e.at(0).push({
-              name: a.type === "Literal" ? `${a.value}` : t.sourceCode.text.slice(...a.range),
-              size: O(a.range),
+            (t, a) => (a !== null && t.at(0).push({
+              name: a.type === "Literal" ? `${a.value}` : e.sourceCode.text.slice(...a.range),
+              size: I(a.range),
               type: a.type,
               node: a
-            }), e),
+            }), t),
             [[], []]
           ).flat();
-          P(r, (e, a) => {
-            let p;
-            l["spread-last"] && e.node.type === "Literal" && a.node.type === "SpreadElement" ? p = !1 : l["spread-last"] && e.node.type === "SpreadElement" && a.node.type === "Literal" ? p = !0 : p = j(A(e, a, l)), p && t.report({
+          P(r, (t, a) => {
+            let n;
+            l["spread-last"] && t.node.type === "Literal" && a.node.type === "SpreadElement" ? n = !1 : l["spread-last"] && t.node.type === "SpreadElement" && a.node.type === "Literal" ? n = !0 : n = O(S(t, a, l)), n && e.report({
               messageId: "unexpectedArrayIncludesOrder",
               data: {
-                left: I(e.name),
-                right: I(a.name)
+                left: k(t.name),
+                right: k(a.name)
               },
               node: a.node,
-              fix: (n) => {
-                let u = w(r, l);
+              fix: (o) => {
+                let p = v(r, l);
                 if (l["spread-last"])
-                  for (let y = 0, m = u.length; y < m; y++)
-                    u.at(y).node.type === "SpreadElement" && u.push(u.splice(y, 1).at(0));
-                return L(
-                  n,
+                  for (let f = 0, y = p.length; f < y; f++)
+                    p.at(f).node.type === "SpreadElement" && p.push(p.splice(f, 1).at(0));
+                return M(
+                  o,
                   r,
-                  u,
-                  t.sourceCode
+                  p,
+                  e.sourceCode
                 );
               }
             });
@@ -452,8 +452,8 @@ const K = "sort-array-includes", me = v({
       }
     }
   })
-}), H = "sort-vue-attributes", he = v({
-  name: H,
+}), Y = "sort-vue-attributes", be = A({
+  name: Y,
   meta: {
     type: "suggestion",
     docs: {
@@ -469,16 +469,16 @@ const K = "sort-array-includes", me = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -499,70 +499,70 @@ const K = "sort-array-includes", me = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => {
-    if (_.extname(t.filename) !== ".vue")
+  create: (e) => {
+    if (W.extname(e.filename) !== ".vue")
       return {};
-    if (!("defineTemplateBodyVisitor" in t.sourceCode.parserServices))
+    if (!("defineTemplateBodyVisitor" in e.sourceCode.parserServices))
       return {};
-    let { defineTemplateBodyVisitor: o } = t.sourceCode.parserServices;
-    return o({
+    let { defineTemplateBodyVisitor: i } = e.sourceCode.parserServices;
+    return i({
       VStartTag: (s) => {
         if (s.attributes.length > 1) {
-          let l = k(t.options.at(0), {
-            type: i.alphabetical,
-            order: c.asc,
+          let l = j(e.options.at(0), {
+            type: u.alphabetical,
+            order: g.asc,
             "ignore-case": !1,
             "custom-groups": {},
             groups: []
           }), r = s.attributes.reduce(
-            (e, a) => {
+            (t, a) => {
               if (a.key.type === "VDirectiveKey" && a.key.name.rawName === "bind")
-                return e.push([]), e;
-              let p, { getGroup: n, defineGroup: u, setCustomGroups: y } = M(
+                return t.push([]), t;
+              let n, { getGroup: o, defineGroup: p, setCustomGroups: f } = G(
                 l.groups
               );
-              return typeof a.key.name == "string" && a.key.type !== "VDirectiveKey" ? p = a.key.rawName : p = t.sourceCode.text.slice(...a.key.range), y(l["custom-groups"], p), a.value === null && u("shorthand"), a.loc.start.line !== a.loc.end.line && u("multiline"), e.at(-1).push({
-                size: O(a.range),
+              return typeof a.key.name == "string" && a.key.type !== "VDirectiveKey" ? n = a.key.rawName : n = e.sourceCode.text.slice(...a.key.range), f(l["custom-groups"], n), a.value === null && p("shorthand"), a.loc.start.line !== a.loc.end.line && p("multiline"), t.at(-1).push({
+                size: I(a.range),
                 node: a,
-                group: n(),
-                name: p
-              }), e;
+                group: o(),
+                name: n
+              }), t;
             },
             [[]]
           );
-          for (let e of r)
-            P(e, (a, p) => {
-              let n = E(l.groups, a), u = E(l.groups, p);
-              (n > u || n === u && j(A(a, p, l))) && t.report({
+          for (let t of r)
+            P(t, (a, n) => {
+              let o = h(l.groups, a), p = h(l.groups, n);
+              (o > p || o === p && O(S(a, n, l))) && e.report({
                 messageId: "unexpectedVueAttributesOrder",
                 data: {
                   left: a.name,
-                  right: p.name
+                  right: n.name
                 },
-                node: p.node,
-                fix: (y) => {
-                  let m = {};
-                  for (let d of e) {
-                    let g = E(l.groups, d);
-                    g in m ? m[g] = w(
-                      [...m[g], d],
+                node: n.node,
+                fix: (f) => {
+                  let y = {};
+                  for (let c of t) {
+                    let m = h(l.groups, c);
+                    m in y ? y[m] = v(
+                      [...y[m], c],
                       l
-                    ) : m[g] = [d];
+                    ) : y[m] = [c];
                   }
-                  let f = [];
-                  for (let d of Object.keys(m).sort(
-                    (g, b) => Number(g) - Number(b)
+                  let d = [];
+                  for (let c of Object.keys(y).sort(
+                    (m, x) => Number(m) - Number(x)
                   ))
-                    f.push(...w(m[d], l));
-                  return L(
-                    y,
-                    e,
+                    d.push(...v(y[c], l));
+                  return M(
                     f,
-                    t.sourceCode
+                    t,
+                    d,
+                    e.sourceCode
                   );
                 }
               });
@@ -571,8 +571,8 @@ const K = "sort-array-includes", me = v({
       }
     });
   }
-}), Q = "sort-named-exports", be = v({
-  name: Q,
+}), Z = "sort-named-exports", xe = A({
+  name: Z,
   meta: {
     type: "suggestion",
     docs: {
@@ -585,21 +585,30 @@ const K = "sort-array-includes", me = v({
         properties: {
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
             type: "boolean",
             default: !1
+          },
+          "group-kind": {
+            enum: [
+              L.mixed,
+              L["values-first"],
+              L["types-first"]
+            ],
+            default: L.mixed,
+            type: "string"
           }
         },
         additionalProperties: !1
@@ -611,43 +620,44 @@ const K = "sort-array-includes", me = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    ExportNamedDeclaration: (o) => {
-      if (o.specifiers.length > 1) {
-        let s = k(t.options.at(0), {
-          type: i.alphabetical,
+  create: (e) => ({
+    ExportNamedDeclaration: (i) => {
+      if (i.specifiers.length > 1) {
+        let s = j(e.options.at(0), {
+          type: u.alphabetical,
           "ignore-case": !1,
-          order: c.asc
-        }), l = o.specifiers.map((r) => ({
-          size: O(r.range),
-          name: r.local.name,
-          node: r
-        }));
-        P(l, (r, e) => {
-          j(A(r, e, s)) && t.report({
-            messageId: "unexpectedNamedExportsOrder",
-            data: {
-              left: r.name,
-              right: e.name
-            },
-            node: e.node,
-            fix: (a) => L(
-              a,
-              l,
-              w(l, s),
-              t.sourceCode
-            )
-          });
+          order: g.asc,
+          "group-kind": L.mixed
+        }), l = i.specifiers.map((a) => ({
+          size: I(a.range),
+          name: a.local.name,
+          node: a,
+          group: a.exportKind
+        })), r = s["group-kind"] !== L.mixed, t = s["group-kind"] === L["values-first"] ? ["value", "type"] : ["type", "value"];
+        P(l, (a, n) => {
+          let o = h(t, a), p = h(t, n);
+          if (r && o > p || (!r || o === p) && O(S(a, n, s))) {
+            let f = r ? t.map((y) => l.filter((d) => d.group === y)).map((y) => v(y, s)).flat() : v(l, s);
+            e.report({
+              messageId: "unexpectedNamedExportsOrder",
+              data: {
+                left: a.name,
+                right: n.name
+              },
+              node: n.node,
+              fix: (y) => M(y, l, f, e.sourceCode)
+            });
+          }
         });
       }
     }
   })
-}), Y = "sort-named-imports", xe = v({
-  name: Y,
+}), F = "sort-named-imports", Ee = A({
+  name: F,
   meta: {
     type: "suggestion",
     docs: {
@@ -660,16 +670,16 @@ const K = "sort-array-includes", me = v({
         properties: {
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -679,6 +689,15 @@ const K = "sort-array-includes", me = v({
           "ignore-alias": {
             type: "boolean",
             default: !1
+          },
+          "group-kind": {
+            enum: [
+              L.mixed,
+              L["values-first"],
+              L["types-first"]
+            ],
+            default: L.mixed,
+            type: "string"
           }
         },
         additionalProperties: !1
@@ -690,55 +709,56 @@ const K = "sort-array-includes", me = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    ImportDeclaration: (o) => {
-      let s = o.specifiers.filter(
+  create: (e) => ({
+    ImportDeclaration: (i) => {
+      let s = i.specifiers.filter(
         ({ type: l }) => l === "ImportSpecifier"
       );
       if (s.length > 1) {
-        let l = k(t.options.at(0), {
-          type: i.alphabetical,
+        let l = j(e.options.at(0), {
+          type: u.alphabetical,
           "ignore-alias": !0,
           "ignore-case": !1,
-          order: c.asc
-        }), r = s.map((e) => {
-          let { name: a } = e.local;
-          return l["ignore-alias"] && e.type === "ImportSpecifier" && ({ name: a } = e.imported), {
-            size: O(e.range),
-            node: e,
-            name: a
+          order: g.asc,
+          "group-kind": L.mixed
+        }), r = s.map((n) => {
+          let o, { name: p } = n.local;
+          return n.type === "ImportSpecifier" && (l["ignore-alias"] && ({ name: p } = n.imported), o = n.importKind), {
+            size: I(n.range),
+            node: n,
+            name: p,
+            group: o
           };
-        });
-        P(r, (e, a) => {
-          j(A(e, a, l)) && t.report({
-            messageId: "unexpectedNamedImportsOrder",
-            data: {
-              left: e.name,
-              right: a.name
-            },
-            node: a.node,
-            fix: (p) => L(
-              p,
-              r,
-              w(r, l),
-              t.sourceCode
-            )
-          });
+        }), t = l["group-kind"] !== L.mixed, a = l["group-kind"] === L["values-first"] ? ["value", "type"] : ["type", "value"];
+        P(r, (n, o) => {
+          let p = h(a, n), f = h(a, o);
+          if (t && p > f || (!t || p === f) && O(S(n, o, l))) {
+            let y = t ? a.map((d) => r.filter((c) => c.group === d)).map((d) => v(d, l)).flat() : v(r, l);
+            e.report({
+              messageId: "unexpectedNamedImportsOrder",
+              data: {
+                left: n.name,
+                right: o.name
+              },
+              node: o.node,
+              fix: (d) => M(d, r, y, e.sourceCode)
+            });
+          }
         });
       }
     }
   })
 });
-let z = (t, o, s) => t.lines.slice(
-  o.node.loc.end.line,
+let z = (e, i, s) => e.lines.slice(
+  i.node.loc.end.line,
   s.node.loc.start.line - 1
 ).filter((r) => !r.trim().length).length;
-const Z = "sort-object-types", Ee = v({
-  name: Z,
+const ee = "sort-object-types", Ne = A({
+  name: ee,
   meta: {
     type: "suggestion",
     docs: {
@@ -754,16 +774,16 @@ const Z = "sort-object-types", Ee = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -788,88 +808,88 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    TSTypeLiteral: (o) => {
-      if (o.members.length > 1) {
-        let s = k(t.options.at(0), {
+  create: (e) => ({
+    TSTypeLiteral: (i) => {
+      if (i.members.length > 1) {
+        let s = j(e.options.at(0), {
           "partition-by-new-line": !1,
-          type: i.alphabetical,
+          type: u.alphabetical,
           "ignore-case": !1,
-          order: c.asc,
+          order: g.asc,
           "custom-groups": {},
           groups: []
-        }), l = o.members.reduce(
-          (r, e) => {
-            var N, h, C, x;
-            let a, p = t.sourceCode.text.slice(
-              e.range.at(0),
-              e.range.at(1)
-            ), n = (N = r.at(-1)) == null ? void 0 : N.at(-1), { getGroup: u, defineGroup: y, setCustomGroups: m } = M(
+        }), l = i.members.reduce(
+          (r, t) => {
+            var C, b, N, E;
+            let a, n = e.sourceCode.text.slice(
+              t.range.at(0),
+              t.range.at(1)
+            ), o = (C = r.at(-1)) == null ? void 0 : C.at(-1), { getGroup: p, defineGroup: f, setCustomGroups: y } = G(
               s.groups
-            ), f = (S) => S.replace(/(,|;)$/, "");
-            if (e.type === "TSPropertySignature")
-              e.key.type === "Identifier" ? { name: a } = e.key : e.key.type === "Literal" ? a = `${e.key.value}` : a = t.sourceCode.text.slice(
-                e.range.at(0),
-                (h = e.typeAnnotation) == null ? void 0 : h.range.at(0)
+            ), d = (w) => w.replace(/(,|;)$/, "");
+            if (t.type === "TSPropertySignature")
+              t.key.type === "Identifier" ? { name: a } = t.key : t.key.type === "Literal" ? a = `${t.key.value}` : a = e.sourceCode.text.slice(
+                t.range.at(0),
+                (b = t.typeAnnotation) == null ? void 0 : b.range.at(0)
               );
-            else if (e.type === "TSIndexSignature") {
-              let S = ((C = e.typeAnnotation) == null ? void 0 : C.range.at(0)) ?? e.range.at(1);
-              a = f(
-                t.sourceCode.text.slice(e.range.at(0), S)
+            else if (t.type === "TSIndexSignature") {
+              let w = ((N = t.typeAnnotation) == null ? void 0 : N.range.at(0)) ?? t.range.at(1);
+              a = d(
+                e.sourceCode.text.slice(t.range.at(0), w)
               );
             } else
-              a = f(
-                t.sourceCode.text.slice(
-                  e.range.at(0),
-                  e.range.at(1)
+              a = d(
+                e.sourceCode.text.slice(
+                  t.range.at(0),
+                  t.range.at(1)
                 )
               );
-            m(s["custom-groups"], a), e.loc.start.line !== e.loc.end.line && y("multiline");
-            let g = p.endsWith(";") || p.endsWith(",") ? 1 : 0, b = {
-              size: O(e.range) - g,
-              node: e,
+            y(s["custom-groups"], a), t.loc.start.line !== t.loc.end.line && f("multiline");
+            let m = n.endsWith(";") || n.endsWith(",") ? 1 : 0, x = {
+              size: I(t.range) - m,
+              node: t,
               name: a
             };
-            return s["partition-by-new-line"] && n && z(t.sourceCode, n, b) && r.push([]), (x = r.at(-1)) == null || x.push({
-              ...b,
-              group: u()
+            return s["partition-by-new-line"] && o && z(e.sourceCode, o, x) && r.push([]), (E = r.at(-1)) == null || E.push({
+              ...x,
+              group: p()
             }), r;
           },
           [[]]
         );
         for (let r of l)
-          P(r, (e, a) => {
-            let p = E(s.groups, e), n = E(s.groups, a);
-            (p > n || p === n && j(A(e, a, s))) && t.report({
+          P(r, (t, a) => {
+            let n = h(s.groups, t), o = h(s.groups, a);
+            (n > o || n === o && O(S(t, a, s))) && e.report({
               messageId: "unexpectedObjectTypesOrder",
               data: {
-                left: I(e.name),
-                right: I(a.name)
+                left: k(t.name),
+                right: k(a.name)
               },
               node: a.node,
-              fix: (u) => {
-                let y = {};
-                for (let f of r) {
-                  let d = E(s.groups, f);
-                  d in y ? y[d] = w(
-                    [...y[d], f],
+              fix: (p) => {
+                let f = {};
+                for (let d of r) {
+                  let c = h(s.groups, d);
+                  c in f ? f[c] = v(
+                    [...f[c], d],
                     s
-                  ) : y[d] = [f];
+                  ) : f[c] = [d];
                 }
-                let m = [];
-                for (let f of Object.keys(y).sort(
-                  (d, g) => Number(d) - Number(g)
+                let y = [];
+                for (let d of Object.keys(f).sort(
+                  (c, m) => Number(c) - Number(m)
                 ))
-                  m.push(...w(y[f], s));
-                return L(
-                  u,
+                  y.push(...v(f[d], s));
+                return M(
+                  p,
                   r,
-                  m,
-                  t.sourceCode
+                  y,
+                  e.sourceCode
                 );
               }
             });
@@ -877,8 +897,8 @@ const Z = "sort-object-types", Ee = v({
       }
     }
   })
-}), F = "sort-union-types", Ce = v({
-  name: F,
+}), te = "sort-union-types", Ce = A({
+  name: te,
   meta: {
     type: "suggestion",
     docs: {
@@ -891,16 +911,16 @@ const Z = "sort-object-types", Ee = v({
         properties: {
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -921,50 +941,50 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    TSUnionType: (o) => {
-      let s = k(t.options.at(0), {
-        type: i.alphabetical,
+  create: (e) => ({
+    TSUnionType: (i) => {
+      let s = j(e.options.at(0), {
+        type: u.alphabetical,
         "nullable-last": !1,
         "ignore-case": !1,
-        order: c.asc
-      }), l = o.types.map((r) => ({
+        order: g.asc
+      }), l = i.types.map((r) => ({
         group: r.type === "TSNullKeyword" || r.type === "TSUndefinedKeyword" ? "nullable" : "unknown",
-        name: t.sourceCode.text.slice(...r.range),
-        size: O(r.range),
+        name: e.sourceCode.text.slice(...r.range),
+        size: I(r.range),
         node: r
       }));
-      P(l, (r, e) => {
-        let a = j(A(r, e, s));
-        s["nullable-last"] && (r.group === "nullable" && e.group === "unknown" ? a = !0 : r.group === "unknown" && e.group === "nullable" && (a = !1)), a && t.report({
+      P(l, (r, t) => {
+        let a = O(S(r, t, s));
+        s["nullable-last"] && (r.group === "nullable" && t.group === "unknown" ? a = !0 : r.group === "unknown" && t.group === "nullable" && (a = !1)), a && e.report({
           messageId: "unexpectedUnionTypesOrder",
           data: {
-            left: I(r.name),
-            right: I(e.name)
+            left: k(r.name),
+            right: k(t.name)
           },
-          node: e.node,
-          fix: (p) => {
-            let n = [];
+          node: t.node,
+          fix: (n) => {
+            let o = [];
             if (s["nullable-last"]) {
-              let u = [], y = l.filter((m) => m.group === "nullable" ? (u.push(m), !1) : !0);
-              n = [
-                ...w(y, s),
-                ...w(u, s)
+              let p = [], f = l.filter((y) => y.group === "nullable" ? (p.push(y), !1) : !0);
+              o = [
+                ...v(f, s),
+                ...v(p, s)
               ];
             } else
-              n = w(l, s);
-            return L(p, l, n, t.sourceCode);
+              o = v(l, s);
+            return M(n, l, o, e.sourceCode);
           }
         });
       });
     }
   })
-}), ee = "sort-interfaces", Ne = v({
-  name: ee,
+}), re = "sort-interfaces", ve = A({
+  name: re,
   meta: {
     type: "suggestion",
     docs: {
@@ -980,16 +1000,16 @@ const Z = "sort-object-types", Ee = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -1020,102 +1040,102 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    TSInterfaceDeclaration: (o) => {
-      if (o.body.body.length > 1) {
-        let s = k(t.options.at(0), {
+  create: (e) => ({
+    TSInterfaceDeclaration: (i) => {
+      if (i.body.body.length > 1) {
+        let s = j(e.options.at(0), {
           "partition-by-new-line": !1,
-          type: i.alphabetical,
+          type: u.alphabetical,
           "ignore-case": !1,
-          order: c.asc,
+          order: g.asc,
           "ignore-pattern": [],
           "custom-groups": {},
           groups: []
         });
         if (!s["ignore-pattern"].some(
-          (l) => $(o.id.name, l, {
+          (l) => D(i.id.name, l, {
             nocomment: !0
           })
         )) {
-          let l = o.body.body.reduce(
-            (r, e) => {
-              var f, d, g, b;
-              if (e.type === "TSCallSignatureDeclaration")
+          let l = i.body.body.reduce(
+            (r, t) => {
+              var d, c, m, x;
+              if (t.type === "TSCallSignatureDeclaration")
                 return r.push([]), r;
-              let a = (f = r.at(-1)) == null ? void 0 : f.at(-1), p, { getGroup: n, defineGroup: u, setCustomGroups: y } = M(
+              let a = (d = r.at(-1)) == null ? void 0 : d.at(-1), n, { getGroup: o, defineGroup: p, setCustomGroups: f } = G(
                 s.groups
               );
-              if (e.type === "TSPropertySignature")
-                if (e.key.type === "Identifier")
-                  ({ name: p } = e.key);
-                else if (e.key.type === "Literal")
-                  p = `${e.key.value}`;
+              if (t.type === "TSPropertySignature")
+                if (t.key.type === "Identifier")
+                  ({ name: n } = t.key);
+                else if (t.key.type === "Literal")
+                  n = `${t.key.value}`;
                 else {
-                  let N = ((d = e.typeAnnotation) == null ? void 0 : d.range.at(0)) ?? e.range.at(1) - (e.optional ? 1 : 0);
-                  p = t.sourceCode.text.slice(e.range.at(0), N);
+                  let C = ((c = t.typeAnnotation) == null ? void 0 : c.range.at(0)) ?? t.range.at(1) - (t.optional ? 1 : 0);
+                  n = e.sourceCode.text.slice(t.range.at(0), C);
                 }
-              else if (e.type === "TSIndexSignature") {
-                let N = ((g = e.typeAnnotation) == null ? void 0 : g.range.at(0)) ?? e.range.at(1);
-                p = t.sourceCode.text.slice(
-                  e.range.at(0),
-                  N
+              else if (t.type === "TSIndexSignature") {
+                let C = ((m = t.typeAnnotation) == null ? void 0 : m.range.at(0)) ?? t.range.at(1);
+                n = e.sourceCode.text.slice(
+                  t.range.at(0),
+                  C
                 );
               } else {
-                let N = ((b = e.returnType) == null ? void 0 : b.range.at(0)) ?? e.range.at(1);
-                p = t.sourceCode.text.slice(
-                  e.range.at(0),
-                  N
+                let C = ((x = t.returnType) == null ? void 0 : x.range.at(0)) ?? t.range.at(1);
+                n = e.sourceCode.text.slice(
+                  t.range.at(0),
+                  C
                 );
               }
-              let m = {
-                size: O(e.range),
-                node: e,
-                name: p
+              let y = {
+                size: I(t.range),
+                node: t,
+                name: n
               };
               return s["partition-by-new-line"] && a && z(
-                t.sourceCode,
+                e.sourceCode,
                 a,
-                m
-              ) && r.push([]), y(s["custom-groups"], p), e.loc.start.line !== e.loc.end.line && u("multiline"), r.at(-1).push({
-                ...m,
-                group: n()
+                y
+              ) && r.push([]), f(s["custom-groups"], n), t.loc.start.line !== t.loc.end.line && p("multiline"), r.at(-1).push({
+                ...y,
+                group: o()
               }), r;
             },
             [[]]
           );
           for (let r of l)
-            P(r, (e, a) => {
-              let p = E(s.groups, e), n = E(s.groups, a);
-              (p > n || p === n && j(A(e, a, s))) && t.report({
+            P(r, (t, a) => {
+              let n = h(s.groups, t), o = h(s.groups, a);
+              (n > o || n === o && O(S(t, a, s))) && e.report({
                 messageId: "unexpectedInterfacePropertiesOrder",
                 data: {
-                  left: I(e.name),
-                  right: I(a.name)
+                  left: k(t.name),
+                  right: k(a.name)
                 },
                 node: a.node,
-                fix: (u) => {
-                  let y = {};
-                  for (let f of r) {
-                    let d = E(s.groups, f);
-                    d in y ? y[d] = w(
-                      [...y[d], f],
+                fix: (p) => {
+                  let f = {};
+                  for (let d of r) {
+                    let c = h(s.groups, d);
+                    c in f ? f[c] = v(
+                      [...f[c], d],
                       s
-                    ) : y[d] = [f];
+                    ) : f[c] = [d];
                   }
-                  let m = [];
-                  for (let f of Object.keys(y).sort(
-                    (d, g) => Number(d) - Number(g)
+                  let y = [];
+                  for (let d of Object.keys(f).sort(
+                    (c, m) => Number(c) - Number(m)
                   ))
-                    m.push(...w(y[f], s));
-                  return L(
-                    u,
+                    y.push(...v(f[d], s));
+                  return M(
+                    p,
                     r,
-                    m,
-                    t.sourceCode
+                    y,
+                    e.sourceCode
                   );
                 }
               });
@@ -1124,8 +1144,8 @@ const Z = "sort-object-types", Ee = v({
       }
     }
   })
-}), te = "sort-jsx-props", we = v({
-  name: te,
+}), se = "sort-jsx-props", we = A({
+  name: se,
   meta: {
     type: "suggestion",
     docs: {
@@ -1141,16 +1161,16 @@ const Z = "sort-object-types", Ee = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           groups: {
@@ -1170,66 +1190,66 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => [".svelte", ".astro", ".vue"].includes(_.extname(t.filename)) ? {} : {
-    JSXElement: (o) => {
-      if (o.openingElement.attributes.length > 1) {
-        let s = k(t.options.at(0), {
-          type: i.alphabetical,
+  create: (e) => [".svelte", ".astro", ".vue"].includes(W.extname(e.filename)) ? {} : {
+    JSXElement: (i) => {
+      if (i.openingElement.attributes.length > 1) {
+        let s = j(e.options.at(0), {
+          type: u.alphabetical,
           "ignore-case": !1,
-          order: c.asc,
+          order: g.asc,
           "custom-groups": {},
           groups: []
-        }), l = o.openingElement.attributes.reduce(
-          (r, e) => {
-            if (e.type === "JSXSpreadAttribute")
+        }), l = i.openingElement.attributes.reduce(
+          (r, t) => {
+            if (t.type === "JSXSpreadAttribute")
               return r.push([]), r;
-            let a = e.name.type === "JSXNamespacedName" ? `${e.name.namespace.name}:${e.name.name.name}` : e.name.name, { getGroup: p, defineGroup: n, setCustomGroups: u } = M(
+            let a = t.name.type === "JSXNamespacedName" ? `${t.name.namespace.name}:${t.name.name.name}` : t.name.name, { getGroup: n, defineGroup: o, setCustomGroups: p } = G(
               s.groups
             );
-            u(s["custom-groups"], a), e.value === null && n("shorthand"), e.loc.start.line !== e.loc.end.line && n("multiline");
-            let y = {
-              size: O(e.range),
-              group: p(),
-              node: e,
+            p(s["custom-groups"], a), t.value === null && o("shorthand"), t.loc.start.line !== t.loc.end.line && o("multiline");
+            let f = {
+              size: I(t.range),
+              group: n(),
+              node: t,
               name: a
             };
-            return r.at(-1).push(y), r;
+            return r.at(-1).push(f), r;
           },
           [[]]
         );
         for (let r of l)
-          P(r, (e, a) => {
-            let p = E(s.groups, e), n = E(s.groups, a);
-            (p > n || p === n && j(A(e, a, s))) && t.report({
+          P(r, (t, a) => {
+            let n = h(s.groups, t), o = h(s.groups, a);
+            (n > o || n === o && O(S(t, a, s))) && e.report({
               messageId: "unexpectedJSXPropsOrder",
               data: {
-                left: e.name,
+                left: t.name,
                 right: a.name
               },
               node: a.node,
-              fix: (u) => {
-                let y = {};
-                for (let f of r) {
-                  let d = E(s.groups, f);
-                  d in y ? y[d] = w(
-                    [...y[d], f],
+              fix: (p) => {
+                let f = {};
+                for (let d of r) {
+                  let c = h(s.groups, d);
+                  c in f ? f[c] = v(
+                    [...f[c], d],
                     s
-                  ) : y[d] = [f];
+                  ) : f[c] = [d];
                 }
-                let m = [];
-                for (let f of Object.keys(y).sort(
-                  (d, g) => Number(d) - Number(g)
+                let y = [];
+                for (let d of Object.keys(f).sort(
+                  (c, m) => Number(c) - Number(m)
                 ))
-                  m.push(...w(y[f], s));
-                return L(
-                  u,
+                  y.push(...v(f[d], s));
+                return M(
+                  p,
                   r,
-                  m,
-                  t.sourceCode
+                  y,
+                  e.sourceCode
                 );
               }
             });
@@ -1237,8 +1257,8 @@ const Z = "sort-object-types", Ee = v({
       }
     }
   }
-}), re = "sort-exports", Se = v({
-  name: re,
+}), ae = "sort-exports", Se = A({
+  name: ae,
   meta: {
     type: "suggestion",
     docs: {
@@ -1251,16 +1271,16 @@ const Z = "sort-object-types", Ee = v({
         properties: {
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -1277,18 +1297,18 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => {
-    let o = k(t.options.at(0), {
-      type: i.alphabetical,
-      order: c.asc,
+  create: (e) => {
+    let i = j(e.options.at(0), {
+      type: u.alphabetical,
+      order: g.asc,
       "ignore-case": !1
     }), s = [[]], l = (r) => {
       r.type === "ExportAllDeclaration" && r.exported === null ? s.push([]) : s.at(-1).push({
-        size: O(r.range),
+        size: I(r.range),
         name: r.source.value,
         node: r
       });
@@ -1300,27 +1320,27 @@ const Z = "sort-object-types", Ee = v({
       },
       "Program:exit": () => {
         for (let r of s)
-          P(r, (e, a) => {
-            j(A(e, a, o)) && t.report({
+          P(r, (t, a) => {
+            O(S(t, a, i)) && e.report({
               messageId: "unexpectedExportsOrder",
               data: {
-                left: e.name,
+                left: t.name,
                 right: a.name
               },
               node: a.node,
-              fix: (p) => L(
-                p,
+              fix: (n) => M(
+                n,
                 r,
-                w(r, o),
-                t.sourceCode
+                v(r, i),
+                e.sourceCode
               )
             });
           });
       }
     };
   }
-}), se = "sort-imports", Ae = v({
-  name: se,
+}), oe = "sort-imports", ke = A({
+  name: oe,
   meta: {
     type: "suggestion",
     docs: {
@@ -1346,16 +1366,16 @@ const Z = "sort-object-types", Ee = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -1398,7 +1418,7 @@ const Z = "sort-object-types", Ee = v({
         definitions: {
           "is-line-length": {
             properties: {
-              type: { enum: [i["line-length"]], type: "string" }
+              type: { enum: [u["line-length"]], type: "string" }
             },
             required: ["type"],
             type: "object"
@@ -1423,31 +1443,31 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => {
-    let o = k(t.options.at(0), {
+  create: (e) => {
+    let i = j(e.options.at(0), {
       "newlines-between": "always",
       "custom-groups": { type: {}, value: {} },
       "internal-pattern": ["~/**"],
-      type: i.alphabetical,
-      order: c.asc,
+      type: u.alphabetical,
+      order: g.asc,
       "ignore-case": !1,
       groups: []
     }), s = !1;
-    for (let n of o.groups)
-      if (Array.isArray(n))
-        for (let u of n)
-          u === "unknown" && (s = !0);
+    for (let o of i.groups)
+      if (Array.isArray(o))
+        for (let p of o)
+          p === "unknown" && (s = !0);
       else
-        n === "unknown" && (s = !0);
-    s || (o.groups = [...o.groups, "unknown"]);
-    let l = [], r = (n) => n.type === "ImportDeclaration" && n.specifiers.length === 0, e = (n) => {
-      let u = (x) => [".less", ".scss", ".sass", ".styl", ".pcss", ".css", ".sss"].some(
-        (S) => x.endsWith(S)
-      ), y = (x) => [
+        o === "unknown" && (s = !0);
+    s || (i.groups = [...i.groups, "unknown"]);
+    let l = [], r = (o) => o.type === "ImportDeclaration" && o.specifiers.length === 0, t = (o) => {
+      let p = (E) => [".less", ".scss", ".sass", ".styl", ".pcss", ".css", ".sss"].some(
+        (w) => E.endsWith(w)
+      ), f = (E) => [
         "./index.d.js",
         "./index.d.ts",
         "./index.js",
@@ -1455,12 +1475,12 @@ const Z = "sort-object-types", Ee = v({
         "./index",
         "./",
         "."
-      ].includes(x), m = (x) => x.indexOf("..") === 0, f = (x) => x.indexOf("./") === 0, { getGroup: d, defineGroup: g, setCustomGroups: b } = M(o.groups), N = (x) => o["internal-pattern"].length && o["internal-pattern"].some(
-        (S) => $(x.source.value, S, {
+      ].includes(E), y = (E) => E.indexOf("..") === 0, d = (E) => E.indexOf("./") === 0, { getGroup: c, defineGroup: m, setCustomGroups: x } = G(i.groups), C = (E) => i["internal-pattern"].length && i["internal-pattern"].some(
+        (w) => D(E.source.value, w, {
           nocomment: !0
         })
-      ), h = (x) => {
-        let S = [
+      ), b = (E) => {
+        let w = [
           "bun",
           "bun:ffi",
           "bun:jsc",
@@ -1471,98 +1491,98 @@ const Z = "sort-object-types", Ee = v({
           "undici",
           "ws"
         ];
-        return ce.includes(
-          x.startsWith("node:") ? x.split("node:")[1] : x
-        ) || S.includes(x);
-      }, C = (x) => !(x.startsWith(".") || x.startsWith("/"));
-      return n.importKind === "type" && (n.type === "ImportDeclaration" && (b(o["custom-groups"].type, n.source.value), y(n.source.value) && g("index-type"), f(n.source.value) && g("sibling-type"), m(n.source.value) && g("parent-type"), N(n) && g("internal-type"), h(n.source.value) && g("builtin-type"), C(n.source.value) && g("external-type")), g("type")), n.type === "ImportDeclaration" && (b(o["custom-groups"].value, n.source.value), r(n) && u(n.source.value) && g("side-effect-style"), r(n) && g("side-effect"), u(n.source.value) && g("style"), y(n.source.value) && g("index"), f(n.source.value) && g("sibling"), m(n.source.value) && g("parent"), N(n) && g("internal"), h(n.source.value) && g("builtin"), C(n.source.value) && g("external")), d();
-    }, a = (n) => n.specifiers.length > 1, p = (n) => {
-      let u;
-      n.type === "ImportDeclaration" ? u = n.source.value : n.moduleReference.type === "TSExternalModuleReference" && n.moduleReference.expression.type === "Literal" ? u = `${n.moduleReference.expression.value}` : u = t.sourceCode.text.slice(...n.moduleReference.range), l.push({
-        size: O(n.range),
-        group: e(n),
-        name: u,
-        node: n,
-        ...o.type === i["line-length"] && o["max-line-length"] && {
+        return fe.includes(
+          E.startsWith("node:") ? E.split("node:")[1] : E
+        ) || w.includes(E);
+      }, N = (E) => !(E.startsWith(".") || E.startsWith("/"));
+      return o.importKind === "type" && (o.type === "ImportDeclaration" && (x(i["custom-groups"].type, o.source.value), f(o.source.value) && m("index-type"), d(o.source.value) && m("sibling-type"), y(o.source.value) && m("parent-type"), C(o) && m("internal-type"), b(o.source.value) && m("builtin-type"), N(o.source.value) && m("external-type")), m("type")), o.type === "ImportDeclaration" && (x(i["custom-groups"].value, o.source.value), r(o) && p(o.source.value) && m("side-effect-style"), r(o) && m("side-effect"), p(o.source.value) && m("style"), f(o.source.value) && m("index"), d(o.source.value) && m("sibling"), y(o.source.value) && m("parent"), C(o) && m("internal"), b(o.source.value) && m("builtin"), N(o.source.value) && m("external")), c();
+    }, a = (o) => o.specifiers.length > 1, n = (o) => {
+      let p;
+      o.type === "ImportDeclaration" ? p = o.source.value : o.moduleReference.type === "TSExternalModuleReference" && o.moduleReference.expression.type === "Literal" ? p = `${o.moduleReference.expression.value}` : p = e.sourceCode.text.slice(...o.moduleReference.range), l.push({
+        size: I(o.range),
+        group: t(o),
+        name: p,
+        node: o,
+        ...i.type === u["line-length"] && i["max-line-length"] && {
           hasMultipleImportDeclarations: a(
-            n
+            o
           )
         }
       });
     };
     return {
-      TSImportEqualsDeclaration: p,
-      ImportDeclaration: p,
+      TSImportEqualsDeclaration: n,
+      ImportDeclaration: n,
       "Program:exit": () => {
-        var m;
-        let n = (f, d) => !!t.sourceCode.getTokensBetween(
-          f.node,
-          J(d.node, t.sourceCode) || d.node,
+        var y;
+        let o = (d, c) => !!e.sourceCode.getTokensBetween(
+          d.node,
+          V(c.node, e.sourceCode) || c.node,
           {
             includeComments: !0
           }
-        ).length, u = (f, d) => {
-          let g = [], b = {};
-          for (let h of d) {
-            let C = E(o.groups, h);
-            C in b ? b[C] = w(
-              [...b[C], h],
-              o
-            ) : b[C] = [h];
+        ).length, p = (d, c) => {
+          let m = [], x = {};
+          for (let b of c) {
+            let N = h(i.groups, b);
+            N in x ? x[N] = v(
+              [...x[N], b],
+              i
+            ) : x[N] = [b];
           }
-          let N = Object.keys(b).sort((h, C) => Number(h) - Number(C)).reduce(
-            (h, C) => [
-              ...h,
-              ...b[C]
+          let C = Object.keys(x).sort((b, N) => Number(b) - Number(N)).reduce(
+            (b, N) => [
+              ...b,
+              ...x[N]
             ],
             []
           );
-          for (let h = 0, C = N.length; h < C; h++) {
-            let x = N.at(h);
-            if (g.push(
-              f.replaceTextRange(
-                T(d.at(h).node, t.sourceCode),
-                t.sourceCode.text.slice(
-                  ...T(x.node, t.sourceCode)
+          for (let b = 0, N = C.length; b < N; b++) {
+            let E = C.at(b);
+            if (m.push(
+              d.replaceTextRange(
+                T(c.at(b).node, e.sourceCode),
+                e.sourceCode.text.slice(
+                  ...T(E.node, e.sourceCode)
                 )
               )
-            ), o["newlines-between"] !== "ignore") {
-              let S = N.at(h + 1);
-              if (S) {
-                let G = z(
-                  t.sourceCode,
-                  d.at(h),
-                  d.at(h + 1)
+            ), i["newlines-between"] !== "ignore") {
+              let w = C.at(b + 1);
+              if (w) {
+                let R = z(
+                  e.sourceCode,
+                  c.at(b),
+                  c.at(b + 1)
                 );
-                (o["newlines-between"] === "always" && E(o.groups, x) === E(o.groups, S) && G !== 0 || o["newlines-between"] === "never" && G > 0) && g.push(
-                  f.removeRange([
+                (i["newlines-between"] === "always" && h(i.groups, E) === h(i.groups, w) && R !== 0 || i["newlines-between"] === "never" && R > 0) && m.push(
+                  d.removeRange([
                     T(
-                      d.at(h).node,
-                      t.sourceCode
+                      c.at(b).node,
+                      e.sourceCode
                     ).at(1),
                     T(
-                      d.at(h + 1).node,
-                      t.sourceCode
+                      c.at(b + 1).node,
+                      e.sourceCode
                     ).at(0) - 1
                   ])
-                ), o["newlines-between"] === "always" && E(o.groups, x) !== E(o.groups, S) && G > 1 && g.push(
-                  f.replaceTextRange(
+                ), i["newlines-between"] === "always" && h(i.groups, E) !== h(i.groups, w) && R > 1 && m.push(
+                  d.replaceTextRange(
                     [
                       T(
-                        d.at(h).node,
-                        t.sourceCode
+                        c.at(b).node,
+                        e.sourceCode
                       ).at(1),
                       T(
-                        d.at(h + 1).node,
-                        t.sourceCode
+                        c.at(b + 1).node,
+                        e.sourceCode
                       ).at(0) - 1
                     ],
                     `
 `
                   )
-                ), o["newlines-between"] === "always" && E(o.groups, x) !== E(o.groups, S) && G === 0 && g.push(
-                  f.insertTextAfterRange(
-                    T(d.at(h).node, t.sourceCode),
+                ), i["newlines-between"] === "always" && h(i.groups, E) !== h(i.groups, w) && R === 0 && m.push(
+                  d.insertTextAfterRange(
+                    T(c.at(b).node, e.sourceCode),
                     `
 `
                   )
@@ -1570,58 +1590,58 @@ const Z = "sort-object-types", Ee = v({
               }
             }
           }
-          return g;
-        }, y = [[]];
-        for (let f of l) {
-          let d = (m = y.at(-1)) == null ? void 0 : m.at(-1);
-          d && n(d, f) ? y.push([f]) : y.at(-1).push(f);
+          return m;
+        }, f = [[]];
+        for (let d of l) {
+          let c = (y = f.at(-1)) == null ? void 0 : y.at(-1);
+          c && o(c, d) ? f.push([d]) : f.at(-1).push(d);
         }
-        for (let f of y)
-          P(f, (d, g) => {
-            let b = E(o.groups, d), N = E(o.groups, g), h = z(
-              t.sourceCode,
-              d,
-              g
+        for (let d of f)
+          P(d, (c, m) => {
+            let x = h(i.groups, c), C = h(i.groups, m), b = z(
+              e.sourceCode,
+              c,
+              m
             );
-            !(r(d.node) && r(g.node)) && !n(d, g) && (b > N || b === N && j(A(d, g, o))) && t.report({
+            !(r(c.node) && r(m.node)) && !o(c, m) && (x > C || x === C && O(S(c, m, i))) && e.report({
               messageId: "unexpectedImportsOrder",
               data: {
-                left: d.name,
-                right: g.name
+                left: c.name,
+                right: m.name
               },
-              node: g.node,
-              fix: (C) => u(C, f)
-            }), o["newlines-between"] === "never" && h > 0 && t.report({
+              node: m.node,
+              fix: (N) => p(N, d)
+            }), i["newlines-between"] === "never" && b > 0 && e.report({
               messageId: "extraSpacingBetweenImports",
               data: {
-                left: d.name,
-                right: g.name
+                left: c.name,
+                right: m.name
               },
-              node: g.node,
-              fix: (C) => u(C, f)
-            }), o["newlines-between"] === "always" && (b < N && h === 0 ? t.report({
+              node: m.node,
+              fix: (N) => p(N, d)
+            }), i["newlines-between"] === "always" && (x < C && b === 0 ? e.report({
               messageId: "missedSpacingBetweenImports",
               data: {
-                left: d.name,
-                right: g.name
+                left: c.name,
+                right: m.name
               },
-              node: g.node,
-              fix: (C) => u(C, f)
-            }) : (h > 1 || b === N && h > 0) && t.report({
+              node: m.node,
+              fix: (N) => p(N, d)
+            }) : (b > 1 || x === C && b > 0) && e.report({
               messageId: "extraSpacingBetweenImports",
               data: {
-                left: d.name,
-                right: g.name
+                left: c.name,
+                right: m.name
               },
-              node: g.node,
-              fix: (C) => u(C, f)
+              node: m.node,
+              fix: (N) => p(N, d)
             }));
           });
       }
     };
   }
-}), ae = "sort-objects", Ie = v({
-  name: ae,
+}), ne = "sort-objects", Ae = A({
+  name: ne,
   meta: {
     type: "suggestion",
     docs: {
@@ -1649,16 +1669,16 @@ const Z = "sort-object-types", Ee = v({
           },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -1684,139 +1704,139 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => {
-    let o = (s) => {
-      let l = k(t.options.at(0), {
+  create: (e) => {
+    let i = (s) => {
+      let l = j(e.options.at(0), {
         "partition-by-new-line": !1,
         "partition-by-comment": !1,
-        type: i.alphabetical,
+        type: u.alphabetical,
         "styled-components": !0,
         "ignore-case": !1,
         "ignore-pattern": [],
-        order: c.asc,
+        order: g.asc,
         "custom-groups": {},
         groups: []
       }), r = s.parent.type === "VariableDeclarator" && s.parent.id.type === "Identifier" ? s.parent.id.name : null;
       if (!(l["ignore-pattern"].length && typeof r == "string" ? l["ignore-pattern"].some(
-        (a) => $(r, a, {
+        (a) => D(r, a, {
           nocomment: !0
         })
       ) : !1) && s.properties.length > 1) {
-        let a = (u) => u.type === "Identifier" && u.name === "styled", p = (u) => u !== void 0 && u.type === "CallExpression" && (u.callee.type === "MemberExpression" && a(u.callee.object) || u.callee.type === "CallExpression" && a(u.callee.callee));
-        if (!l["styled-components"] && (p(s.parent) || s.parent.type === "ArrowFunctionExpression" && p(s.parent.parent)))
+        let a = (p) => p.type === "Identifier" && p.name === "styled", n = (p) => p !== void 0 && p.type === "CallExpression" && (p.callee.type === "MemberExpression" && a(p.callee.object) || p.callee.type === "CallExpression" && a(p.callee.callee));
+        if (!l["styled-components"] && (n(s.parent) || s.parent.type === "ArrowFunctionExpression" && n(s.parent.parent)))
           return;
-        let n = (u) => u.reduce(
-          (y, m) => {
-            var G;
-            if (m.type === "SpreadElement" || m.type === "RestElement")
-              return y.push([]), y;
-            let f = J(m, t.sourceCode), d = (G = y.at(-1)) == null ? void 0 : G.at(-1);
-            l["partition-by-comment"] && f && pe(
+        let o = (p) => p.reduce(
+          (f, y) => {
+            var R;
+            if (y.type === "SpreadElement" || y.type === "RestElement")
+              return f.push([]), f;
+            let d = V(y, e.sourceCode), c = (R = f.at(-1)) == null ? void 0 : R.at(-1);
+            l["partition-by-comment"] && d && X(
               l["partition-by-comment"],
-              f.value
-            ) && y.push([]);
-            let g, b = "ignore", N = [], { getGroup: h, setCustomGroups: C } = M(l.groups);
-            m.key.type === "Identifier" ? { name: g } = m.key : m.key.type === "Literal" ? g = `${m.key.value}` : g = t.sourceCode.text.slice(...m.key.range);
-            let x = {
-              size: O(m.range),
-              node: m,
-              name: g
+              d.value
+            ) && f.push([]);
+            let m, x = "ignore", C = [], { getGroup: b, setCustomGroups: N } = G(l.groups);
+            y.key.type === "Identifier" ? { name: m } = y.key : y.key.type === "Literal" ? m = `${y.key.value}` : m = e.sourceCode.text.slice(...y.key.range);
+            let E = {
+              size: I(y.range),
+              node: y,
+              name: m
             };
-            l["partition-by-new-line"] && d && z(t.sourceCode, d, x) && y.push([]), m.value.type === "AssignmentPattern" && ((B) => {
-              B.right.type === "Identifier" && N.push(B.right.name);
-              let ie = (R) => {
-                let D = [];
-                switch (R.type) {
+            l["partition-by-new-line"] && c && z(e.sourceCode, c, E) && f.push([]), y.value.type === "AssignmentPattern" && ((_) => {
+              _.right.type === "Identifier" && C.push(_.right.name);
+              let ue = ($) => {
+                let B = [];
+                switch ($.type) {
                   case "ArrowFunctionExpression":
-                    D.push(R.body);
+                    B.push($.body);
                     break;
                   case "ConditionalExpression":
-                    D.push(R.consequent, R.alternate);
+                    B.push($.consequent, $.alternate);
                     break;
                   case "LogicalExpression":
                   case "BinaryExpression":
-                    D.push(R.left, R.right);
+                    B.push($.left, $.right);
                     break;
                   case "CallExpression":
-                    D.push(...R.arguments);
+                    B.push(...$.arguments);
                     break;
                 }
-                D.forEach((U) => {
-                  U.type === "Identifier" && N.push(U.name), (U.type === "BinaryExpression" || U.type === "ConditionalExpression") && ie(U);
+                B.forEach((U) => {
+                  U.type === "Identifier" && C.push(U.name), (U.type === "BinaryExpression" || U.type === "ConditionalExpression") && ue(U);
                 });
               };
-              switch (B.right.type) {
+              switch (_.right.type) {
                 case "ArrowFunctionExpression":
                 case "ConditionalExpression":
                 case "LogicalExpression":
                 case "BinaryExpression":
                 case "CallExpression":
-                  ie(B.right);
+                  ue(_.right);
                   break;
               }
-            })(m.value), C(l["custom-groups"], g);
-            let S = {
-              ...x,
-              group: h(),
-              dependencies: N,
-              position: b
+            })(y.value), N(l["custom-groups"], m);
+            let w = {
+              ...E,
+              group: b(),
+              dependencies: C,
+              position: x
             };
-            return y.at(-1).push(S), y;
+            return f.at(-1).push(w), f;
           },
           [[]]
         );
-        for (let u of n(s.properties))
-          P(u, (y, m) => {
-            let f = E(l.groups, y), d = E(l.groups, m);
-            if (f > d || f === d && j(A(y, m, l))) {
-              let g = (b) => {
-                let N = {};
-                for (let C of u) {
-                  let x = E(l.groups, C);
-                  x in N ? N[x] = w(
-                    [...N[x], C],
+        for (let p of o(s.properties))
+          P(p, (f, y) => {
+            let d = h(l.groups, f), c = h(l.groups, y);
+            if (d > c || d === c && O(S(f, y, l))) {
+              let m = (x) => {
+                let C = {};
+                for (let N of p) {
+                  let E = h(l.groups, N);
+                  E in C ? C[E] = v(
+                    [...C[E], N],
                     l
-                  ) : N[x] = [C];
+                  ) : C[E] = [N];
                 }
-                let h = [];
-                for (let C of Object.keys(N).sort(
-                  (x, S) => Number(x) - Number(S)
+                let b = [];
+                for (let N of Object.keys(C).sort(
+                  (E, w) => Number(E) - Number(w)
                 ))
-                  h.push(...w(N[C], l));
-                return L(
+                  b.push(...v(C[N], l));
+                return M(
+                  x,
+                  p,
                   b,
-                  u,
-                  h,
-                  t.sourceCode,
+                  e.sourceCode,
                   {
                     partitionComment: l["partition-by-comment"]
                   }
                 );
               };
-              t.report({
+              e.report({
                 messageId: "unexpectedObjectsOrder",
                 data: {
-                  left: I(y.name),
-                  right: I(m.name)
+                  left: k(f.name),
+                  right: k(y.name)
                 },
-                node: m.node,
-                fix: g
+                node: y.node,
+                fix: m
               });
             }
           });
       }
     };
     return {
-      ObjectExpression: o,
-      ObjectPattern: o
+      ObjectExpression: i,
+      ObjectPattern: i
     };
   }
-}), oe = "sort-classes", ve = v({
-  name: oe,
+}), le = "sort-classes", Ie = A({
+  name: le,
   meta: {
     type: "suggestion",
     docs: {
@@ -1829,11 +1849,11 @@ const Z = "sort-object-types", Ee = v({
         properties: {
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           "ignore-case": {
@@ -1841,8 +1861,8 @@ const Z = "sort-object-types", Ee = v({
             default: !1
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           groups: {
@@ -1859,86 +1879,86 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    ClassBody: (o) => {
-      if (o.body.length > 1) {
-        let s = k(t.options.at(0), {
-          type: i.alphabetical,
-          order: c.asc,
+  create: (e) => ({
+    ClassBody: (i) => {
+      if (i.body.length > 1) {
+        let s = j(e.options.at(0), {
+          type: u.alphabetical,
+          order: g.asc,
           "ignore-case": !1,
           groups: ["property", "constructor", "method", "unknown"]
-        }), l = o.body.map((r) => {
-          var u;
-          let e, { getGroup: a, defineGroup: p } = M(s.groups);
-          r.type === "StaticBlock" ? e = "static" : r.type === "TSIndexSignature" ? e = t.sourceCode.text.slice(
+        }), l = i.body.map((r) => {
+          var f;
+          let t, { getGroup: a, defineGroup: n } = G(s.groups);
+          r.type === "StaticBlock" ? t = "static" : r.type === "TSIndexSignature" ? t = e.sourceCode.text.slice(
             r.range.at(0),
-            ((u = r.typeAnnotation) == null ? void 0 : u.range.at(0)) ?? r.range.at(1)
-          ) : r.key.type === "Identifier" ? { name: e } = r.key : e = t.sourceCode.text.slice(...r.key.range);
-          let n = e.startsWith("_") || e.startsWith("#");
+            ((f = r.typeAnnotation) == null ? void 0 : f.range.at(0)) ?? r.range.at(1)
+          ) : r.key.type === "Identifier" ? { name: t } = r.key : t = e.sourceCode.text.slice(...r.key.range);
+          let o = t.startsWith("_") || t.startsWith("#"), p = "decorators" in r && r.decorators.length > 0;
           if (r.type === "MethodDefinition") {
-            r.kind === "constructor" && p("constructor");
-            let y = r.accessibility === "private" || n, m = r.static;
-            y && m && p("static-private-method"), y && p("private-method"), m && p("static-method"), r.kind === "get" && p("get-method"), r.kind === "set" && p("set-method"), p("method");
+            r.kind === "constructor" && n("constructor");
+            let y = r.accessibility === "private" || o, d = r.static;
+            p && (r.kind === "get" && n("decorated-get-method"), r.kind === "set" && n("decorated-set-method"), n("decorated-method")), y && d && n("static-private-method"), y && n("private-method"), d && n("static-method"), r.kind === "get" && n("get-method"), r.kind === "set" && n("set-method"), n("method");
           } else
-            r.type === "TSIndexSignature" ? p("index-signature") : r.type === "PropertyDefinition" && ((r.accessibility === "private" || n) && p("private-property"), r.static && p("static-property"), p("property"));
+            r.type === "TSIndexSignature" ? n("index-signature") : r.type === "AccessorProperty" ? p && ((r.accessibility === "private" || o) && n("private-decorated-accessor-property"), n("decorated-accessor-property")) : r.type === "PropertyDefinition" && (p && ((r.accessibility === "private" || o) && n("private-decorated-property"), n("decorated-property")), (r.accessibility === "private" || o) && n("private-property"), r.static && n("static-property"), n("property"));
           return {
-            size: O(r.range),
+            size: I(r.range),
             group: a(),
             node: r,
-            name: e
+            name: t
           };
         });
-        P(l, (r, e) => {
-          let a = E(s.groups, r), p = E(s.groups, e);
-          r.name !== e.name && (a > p || a === p && j(A(r, e, s))) && t.report({
+        P(l, (r, t) => {
+          let a = h(s.groups, r), n = h(s.groups, t);
+          r.name !== t.name && (a > n || a === n && O(S(r, t, s))) && e.report({
             messageId: "unexpectedClassesOrder",
             data: {
-              left: I(r.name),
-              right: I(e.name)
+              left: k(r.name),
+              right: k(t.name)
             },
-            node: e.node,
-            fix: (n) => {
-              let u = [], y = l.reduce(
-                (f, d) => {
-                  let g = E(s.groups, d);
-                  return g in f ? f[g] = w(
-                    [...f[g], d],
+            node: t.node,
+            fix: (o) => {
+              let p = [], f = l.reduce(
+                (d, c) => {
+                  let m = h(s.groups, c);
+                  return m in d ? d[m] = v(
+                    [...d[m], c],
                     s
-                  ) : f[g] = [d], f;
+                  ) : d[m] = [c], d;
                 },
                 {}
-              ), m = Object.keys(y).sort((f, d) => Number(f) - Number(d)).reduce(
-                (f, d) => [
-                  ...f,
-                  ...y[d]
+              ), y = Object.keys(f).sort((d, c) => Number(d) - Number(c)).reduce(
+                (d, c) => [
+                  ...d,
+                  ...f[c]
                 ],
                 []
               );
-              for (let f = 0, d = m.length; f < d; f++)
-                u.push(
-                  n.replaceTextRange(
-                    T(l.at(f).node, t.sourceCode),
-                    t.sourceCode.text.slice(
+              for (let d = 0, c = y.length; d < c; d++)
+                p.push(
+                  o.replaceTextRange(
+                    T(l.at(d).node, e.sourceCode),
+                    e.sourceCode.text.slice(
                       ...T(
-                        m.at(f).node,
-                        t.sourceCode
+                        y.at(d).node,
+                        e.sourceCode
                       )
                     )
                   )
                 );
-              return u;
+              return p;
             }
           });
         });
       }
     }
   })
-}), ne = "sort-enums", Oe = v({
-  name: ne,
+}), ie = "sort-enums", Oe = A({
+  name: ie,
   meta: {
     type: "suggestion",
     docs: {
@@ -1949,13 +1969,17 @@ const Z = "sort-object-types", Ee = v({
       {
         type: "object",
         properties: {
+          "partition-by-comment": {
+            default: !1,
+            type: ["boolean", "string", "array"]
+          },
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           "ignore-case": {
@@ -1963,8 +1987,8 @@ const Z = "sort-object-types", Ee = v({
             default: !1
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           }
         },
@@ -1977,43 +2001,54 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    TSEnumDeclaration: (o) => {
-      if (o.members.length > 1 && o.members.every(({ initializer: s }) => s)) {
-        let s = k(t.options.at(0), {
-          type: i.alphabetical,
-          order: c.asc,
-          "ignore-case": !1
-        }), l = o.members.map((r) => ({
-          name: r.id.type === "Literal" ? `${r.id.value}` : `${t.sourceCode.text.slice(...r.id.range)}`,
-          size: O(r.range),
-          node: r
-        }));
-        P(l, (r, e) => {
-          j(A(r, e, s)) && t.report({
-            messageId: "unexpectedEnumsOrder",
-            data: {
-              left: I(r.name),
-              right: I(e.name)
-            },
-            node: e.node,
-            fix: (a) => L(
-              a,
-              l,
-              w(l, s),
-              t.sourceCode
-            )
+  create: (e) => ({
+    TSEnumDeclaration: (i) => {
+      if (i.members.length > 1 && i.members.every(({ initializer: s }) => s)) {
+        let s = j(e.options.at(0), {
+          type: u.alphabetical,
+          order: g.asc,
+          "ignore-case": !1,
+          "partition-by-comment": !1
+        }), l = s["partition-by-comment"], r = i.members.reduce(
+          (t, a) => {
+            let n = V(a, e.sourceCode);
+            l && n && X(l, n.value) && t.push([]);
+            let p = {
+              name: a.id.type === "Literal" ? `${a.id.value}` : `${e.sourceCode.text.slice(...a.id.range)}`,
+              node: a,
+              size: I(a.range)
+            };
+            return t.at(-1).push(p), t;
+          },
+          [[]]
+        );
+        for (let t of r)
+          P(t, (a, n) => {
+            O(S(a, n, s)) && e.report({
+              messageId: "unexpectedEnumsOrder",
+              data: {
+                left: k(a.name),
+                right: k(n.name)
+              },
+              node: n.node,
+              fix: (o) => M(
+                o,
+                t,
+                v(t, s),
+                e.sourceCode,
+                { partitionComment: l }
+              )
+            });
           });
-        });
       }
     }
   })
-}), le = "sort-maps", je = v({
-  name: le,
+}), pe = "sort-maps", je = A({
+  name: pe,
   meta: {
     type: "suggestion",
     docs: {
@@ -2026,16 +2061,16 @@ const Z = "sort-object-types", Ee = v({
         properties: {
           type: {
             enum: [
-              i.alphabetical,
-              i.natural,
-              i["line-length"]
+              u.alphabetical,
+              u.natural,
+              u["line-length"]
             ],
-            default: i.alphabetical,
+            default: u.alphabetical,
             type: "string"
           },
           order: {
-            enum: [c.asc, c.desc],
-            default: c.asc,
+            enum: [g.asc, g.desc],
+            default: g.asc,
             type: "string"
           },
           "ignore-case": {
@@ -2052,50 +2087,50 @@ const Z = "sort-object-types", Ee = v({
   },
   defaultOptions: [
     {
-      type: i.alphabetical,
-      order: c.asc
+      type: u.alphabetical,
+      order: g.asc
     }
   ],
-  create: (t) => ({
-    NewExpression: (o) => {
-      if (o.callee.type === "Identifier" && o.callee.name === "Map" && o.arguments.length && o.arguments[0].type === "ArrayExpression") {
-        let [{ elements: s }] = o.arguments;
+  create: (e) => ({
+    NewExpression: (i) => {
+      if (i.callee.type === "Identifier" && i.callee.name === "Map" && i.arguments.length && i.arguments[0].type === "ArrayExpression") {
+        let [{ elements: s }] = i.arguments;
         if (s.length > 1) {
-          let l = k(t.options.at(0), {
-            type: i.alphabetical,
+          let l = j(e.options.at(0), {
+            type: u.alphabetical,
             "ignore-case": !1,
-            order: c.asc
+            order: g.asc
           }), r = s.reduce(
-            (e, a) => (a === null || a.type === "SpreadElement" ? e.push([]) : e.at(-1).push(a), e),
+            (t, a) => (a === null || a.type === "SpreadElement" ? t.push([]) : t.at(-1).push(a), t),
             [[]]
           );
-          for (let e of r) {
-            let a = e.map((p) => {
-              let n;
-              if (p.type === "ArrayExpression") {
-                let [u] = p.elements;
-                u ? u.type === "Literal" ? n = u.raw : n = t.sourceCode.text.slice(...u.range) : n = `${u}`;
+          for (let t of r) {
+            let a = t.map((n) => {
+              let o;
+              if (n.type === "ArrayExpression") {
+                let [p] = n.elements;
+                p ? p.type === "Literal" ? o = p.raw : o = e.sourceCode.text.slice(...p.range) : o = `${p}`;
               } else
-                n = t.sourceCode.text.slice(...p.range);
+                o = e.sourceCode.text.slice(...n.range);
               return {
-                size: O(p.range),
-                node: p,
-                name: n
+                size: I(n.range),
+                node: n,
+                name: o
               };
             });
-            P(a, (p, n) => {
-              j(A(p, n, l)) && t.report({
+            P(a, (n, o) => {
+              O(S(n, o, l)) && e.report({
                 messageId: "unexpectedMapElementsOrder",
                 data: {
-                  left: I(p.name),
-                  right: I(n.name)
+                  left: k(n.name),
+                  right: k(o.name)
                 },
-                node: n.node,
-                fix: (u) => L(
-                  u,
+                node: o.node,
+                fix: (p) => M(
+                  p,
                   a,
-                  w(a, l),
-                  t.sourceCode
+                  v(a, l),
+                  e.sourceCode
                 )
               });
             });
@@ -2104,10 +2139,10 @@ const Z = "sort-object-types", Ee = v({
       }
     }
   })
-}), ke = "eslint-plugin-perfectionist";
-let V = (t) => {
-  let o = {
-    [se]: [
+}), Pe = "eslint-plugin-perfectionist";
+let J = (e) => {
+  let i = {
+    [oe]: [
       "error",
       {
         groups: [
@@ -2128,7 +2163,7 @@ let V = (t) => {
         "internal-pattern": ["~/**"]
       }
     ],
-    [oe]: [
+    [le]: [
       "error",
       {
         groups: [
@@ -2145,78 +2180,78 @@ let V = (t) => {
         ]
       }
     ],
-    [ae]: [
+    [ne]: [
       "error",
       {
         "partition-by-comment": !1
       }
     ],
-    [K]: [
+    [Q]: [
       "error",
       {
         "spread-last": !0
       }
     ],
-    [X]: ["error"],
     [q]: ["error"],
     [H]: ["error"],
-    [Q]: ["error"],
     [Y]: ["error"],
     [Z]: ["error"],
     [F]: ["error"],
     [ee]: ["error"],
     [te]: ["error"],
     [re]: ["error"],
-    [ne]: ["error"],
-    [le]: ["error"]
+    [se]: ["error"],
+    [ae]: ["error"],
+    [ie]: ["error"],
+    [pe]: ["error"]
   };
   return {
     rules: Object.fromEntries(
-      Object.entries(o).map(([s, [l, r = {}]]) => [
+      Object.entries(i).map(([s, [l, r = {}]]) => [
         `perfectionist/${s}`,
-        [l, Object.assign(r, t)]
+        [l, Object.assign(r, e)]
       ])
     ),
     plugins: ["perfectionist"]
   };
 };
-const $e = {
+const De = {
   rules: {
-    [K]: me,
-    [q]: ye,
-    [oe]: ve,
-    [ne]: Oe,
-    [re]: Se,
-    [se]: Ae,
+    [Q]: he,
+    [H]: me,
+    [le]: Ie,
+    [ie]: Oe,
+    [ae]: Se,
+    [oe]: ke,
+    [re]: ve,
+    [se]: we,
+    [pe]: je,
+    [Z]: xe,
+    [F]: Ee,
     [ee]: Ne,
-    [te]: we,
-    [le]: je,
-    [Q]: be,
-    [Y]: xe,
-    [Z]: Ee,
-    [ae]: Ie,
-    [X]: ge,
-    [F]: Ce,
-    [H]: he
+    [ne]: Ae,
+    [q]: ye,
+    [te]: Ce,
+    [Y]: be
   },
   configs: {
-    "recommended-alphabetical": V({
-      type: i.alphabetical,
-      order: c.asc,
+    "recommended-alphabetical": J({
+      type: u.alphabetical,
+      order: g.asc,
       "ignore-case": !1
     }),
-    "recommended-natural": V({
-      type: i.natural,
-      order: c.asc,
+    "recommended-natural": J({
+      type: u.natural,
+      order: g.asc,
       "ignore-case": !1
     }),
-    "recommended-line-length": V({
-      type: i["line-length"],
-      order: c.desc
+    "recommended-line-length": J({
+      type: u["line-length"],
+      order: g.desc
     })
   },
-  name: ke
+  name: Pe
 };
 export {
-  $e as default
+  De as default
 };