eslint-plugin-perfectionist 2.6.0 → 2.8.0

package/dist/index.mjs

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