eslint-plugin-perfectionist 2.7.0 → 2.9.0

package/dist/index.mjs

@@ -1,2148 +1,25 @@
-import W from "node:path";
-import { ESLintUtils as de, ASTUtils as K } from "@typescript-eslint/utils";
-import { minimatch as D } from "minimatch";
-import ce from "natural-compare-lite";
-import { builtinModules as fe } from "node:module";
-let A = de.RuleCreator(
-  (e) => `https://eslint-plugin-perfectionist.azat.io/rules/${e}`
-), h = (e, i) => {
-  for (let s = 0, l = e.length; s < l; s++) {
-    let r = e[s];
-    if (i.group === r || Array.isArray(r) && typeof i.group == "string" && r.includes(i.group))
-      return s;
-  }
-  return e.length;
-}, I = (e) => {
-  let [i, s] = e;
-  return s - i;
-}, O = (e) => e > 0;
-var u = /* @__PURE__ */ ((e) => (e.alphabetical = "alphabetical", e["line-length"] = "line-length", e.natural = "natural", e))(u || {}), g = /* @__PURE__ */ ((e) => (e.desc = "desc", e.asc = "asc", e))(g || {}), L = /* @__PURE__ */ ((e) => (e["values-first"] = "values-first", e["types-first"] = "types-first", e.mixed = "mixed", e))(L || {});
-let G = (e) => {
-  let i, s = (r) => {
-    !i && e.flat().includes(r) && (i = r);
-  };
-  return {
-    getGroup: () => i ?? "unknown",
-    setCustomGroups: (r, t) => {
-      if (r)
-        for (let [a, n] of Object.entries(r))
-          Array.isArray(n) && n.some(
-            (o) => D(t, o, {
-              nocomment: !0
-            })
-          ) && s(a), typeof n == "string" && D(t, n, {
-            nocomment: !0
-          }) && s(a);
-    },
-    defineGroup: s
-  };
-}, S = (e, i, s) => {
-  var a, n;
-  if ((a = i.dependencies) != null && a.includes(e.name))
-    return -1;
-  if ((n = e.dependencies) != null && n.includes(i.name))
-    return 1;
-  let l = s.order === "asc" ? 1 : -1, r, t = (o) => s["ignore-case"] ? o.toLowerCase() : o;
-  return s.type === u.alphabetical ? r = (o, p) => t(o.name).localeCompare(t(p.name)) : s.type === u.natural ? r = (o, p) => ce(t(o.name), t(p.name)) : r = (o, p) => {
-    let f = o.size, y = p.size, d = s["max-line-length"];
-    if (d) {
-      let c = (m, x) => m > d && x.hasMultipleImportDeclarations;
-      c(f, o) && (f = o.name.length + 10), c(y, p) && (y = p.name.length + 10);
-    }
-    return f - y;
-  }, l * r(e, i);
-}, v = (e, i) => [...e].sort((s, l) => S(s, l, i)), ge = (e, i) => {
-  let s = i.getTokenAfter(e, {
-    filter: ({ value: l, type: r }) => !(r === "Punctuator" && [",", ";"].includes(l)),
-    includeComments: !0
-  });
-  return ((s == null ? void 0 : s.type) === "Block" || (s == null ? void 0 : s.type) === "Line") && e.loc.end.line === s.loc.end.line ? s : null;
-}, X = (e, i) => Array.isArray(e) && e.some(
-  (s) => D(i.trim(), s, {
-    nocomment: !0
-  })
-) || typeof e == "string" && D(i.trim(), e, {
-  nocomment: !0
-}) || e === !0, V = (e, i) => {
-  let [s, l] = i.getTokensBefore(e, {
-    filter: ({ value: r, type: t }) => !(t === "Punctuator" && [",", ";"].includes(r)),
-    includeComments: !0,
-    count: 2
-  });
-  return ((l == null ? void 0 : l.type) === "Block" || (l == null ? void 0 : l.type) === "Line") && e.loc.start.line - l.loc.end.line <= 1 && (s == null ? void 0 : s.loc.end.line) !== l.loc.start.line ? l : null;
-}, T = (e, i, s) => {
-  var n;
-  let l = e.range.at(0), r = e.range.at(1), t = i.text.slice(l, r);
-  if (K.isParenthesized(e, i)) {
-    let o = i.getTokenBefore(
-      e,
-      K.isOpeningParenToken
-    ), p = i.getTokenAfter(
-      e,
-      K.isClosingParenToken
-    );
-    l = o.range.at(0), r = p.range.at(1);
-  }
-  let a = V(e, i);
-  if (t.endsWith(";") || t.endsWith(",")) {
-    let o = i.getTokensAfter(e, {
-      includeComments: !0,
-      count: 2
-    });
-    e.loc.start.line === ((n = o.at(1)) == null ? void 0 : n.loc.start.line) && (r -= 1);
-  }
-  return a && !X(
-    (s == null ? void 0 : s.partitionComment) ?? !1,
-    a.value
-  ) && (l = a.range.at(0)), [l, r];
-}, M = (e, i, s, l, r) => {
-  var n, o;
-  let t = [], a = ((n = i.at(0)) == null ? void 0 : n.node.loc.start.line) === ((o = i.at(-1)) == null ? void 0 : o.node.loc.end.line);
-  for (let p = 0, f = i.length; p < f; p++) {
-    let { node: y } = i.at(p);
-    t.push(
-      e.replaceTextRange(
-        T(y, l, r),
-        l.text.slice(
-          ...T(s.at(p).node, l, r)
-        )
-      )
-    );
-    let d = ge(s.at(p).node, l);
-    if (d && !a) {
-      let m = [
-        l.getTokenBefore(d).range.at(1),
-        d.range.at(1)
-      ];
-      t.push(e.replaceTextRange(m, ""));
-      let x = l.getTokenAfter(y);
-      t.push(
-        e.insertTextAfter(
-          (x == null ? void 0 : x.loc.end.line) === y.loc.end.line ? x : y,
-          l.text.slice(...m)
-        )
-      );
-    }
-  }
-  return t;
-}, j = (e = {}, i) => Object.assign(i, e), P = (e, i) => {
-  if (e.length > 1)
-    for (let s = 1; s < e.length; s++) {
-      let l = e.at(s - 1), r = e.at(s);
-      l && r && i(l, r, s - 1);
-    }
-};
-const q = "sort-svelte-attributes", ye = A({
-  name: q,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted Svelte attributes"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object"
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          groups: {
-            type: "array"
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedSvelteAttributesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => W.extname(e.filename) !== ".svelte" ? {} : {
-    SvelteStartTag: (i) => {
-      if (i.attributes.length > 1) {
-        let s = j(e.options.at(0), {
-          type: u.alphabetical,
-          order: g.asc,
-          "ignore-case": !1,
-          "custom-groups": {},
-          groups: []
-        }), l = i.attributes.reduce(
-          (r, t) => {
-            if (t.type === "SvelteSpreadAttribute")
-              return r.push([]), r;
-            let a, { getGroup: n, defineGroup: o, setCustomGroups: p } = G(
-              s.groups
-            );
-            return t.key.type === "SvelteSpecialDirectiveKey" ? a = e.sourceCode.text.slice(...t.key.range) : typeof t.key.name == "string" ? { name: a } = t.key : a = e.sourceCode.text.slice(...t.key.range), p(s["custom-groups"], a), t.type === "SvelteShorthandAttribute" && (o("svelte-shorthand"), o("shorthand")), (!("value" in t) || Array.isArray(t.value) && !t.value.at(0)) && o("shorthand"), t.loc.start.line !== t.loc.end.line && o("multiline"), r.at(-1).push({
-              size: I(t.range),
-              node: t,
-              group: n(),
-              name: a
-            }), r;
-          },
-          [[]]
-        );
-        for (let r of l)
-          P(r, (t, a) => {
-            let n = h(s.groups, t), o = h(s.groups, a);
-            (n > o || n === o && O(S(t, a, s))) && e.report({
-              messageId: "unexpectedSvelteAttributesOrder",
-              data: {
-                left: t.name,
-                right: a.name
-              },
-              node: a.node,
-              fix: (p) => {
-                let f = {};
-                for (let d of r) {
-                  let c = h(s.groups, d);
-                  c in f ? f[c] = v(
-                    [...f[c], d],
-                    s
-                  ) : f[c] = [d];
-                }
-                let y = [];
-                for (let d of Object.keys(f).sort(
-                  (c, m) => Number(c) - Number(m)
-                ))
-                  y.push(...v(f[d], s));
-                return M(
-                  p,
-                  r,
-                  y,
-                  e.sourceCode
-                );
-              }
-            });
-          });
-      }
-    }
-  }
-}), H = "sort-astro-attributes", me = A({
-  name: H,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted Astro attributes"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object"
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          groups: {
-            type: "array"
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedAstroAttributesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  // @ts-ignore
-  create: (e) => W.extname(e.filename) !== ".astro" ? {} : {
-    JSXElement: (i) => {
-      let { attributes: s } = i.openingElement;
-      if (s.length > 1) {
-        let l = j(e.options.at(0), {
-          type: u.alphabetical,
-          order: g.asc,
-          "ignore-case": !1,
-          "custom-groups": {},
-          groups: []
-        }), r = s.reduce(
-          (t, a) => {
-            if (a.type === "JSXSpreadAttribute")
-              return t.push([]), t;
-            let n = typeof a.name.name == "string" ? a.name.name : e.sourceCode.text.slice(...a.name.range), { getGroup: o, defineGroup: p, setCustomGroups: f } = G(
-              l.groups
-            );
-            return f(l["custom-groups"], n), a.type === "AstroShorthandAttribute" && (p("astro-shorthand"), p("shorthand")), a.value === null && p("shorthand"), a.loc.start.line !== a.loc.end.line && p("multiline"), t.at(-1).push({
-              size: I(a.range),
-              node: a,
-              group: o(),
-              name: n
-            }), t;
-          },
-          [[]]
-        );
-        for (let t of r)
-          P(t, (a, n) => {
-            let o = h(l.groups, a), p = h(l.groups, n);
-            (o > p || o === p && O(S(a, n, l))) && e.report({
-              messageId: "unexpectedAstroAttributesOrder",
-              data: {
-                left: a.name,
-                right: n.name
-              },
-              node: n.node,
-              fix: (f) => {
-                let y = {};
-                for (let c of t) {
-                  let m = h(l.groups, c);
-                  m in y ? y[m] = v(
-                    [...y[m], c],
-                    l
-                  ) : y[m] = [c];
-                }
-                let d = [];
-                for (let c of Object.keys(y).sort(
-                  (m, x) => Number(m) - Number(x)
-                ))
-                  d.push(...v(y[c], l));
-                return M(
-                  f,
-                  t,
-                  d,
-                  e.sourceCode
-                );
-              }
-            });
-          });
-      }
-    }
-  }
-});
-let k = (e) => e.replaceAll(/\s\s+/g, " ").trim();
-const Q = "sort-array-includes", he = A({
-  name: Q,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted arrays before include method"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          "spread-last": {
-            type: "boolean",
-            default: !1
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedArrayIncludesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    MemberExpression: (i) => {
-      if ((i.object.type === "ArrayExpression" || i.object.type === "NewExpression") && i.property.type === "Identifier" && i.property.name === "includes") {
-        let s = i.object.type === "ArrayExpression" ? i.object.elements : i.object.arguments;
-        if (s.length > 1) {
-          let l = j(e.options.at(0), {
-            type: u.alphabetical,
-            order: g.asc,
-            "ignore-case": !1,
-            "spread-last": !1
-          }), r = s.reduce(
-            (t, a) => (a !== null && t.at(0).push({
-              name: a.type === "Literal" ? `${a.value}` : e.sourceCode.text.slice(...a.range),
-              size: I(a.range),
-              type: a.type,
-              node: a
-            }), t),
-            [[], []]
-          ).flat();
-          P(r, (t, a) => {
-            let n;
-            l["spread-last"] && t.node.type === "Literal" && a.node.type === "SpreadElement" ? n = !1 : l["spread-last"] && t.node.type === "SpreadElement" && a.node.type === "Literal" ? n = !0 : n = O(S(t, a, l)), n && e.report({
-              messageId: "unexpectedArrayIncludesOrder",
-              data: {
-                left: k(t.name),
-                right: k(a.name)
-              },
-              node: a.node,
-              fix: (o) => {
-                let p = v(r, l);
-                if (l["spread-last"])
-                  for (let f = 0, y = p.length; f < y; f++)
-                    p.at(f).node.type === "SpreadElement" && p.push(p.splice(f, 1).at(0));
-                return M(
-                  o,
-                  r,
-                  p,
-                  e.sourceCode
-                );
-              }
-            });
-          });
-        }
-      }
-    }
-  })
-}), Y = "sort-vue-attributes", be = A({
-  name: Y,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted Vue attributes"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object"
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          groups: {
-            type: "array",
-            default: []
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedVueAttributesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => {
-    if (W.extname(e.filename) !== ".vue")
-      return {};
-    if (!("defineTemplateBodyVisitor" in e.sourceCode.parserServices))
-      return {};
-    let { defineTemplateBodyVisitor: i } = e.sourceCode.parserServices;
-    return i({
-      VStartTag: (s) => {
-        if (s.attributes.length > 1) {
-          let l = j(e.options.at(0), {
-            type: u.alphabetical,
-            order: g.asc,
-            "ignore-case": !1,
-            "custom-groups": {},
-            groups: []
-          }), r = s.attributes.reduce(
-            (t, a) => {
-              if (a.key.type === "VDirectiveKey" && a.key.name.rawName === "bind")
-                return t.push([]), t;
-              let n, { getGroup: o, defineGroup: p, setCustomGroups: f } = G(
-                l.groups
-              );
-              return typeof a.key.name == "string" && a.key.type !== "VDirectiveKey" ? n = a.key.rawName : n = e.sourceCode.text.slice(...a.key.range), f(l["custom-groups"], n), a.value === null && p("shorthand"), a.loc.start.line !== a.loc.end.line && p("multiline"), t.at(-1).push({
-                size: I(a.range),
-                node: a,
-                group: o(),
-                name: n
-              }), t;
-            },
-            [[]]
-          );
-          for (let t of r)
-            P(t, (a, n) => {
-              let o = h(l.groups, a), p = h(l.groups, n);
-              (o > p || o === p && O(S(a, n, l))) && e.report({
-                messageId: "unexpectedVueAttributesOrder",
-                data: {
-                  left: a.name,
-                  right: n.name
-                },
-                node: n.node,
-                fix: (f) => {
-                  let y = {};
-                  for (let c of t) {
-                    let m = h(l.groups, c);
-                    m in y ? y[m] = v(
-                      [...y[m], c],
-                      l
-                    ) : y[m] = [c];
-                  }
-                  let d = [];
-                  for (let c of Object.keys(y).sort(
-                    (m, x) => Number(m) - Number(x)
-                  ))
-                    d.push(...v(y[c], l));
-                  return M(
-                    f,
-                    t,
-                    d,
-                    e.sourceCode
-                  );
-                }
-              });
-            });
-        }
-      }
-    });
-  }
-}), Z = "sort-named-exports", xe = A({
-  name: Z,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted named exports"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          "group-kind": {
-            enum: [
-              L.mixed,
-              L["values-first"],
-              L["types-first"]
-            ],
-            default: L.mixed,
-            type: "string"
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedNamedExportsOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    ExportNamedDeclaration: (i) => {
-      if (i.specifiers.length > 1) {
-        let s = j(e.options.at(0), {
-          type: u.alphabetical,
-          "ignore-case": !1,
-          order: g.asc,
-          "group-kind": L.mixed
-        }), l = i.specifiers.map((a) => ({
-          size: I(a.range),
-          name: a.local.name,
-          node: a,
-          group: a.exportKind
-        })), r = s["group-kind"] !== L.mixed, t = s["group-kind"] === L["values-first"] ? ["value", "type"] : ["type", "value"];
-        P(l, (a, n) => {
-          let o = h(t, a), p = h(t, n);
-          if (r && o > p || (!r || o === p) && O(S(a, n, s))) {
-            let f = r ? t.map((y) => l.filter((d) => d.group === y)).map((y) => v(y, s)).flat() : v(l, s);
-            e.report({
-              messageId: "unexpectedNamedExportsOrder",
-              data: {
-                left: a.name,
-                right: n.name
-              },
-              node: n.node,
-              fix: (y) => M(y, l, f, e.sourceCode)
-            });
-          }
-        });
-      }
-    }
-  })
-}), F = "sort-named-imports", Ee = A({
-  name: F,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted named imports"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          "ignore-alias": {
-            type: "boolean",
-            default: !1
-          },
-          "group-kind": {
-            enum: [
-              L.mixed,
-              L["values-first"],
-              L["types-first"]
-            ],
-            default: L.mixed,
-            type: "string"
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedNamedImportsOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    ImportDeclaration: (i) => {
-      let s = i.specifiers.filter(
-        ({ type: l }) => l === "ImportSpecifier"
-      );
-      if (s.length > 1) {
-        let l = j(e.options.at(0), {
-          type: u.alphabetical,
-          "ignore-alias": !0,
-          "ignore-case": !1,
-          order: g.asc,
-          "group-kind": L.mixed
-        }), r = s.map((n) => {
-          let o, { name: p } = n.local;
-          return n.type === "ImportSpecifier" && (l["ignore-alias"] && ({ name: p } = n.imported), o = n.importKind), {
-            size: I(n.range),
-            node: n,
-            name: p,
-            group: o
-          };
-        }), t = l["group-kind"] !== L.mixed, a = l["group-kind"] === L["values-first"] ? ["value", "type"] : ["type", "value"];
-        P(r, (n, o) => {
-          let p = h(a, n), f = h(a, o);
-          if (t && p > f || (!t || p === f) && O(S(n, o, l))) {
-            let y = t ? a.map((d) => r.filter((c) => c.group === d)).map((d) => v(d, l)).flat() : v(r, l);
-            e.report({
-              messageId: "unexpectedNamedImportsOrder",
-              data: {
-                left: n.name,
-                right: o.name
-              },
-              node: o.node,
-              fix: (d) => M(d, r, y, e.sourceCode)
-            });
-          }
-        });
-      }
-    }
-  })
-});
-let z = (e, i, s) => e.lines.slice(
-  i.node.loc.end.line,
-  s.node.loc.start.line - 1
-).filter((r) => !r.trim().length).length;
-const ee = "sort-object-types", Ne = A({
-  name: ee,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted object types"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object"
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          groups: {
-            type: "array",
-            default: []
-          },
-          "partition-by-new-line": {
-            type: "boolean",
-            default: !1
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedObjectTypesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    TSTypeLiteral: (i) => {
-      if (i.members.length > 1) {
-        let s = j(e.options.at(0), {
-          "partition-by-new-line": !1,
-          type: u.alphabetical,
-          "ignore-case": !1,
-          order: g.asc,
-          "custom-groups": {},
-          groups: []
-        }), l = i.members.reduce(
-          (r, t) => {
-            var C, b, N, E;
-            let a, n = e.sourceCode.text.slice(
-              t.range.at(0),
-              t.range.at(1)
-            ), o = (C = r.at(-1)) == null ? void 0 : C.at(-1), { getGroup: p, defineGroup: f, setCustomGroups: y } = G(
-              s.groups
-            ), d = (w) => w.replace(/(,|;)$/, "");
-            if (t.type === "TSPropertySignature")
-              t.key.type === "Identifier" ? { name: a } = t.key : t.key.type === "Literal" ? a = `${t.key.value}` : a = e.sourceCode.text.slice(
-                t.range.at(0),
-                (b = t.typeAnnotation) == null ? void 0 : b.range.at(0)
-              );
-            else if (t.type === "TSIndexSignature") {
-              let w = ((N = t.typeAnnotation) == null ? void 0 : N.range.at(0)) ?? t.range.at(1);
-              a = d(
-                e.sourceCode.text.slice(t.range.at(0), w)
-              );
-            } else
-              a = d(
-                e.sourceCode.text.slice(
-                  t.range.at(0),
-                  t.range.at(1)
-                )
-              );
-            y(s["custom-groups"], a), t.loc.start.line !== t.loc.end.line && f("multiline");
-            let m = n.endsWith(";") || n.endsWith(",") ? 1 : 0, x = {
-              size: I(t.range) - m,
-              node: t,
-              name: a
-            };
-            return s["partition-by-new-line"] && o && z(e.sourceCode, o, x) && r.push([]), (E = r.at(-1)) == null || E.push({
-              ...x,
-              group: p()
-            }), r;
-          },
-          [[]]
-        );
-        for (let r of l)
-          P(r, (t, a) => {
-            let n = h(s.groups, t), o = h(s.groups, a);
-            (n > o || n === o && O(S(t, a, s))) && e.report({
-              messageId: "unexpectedObjectTypesOrder",
-              data: {
-                left: k(t.name),
-                right: k(a.name)
-              },
-              node: a.node,
-              fix: (p) => {
-                let f = {};
-                for (let d of r) {
-                  let c = h(s.groups, d);
-                  c in f ? f[c] = v(
-                    [...f[c], d],
-                    s
-                  ) : f[c] = [d];
-                }
-                let y = [];
-                for (let d of Object.keys(f).sort(
-                  (c, m) => Number(c) - Number(m)
-                ))
-                  y.push(...v(f[d], s));
-                return M(
-                  p,
-                  r,
-                  y,
-                  e.sourceCode
-                );
-              }
-            });
-          });
-      }
-    }
-  })
-}), te = "sort-union-types", Ce = A({
-  name: te,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted union types"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          "nullable-last": {
-            type: "boolean",
-            default: !1
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedUnionTypesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    TSUnionType: (i) => {
-      let s = j(e.options.at(0), {
-        type: u.alphabetical,
-        "nullable-last": !1,
-        "ignore-case": !1,
-        order: g.asc
-      }), l = i.types.map((r) => ({
-        group: r.type === "TSNullKeyword" || r.type === "TSUndefinedKeyword" ? "nullable" : "unknown",
-        name: e.sourceCode.text.slice(...r.range),
-        size: I(r.range),
-        node: r
-      }));
-      P(l, (r, t) => {
-        let a = O(S(r, t, s));
-        s["nullable-last"] && (r.group === "nullable" && t.group === "unknown" ? a = !0 : r.group === "unknown" && t.group === "nullable" && (a = !1)), a && e.report({
-          messageId: "unexpectedUnionTypesOrder",
-          data: {
-            left: k(r.name),
-            right: k(t.name)
-          },
-          node: t.node,
-          fix: (n) => {
-            let o = [];
-            if (s["nullable-last"]) {
-              let p = [], f = l.filter((y) => y.group === "nullable" ? (p.push(y), !1) : !0);
-              o = [
-                ...v(f, s),
-                ...v(p, s)
-              ];
-            } else
-              o = v(l, s);
-            return M(n, l, o, e.sourceCode);
-          }
-        });
-      });
-    }
-  })
-}), re = "sort-interfaces", ve = A({
-  name: re,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted interface properties"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object"
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          "ignore-pattern": {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          },
-          groups: {
-            type: "array",
-            default: []
-          },
-          "partition-by-new-line": {
-            type: "boolean",
-            default: !1
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedInterfacePropertiesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    TSInterfaceDeclaration: (i) => {
-      if (i.body.body.length > 1) {
-        let s = j(e.options.at(0), {
-          "partition-by-new-line": !1,
-          type: u.alphabetical,
-          "ignore-case": !1,
-          order: g.asc,
-          "ignore-pattern": [],
-          "custom-groups": {},
-          groups: []
-        });
-        if (!s["ignore-pattern"].some(
-          (l) => D(i.id.name, l, {
-            nocomment: !0
-          })
-        )) {
-          let l = i.body.body.reduce(
-            (r, t) => {
-              var d, c, m, x;
-              if (t.type === "TSCallSignatureDeclaration")
-                return r.push([]), r;
-              let a = (d = r.at(-1)) == null ? void 0 : d.at(-1), n, { getGroup: o, defineGroup: p, setCustomGroups: f } = G(
-                s.groups
-              );
-              if (t.type === "TSPropertySignature")
-                if (t.key.type === "Identifier")
-                  ({ name: n } = t.key);
-                else if (t.key.type === "Literal")
-                  n = `${t.key.value}`;
-                else {
-                  let C = ((c = t.typeAnnotation) == null ? void 0 : c.range.at(0)) ?? t.range.at(1) - (t.optional ? 1 : 0);
-                  n = e.sourceCode.text.slice(t.range.at(0), C);
-                }
-              else if (t.type === "TSIndexSignature") {
-                let C = ((m = t.typeAnnotation) == null ? void 0 : m.range.at(0)) ?? t.range.at(1);
-                n = e.sourceCode.text.slice(
-                  t.range.at(0),
-                  C
-                );
-              } else {
-                let C = ((x = t.returnType) == null ? void 0 : x.range.at(0)) ?? t.range.at(1);
-                n = e.sourceCode.text.slice(
-                  t.range.at(0),
-                  C
-                );
-              }
-              let y = {
-                size: I(t.range),
-                node: t,
-                name: n
-              };
-              return s["partition-by-new-line"] && a && z(
-                e.sourceCode,
-                a,
-                y
-              ) && r.push([]), f(s["custom-groups"], n), t.loc.start.line !== t.loc.end.line && p("multiline"), r.at(-1).push({
-                ...y,
-                group: o()
-              }), r;
-            },
-            [[]]
-          );
-          for (let r of l)
-            P(r, (t, a) => {
-              let n = h(s.groups, t), o = h(s.groups, a);
-              (n > o || n === o && O(S(t, a, s))) && e.report({
-                messageId: "unexpectedInterfacePropertiesOrder",
-                data: {
-                  left: k(t.name),
-                  right: k(a.name)
-                },
-                node: a.node,
-                fix: (p) => {
-                  let f = {};
-                  for (let d of r) {
-                    let c = h(s.groups, d);
-                    c in f ? f[c] = v(
-                      [...f[c], d],
-                      s
-                    ) : f[c] = [d];
-                  }
-                  let y = [];
-                  for (let d of Object.keys(f).sort(
-                    (c, m) => Number(c) - Number(m)
-                  ))
-                    y.push(...v(f[d], s));
-                  return M(
-                    p,
-                    r,
-                    y,
-                    e.sourceCode
-                  );
-                }
-              });
-            });
-        }
-      }
-    }
-  })
-}), se = "sort-jsx-props", we = A({
-  name: se,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted JSX props"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object"
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          groups: {
-            type: "array"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedJSXPropsOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => [".svelte", ".astro", ".vue"].includes(W.extname(e.filename)) ? {} : {
-    JSXElement: (i) => {
-      if (i.openingElement.attributes.length > 1) {
-        let s = j(e.options.at(0), {
-          type: u.alphabetical,
-          "ignore-case": !1,
-          order: g.asc,
-          "custom-groups": {},
-          groups: []
-        }), l = i.openingElement.attributes.reduce(
-          (r, t) => {
-            if (t.type === "JSXSpreadAttribute")
-              return r.push([]), r;
-            let a = t.name.type === "JSXNamespacedName" ? `${t.name.namespace.name}:${t.name.name.name}` : t.name.name, { getGroup: n, defineGroup: o, setCustomGroups: p } = G(
-              s.groups
-            );
-            p(s["custom-groups"], a), t.value === null && o("shorthand"), t.loc.start.line !== t.loc.end.line && o("multiline");
-            let f = {
-              size: I(t.range),
-              group: n(),
-              node: t,
-              name: a
-            };
-            return r.at(-1).push(f), r;
-          },
-          [[]]
-        );
-        for (let r of l)
-          P(r, (t, a) => {
-            let n = h(s.groups, t), o = h(s.groups, a);
-            (n > o || n === o && O(S(t, a, s))) && e.report({
-              messageId: "unexpectedJSXPropsOrder",
-              data: {
-                left: t.name,
-                right: a.name
-              },
-              node: a.node,
-              fix: (p) => {
-                let f = {};
-                for (let d of r) {
-                  let c = h(s.groups, d);
-                  c in f ? f[c] = v(
-                    [...f[c], d],
-                    s
-                  ) : f[c] = [d];
-                }
-                let y = [];
-                for (let d of Object.keys(f).sort(
-                  (c, m) => Number(c) - Number(m)
-                ))
-                  y.push(...v(f[d], s));
-                return M(
-                  p,
-                  r,
-                  y,
-                  e.sourceCode
-                );
-              }
-            });
-          });
-      }
-    }
-  }
-}), ae = "sort-exports", Se = A({
-  name: ae,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted exports"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedExportsOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => {
-    let i = j(e.options.at(0), {
-      type: u.alphabetical,
-      order: g.asc,
-      "ignore-case": !1
-    }), s = [[]], l = (r) => {
-      r.type === "ExportAllDeclaration" && r.exported === null ? s.push([]) : s.at(-1).push({
-        size: I(r.range),
-        name: r.source.value,
-        node: r
-      });
-    };
-    return {
-      ExportAllDeclaration: l,
-      ExportNamedDeclaration: (r) => {
-        r.source !== null && l(r);
-      },
-      "Program:exit": () => {
-        for (let r of s)
-          P(r, (t, a) => {
-            O(S(t, a, i)) && e.report({
-              messageId: "unexpectedExportsOrder",
-              data: {
-                left: t.name,
-                right: a.name
-              },
-              node: a.node,
-              fix: (n) => M(
-                n,
-                r,
-                v(r, i),
-                e.sourceCode
-              )
-            });
-          });
-      }
-    };
-  }
-}), oe = "sort-imports", ke = A({
-  name: oe,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted imports"
-    },
-    fixable: "code",
-    schema: [
-      {
-        id: "sort-imports",
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object",
-            properties: {
-              type: {
-                type: "object"
-              },
-              value: {
-                type: "object"
-              }
-            },
-            additionalProperties: !1
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          groups: {
-            type: "array",
-            default: []
-          },
-          "internal-pattern": {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          },
-          "newlines-between": {
-            enum: [
-              "ignore",
-              "always",
-              "never"
-              /* never */
-            ],
-            default: "always",
-            type: "string"
-          },
-          "max-line-length": {
-            type: "integer",
-            minimum: 0,
-            exclusiveMinimum: !0
-          }
-        },
-        allOf: [
-          { $ref: "#/definitions/max-line-length-requires-line-length-type" }
-        ],
-        additionalProperties: !1,
-        dependencies: {
-          "max-line-length": ["type"]
-        },
-        definitions: {
-          "is-line-length": {
-            properties: {
-              type: { enum: [u["line-length"]], type: "string" }
-            },
-            required: ["type"],
-            type: "object"
-          },
-          "max-line-length-requires-line-length-type": {
-            anyOf: [
-              {
-                not: { required: ["max-line-length"], type: "object" },
-                type: "object"
-              },
-              { $ref: "#/definitions/is-line-length" }
-            ]
-          }
-        }
-      }
-    ],
-    messages: {
-      unexpectedImportsOrder: 'Expected "{{right}}" to come before "{{left}}"',
-      missedSpacingBetweenImports: 'Missed spacing between "{{left}}" and "{{right}}" imports',
-      extraSpacingBetweenImports: 'Extra spacing between "{{left}}" and "{{right}}" imports'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => {
-    let i = j(e.options.at(0), {
-      "newlines-between": "always",
-      "custom-groups": { type: {}, value: {} },
-      "internal-pattern": ["~/**"],
-      type: u.alphabetical,
-      order: g.asc,
-      "ignore-case": !1,
-      groups: []
-    }), s = !1;
-    for (let o of i.groups)
-      if (Array.isArray(o))
-        for (let p of o)
-          p === "unknown" && (s = !0);
-      else
-        o === "unknown" && (s = !0);
-    s || (i.groups = [...i.groups, "unknown"]);
-    let l = [], r = (o) => o.type === "ImportDeclaration" && o.specifiers.length === 0, t = (o) => {
-      let p = (E) => [".less", ".scss", ".sass", ".styl", ".pcss", ".css", ".sss"].some(
-        (w) => E.endsWith(w)
-      ), f = (E) => [
-        "./index.d.js",
-        "./index.d.ts",
-        "./index.js",
-        "./index.ts",
-        "./index",
-        "./",
-        "."
-      ].includes(E), y = (E) => E.indexOf("..") === 0, d = (E) => E.indexOf("./") === 0, { getGroup: c, defineGroup: m, setCustomGroups: x } = G(i.groups), C = (E) => i["internal-pattern"].length && i["internal-pattern"].some(
-        (w) => D(E.source.value, w, {
-          nocomment: !0
-        })
-      ), b = (E) => {
-        let w = [
-          "bun",
-          "bun:ffi",
-          "bun:jsc",
-          "bun:sqlite",
-          "bun:test",
-          "bun:wrap",
-          "detect-libc",
-          "undici",
-          "ws"
-        ];
-        return fe.includes(
-          E.startsWith("node:") ? E.split("node:")[1] : E
-        ) || w.includes(E);
-      }, N = (E) => !(E.startsWith(".") || E.startsWith("/"));
-      return o.importKind === "type" && (o.type === "ImportDeclaration" && (x(i["custom-groups"].type, o.source.value), f(o.source.value) && m("index-type"), d(o.source.value) && m("sibling-type"), y(o.source.value) && m("parent-type"), C(o) && m("internal-type"), b(o.source.value) && m("builtin-type"), N(o.source.value) && m("external-type")), m("type")), o.type === "ImportDeclaration" && (x(i["custom-groups"].value, o.source.value), r(o) && p(o.source.value) && m("side-effect-style"), r(o) && m("side-effect"), p(o.source.value) && m("style"), f(o.source.value) && m("index"), d(o.source.value) && m("sibling"), y(o.source.value) && m("parent"), C(o) && m("internal"), b(o.source.value) && m("builtin"), N(o.source.value) && m("external")), c();
-    }, a = (o) => o.specifiers.length > 1, n = (o) => {
-      let p;
-      o.type === "ImportDeclaration" ? p = o.source.value : o.moduleReference.type === "TSExternalModuleReference" && o.moduleReference.expression.type === "Literal" ? p = `${o.moduleReference.expression.value}` : p = e.sourceCode.text.slice(...o.moduleReference.range), l.push({
-        size: I(o.range),
-        group: t(o),
-        name: p,
-        node: o,
-        ...i.type === u["line-length"] && i["max-line-length"] && {
-          hasMultipleImportDeclarations: a(
-            o
-          )
-        }
-      });
-    };
-    return {
-      TSImportEqualsDeclaration: n,
-      ImportDeclaration: n,
-      "Program:exit": () => {
-        var y;
-        let o = (d, c) => !!e.sourceCode.getTokensBetween(
-          d.node,
-          V(c.node, e.sourceCode) || c.node,
-          {
-            includeComments: !0
-          }
-        ).length, p = (d, c) => {
-          let m = [], x = {};
-          for (let b of c) {
-            let N = h(i.groups, b);
-            N in x ? x[N] = v(
-              [...x[N], b],
-              i
-            ) : x[N] = [b];
-          }
-          let C = Object.keys(x).sort((b, N) => Number(b) - Number(N)).reduce(
-            (b, N) => [
-              ...b,
-              ...x[N]
-            ],
-            []
-          );
-          for (let b = 0, N = C.length; b < N; b++) {
-            let E = C.at(b);
-            if (m.push(
-              d.replaceTextRange(
-                T(c.at(b).node, e.sourceCode),
-                e.sourceCode.text.slice(
-                  ...T(E.node, e.sourceCode)
-                )
-              )
-            ), i["newlines-between"] !== "ignore") {
-              let w = C.at(b + 1);
-              if (w) {
-                let R = z(
-                  e.sourceCode,
-                  c.at(b),
-                  c.at(b + 1)
-                );
-                (i["newlines-between"] === "always" && h(i.groups, E) === h(i.groups, w) && R !== 0 || i["newlines-between"] === "never" && R > 0) && m.push(
-                  d.removeRange([
-                    T(
-                      c.at(b).node,
-                      e.sourceCode
-                    ).at(1),
-                    T(
-                      c.at(b + 1).node,
-                      e.sourceCode
-                    ).at(0) - 1
-                  ])
-                ), i["newlines-between"] === "always" && h(i.groups, E) !== h(i.groups, w) && R > 1 && m.push(
-                  d.replaceTextRange(
-                    [
-                      T(
-                        c.at(b).node,
-                        e.sourceCode
-                      ).at(1),
-                      T(
-                        c.at(b + 1).node,
-                        e.sourceCode
-                      ).at(0) - 1
-                    ],
-                    `
-`
-                  )
-                ), i["newlines-between"] === "always" && h(i.groups, E) !== h(i.groups, w) && R === 0 && m.push(
-                  d.insertTextAfterRange(
-                    T(c.at(b).node, e.sourceCode),
-                    `
-`
-                  )
-                );
-              }
-            }
-          }
-          return m;
-        }, f = [[]];
-        for (let d of l) {
-          let c = (y = f.at(-1)) == null ? void 0 : y.at(-1);
-          c && o(c, d) ? f.push([d]) : f.at(-1).push(d);
-        }
-        for (let d of f)
-          P(d, (c, m) => {
-            let x = h(i.groups, c), C = h(i.groups, m), b = z(
-              e.sourceCode,
-              c,
-              m
-            );
-            !(r(c.node) && r(m.node)) && !o(c, m) && (x > C || x === C && O(S(c, m, i))) && e.report({
-              messageId: "unexpectedImportsOrder",
-              data: {
-                left: c.name,
-                right: m.name
-              },
-              node: m.node,
-              fix: (N) => p(N, d)
-            }), i["newlines-between"] === "never" && b > 0 && e.report({
-              messageId: "extraSpacingBetweenImports",
-              data: {
-                left: c.name,
-                right: m.name
-              },
-              node: m.node,
-              fix: (N) => p(N, d)
-            }), i["newlines-between"] === "always" && (x < C && b === 0 ? e.report({
-              messageId: "missedSpacingBetweenImports",
-              data: {
-                left: c.name,
-                right: m.name
-              },
-              node: m.node,
-              fix: (N) => p(N, d)
-            }) : (b > 1 || x === C && b > 0) && e.report({
-              messageId: "extraSpacingBetweenImports",
-              data: {
-                left: c.name,
-                right: m.name
-              },
-              node: m.node,
-              fix: (N) => p(N, d)
-            }));
-          });
-      }
-    };
-  }
-}), ne = "sort-objects", Ae = A({
-  name: ne,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted objects"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "custom-groups": {
-            type: "object"
-          },
-          "partition-by-comment": {
-            type: ["boolean", "string", "array"],
-            default: !1
-          },
-          "partition-by-new-line": {
-            type: "boolean",
-            default: !1
-          },
-          "styled-components": {
-            type: "boolean",
-            default: !0
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          "ignore-pattern": {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          },
-          groups: {
-            type: "array"
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedObjectsOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => {
-    let i = (s) => {
-      let l = j(e.options.at(0), {
-        "partition-by-new-line": !1,
-        "partition-by-comment": !1,
-        type: u.alphabetical,
-        "styled-components": !0,
-        "ignore-case": !1,
-        "ignore-pattern": [],
-        order: g.asc,
-        "custom-groups": {},
-        groups: []
-      }), r = s.parent.type === "VariableDeclarator" && s.parent.id.type === "Identifier" ? s.parent.id.name : null;
-      if (!(l["ignore-pattern"].length && typeof r == "string" ? l["ignore-pattern"].some(
-        (a) => D(r, a, {
-          nocomment: !0
-        })
-      ) : !1) && s.properties.length > 1) {
-        let a = (p) => p.type === "Identifier" && p.name === "styled", n = (p) => p !== void 0 && p.type === "CallExpression" && (p.callee.type === "MemberExpression" && a(p.callee.object) || p.callee.type === "CallExpression" && a(p.callee.callee));
-        if (!l["styled-components"] && (n(s.parent) || s.parent.type === "ArrowFunctionExpression" && n(s.parent.parent)))
-          return;
-        let o = (p) => p.reduce(
-          (f, y) => {
-            var R;
-            if (y.type === "SpreadElement" || y.type === "RestElement")
-              return f.push([]), f;
-            let d = V(y, e.sourceCode), c = (R = f.at(-1)) == null ? void 0 : R.at(-1);
-            l["partition-by-comment"] && d && X(
-              l["partition-by-comment"],
-              d.value
-            ) && f.push([]);
-            let m, x = "ignore", C = [], { getGroup: b, setCustomGroups: N } = G(l.groups);
-            y.key.type === "Identifier" ? { name: m } = y.key : y.key.type === "Literal" ? m = `${y.key.value}` : m = e.sourceCode.text.slice(...y.key.range);
-            let E = {
-              size: I(y.range),
-              node: y,
-              name: m
-            };
-            l["partition-by-new-line"] && c && z(e.sourceCode, c, E) && f.push([]), y.value.type === "AssignmentPattern" && ((_) => {
-              _.right.type === "Identifier" && C.push(_.right.name);
-              let ue = ($) => {
-                let B = [];
-                switch ($.type) {
-                  case "ArrowFunctionExpression":
-                    B.push($.body);
-                    break;
-                  case "ConditionalExpression":
-                    B.push($.consequent, $.alternate);
-                    break;
-                  case "LogicalExpression":
-                  case "BinaryExpression":
-                    B.push($.left, $.right);
-                    break;
-                  case "CallExpression":
-                    B.push(...$.arguments);
-                    break;
-                }
-                B.forEach((U) => {
-                  U.type === "Identifier" && C.push(U.name), (U.type === "BinaryExpression" || U.type === "ConditionalExpression") && ue(U);
-                });
-              };
-              switch (_.right.type) {
-                case "ArrowFunctionExpression":
-                case "ConditionalExpression":
-                case "LogicalExpression":
-                case "BinaryExpression":
-                case "CallExpression":
-                  ue(_.right);
-                  break;
-              }
-            })(y.value), N(l["custom-groups"], m);
-            let w = {
-              ...E,
-              group: b(),
-              dependencies: C,
-              position: x
-            };
-            return f.at(-1).push(w), f;
-          },
-          [[]]
-        );
-        for (let p of o(s.properties))
-          P(p, (f, y) => {
-            let d = h(l.groups, f), c = h(l.groups, y);
-            if (d > c || d === c && O(S(f, y, l))) {
-              let m = (x) => {
-                let C = {};
-                for (let N of p) {
-                  let E = h(l.groups, N);
-                  E in C ? C[E] = v(
-                    [...C[E], N],
-                    l
-                  ) : C[E] = [N];
-                }
-                let b = [];
-                for (let N of Object.keys(C).sort(
-                  (E, w) => Number(E) - Number(w)
-                ))
-                  b.push(...v(C[N], l));
-                return M(
-                  x,
-                  p,
-                  b,
-                  e.sourceCode,
-                  {
-                    partitionComment: l["partition-by-comment"]
-                  }
-                );
-              };
-              e.report({
-                messageId: "unexpectedObjectsOrder",
-                data: {
-                  left: k(f.name),
-                  right: k(y.name)
-                },
-                node: y.node,
-                fix: m
-              });
-            }
-          });
-      }
-    };
-    return {
-      ObjectExpression: i,
-      ObjectPattern: i
-    };
-  }
-}), le = "sort-classes", Ie = A({
-  name: le,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted classes"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          groups: {
-            type: "array",
-            default: []
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedClassesOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    ClassBody: (i) => {
-      if (i.body.length > 1) {
-        let s = j(e.options.at(0), {
-          type: u.alphabetical,
-          order: g.asc,
-          "ignore-case": !1,
-          groups: ["property", "constructor", "method", "unknown"]
-        }), l = i.body.map((r) => {
-          var f;
-          let t, { getGroup: a, defineGroup: n } = G(s.groups);
-          r.type === "StaticBlock" ? t = "static" : r.type === "TSIndexSignature" ? t = e.sourceCode.text.slice(
-            r.range.at(0),
-            ((f = r.typeAnnotation) == null ? void 0 : f.range.at(0)) ?? r.range.at(1)
-          ) : r.key.type === "Identifier" ? { name: t } = r.key : t = e.sourceCode.text.slice(...r.key.range);
-          let o = t.startsWith("_") || t.startsWith("#"), p = "decorators" in r && r.decorators.length > 0;
-          if (r.type === "MethodDefinition") {
-            r.kind === "constructor" && n("constructor");
-            let y = r.accessibility === "private" || o, d = r.static;
-            p && (r.kind === "get" && n("decorated-get-method"), r.kind === "set" && n("decorated-set-method"), n("decorated-method")), y && d && n("static-private-method"), y && n("private-method"), d && n("static-method"), r.kind === "get" && n("get-method"), r.kind === "set" && n("set-method"), n("method");
-          } else
-            r.type === "TSIndexSignature" ? n("index-signature") : r.type === "AccessorProperty" ? p && ((r.accessibility === "private" || o) && n("private-decorated-accessor-property"), n("decorated-accessor-property")) : r.type === "PropertyDefinition" && (p && ((r.accessibility === "private" || o) && n("private-decorated-property"), n("decorated-property")), (r.accessibility === "private" || o) && n("private-property"), r.static && n("static-property"), n("property"));
-          return {
-            size: I(r.range),
-            group: a(),
-            node: r,
-            name: t
-          };
-        });
-        P(l, (r, t) => {
-          let a = h(s.groups, r), n = h(s.groups, t);
-          r.name !== t.name && (a > n || a === n && O(S(r, t, s))) && e.report({
-            messageId: "unexpectedClassesOrder",
-            data: {
-              left: k(r.name),
-              right: k(t.name)
-            },
-            node: t.node,
-            fix: (o) => {
-              let p = [], f = l.reduce(
-                (d, c) => {
-                  let m = h(s.groups, c);
-                  return m in d ? d[m] = v(
-                    [...d[m], c],
-                    s
-                  ) : d[m] = [c], d;
-                },
-                {}
-              ), y = Object.keys(f).sort((d, c) => Number(d) - Number(c)).reduce(
-                (d, c) => [
-                  ...d,
-                  ...f[c]
-                ],
-                []
-              );
-              for (let d = 0, c = y.length; d < c; d++)
-                p.push(
-                  o.replaceTextRange(
-                    T(l.at(d).node, e.sourceCode),
-                    e.sourceCode.text.slice(
-                      ...T(
-                        y.at(d).node,
-                        e.sourceCode
-                      )
-                    )
-                  )
-                );
-              return p;
-            }
-          });
-        });
-      }
-    }
-  })
-}), ie = "sort-enums", Oe = A({
-  name: ie,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted TypeScript enums"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          "partition-by-comment": {
-            default: !1,
-            type: ["boolean", "string", "array"]
-          },
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedEnumsOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    TSEnumDeclaration: (i) => {
-      if (i.members.length > 1 && i.members.every(({ initializer: s }) => s)) {
-        let s = j(e.options.at(0), {
-          type: u.alphabetical,
-          order: g.asc,
-          "ignore-case": !1,
-          "partition-by-comment": !1
-        }), l = s["partition-by-comment"], r = i.members.reduce(
-          (t, a) => {
-            let n = V(a, e.sourceCode);
-            l && n && X(l, n.value) && t.push([]);
-            let p = {
-              name: a.id.type === "Literal" ? `${a.id.value}` : `${e.sourceCode.text.slice(...a.id.range)}`,
-              node: a,
-              size: I(a.range)
-            };
-            return t.at(-1).push(p), t;
-          },
-          [[]]
-        );
-        for (let t of r)
-          P(t, (a, n) => {
-            O(S(a, n, s)) && e.report({
-              messageId: "unexpectedEnumsOrder",
-              data: {
-                left: k(a.name),
-                right: k(n.name)
-              },
-              node: n.node,
-              fix: (o) => M(
-                o,
-                t,
-                v(t, s),
-                e.sourceCode,
-                { partitionComment: l }
-              )
-            });
-          });
-      }
-    }
-  })
-}), pe = "sort-maps", je = A({
-  name: pe,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted Map elements"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          type: {
-            enum: [
-              u.alphabetical,
-              u.natural,
-              u["line-length"]
-            ],
-            default: u.alphabetical,
-            type: "string"
-          },
-          order: {
-            enum: [g.asc, g.desc],
-            default: g.asc,
-            type: "string"
-          },
-          "ignore-case": {
-            type: "boolean",
-            default: !1
-          }
-        },
-        additionalProperties: !1
-      }
-    ],
-    messages: {
-      unexpectedMapElementsOrder: 'Expected "{{right}}" to come before "{{left}}"'
-    }
-  },
-  defaultOptions: [
-    {
-      type: u.alphabetical,
-      order: g.asc
-    }
-  ],
-  create: (e) => ({
-    NewExpression: (i) => {
-      if (i.callee.type === "Identifier" && i.callee.name === "Map" && i.arguments.length && i.arguments[0].type === "ArrayExpression") {
-        let [{ elements: s }] = i.arguments;
-        if (s.length > 1) {
-          let l = j(e.options.at(0), {
-            type: u.alphabetical,
-            "ignore-case": !1,
-            order: g.asc
-          }), r = s.reduce(
-            (t, a) => (a === null || a.type === "SpreadElement" ? t.push([]) : t.at(-1).push(a), t),
-            [[]]
-          );
-          for (let t of r) {
-            let a = t.map((n) => {
-              let o;
-              if (n.type === "ArrayExpression") {
-                let [p] = n.elements;
-                p ? p.type === "Literal" ? o = p.raw : o = e.sourceCode.text.slice(...p.range) : o = `${p}`;
-              } else
-                o = e.sourceCode.text.slice(...n.range);
-              return {
-                size: I(n.range),
-                node: n,
-                name: o
-              };
-            });
-            P(a, (n, o) => {
-              O(S(n, o, l)) && e.report({
-                messageId: "unexpectedMapElementsOrder",
-                data: {
-                  left: k(n.name),
-                  right: k(o.name)
-                },
-                node: o.node,
-                fix: (p) => M(
-                  p,
-                  a,
-                  v(a, l),
-                  e.sourceCode
-                )
-              });
-            });
-          }
-        }
-      }
-    }
-  })
-}), Pe = "eslint-plugin-perfectionist";
-let J = (e) => {
-  let i = {
-    [oe]: [
+import sortIntersectionTypes, { RULE_NAME as RULE_NAME$e } from "./rules/sort-intersection-types.mjs";
+import sortSvelteAttributes, { RULE_NAME as RULE_NAME$d } from "./rules/sort-svelte-attributes.mjs";
+import sortAstroAttributes, { RULE_NAME as RULE_NAME$1 } from "./rules/sort-astro-attributes.mjs";
+import sortArrayIncludes, { RULE_NAME } from "./rules/sort-array-includes.mjs";
+import sortVueAttributes, { RULE_NAME as RULE_NAME$g } from "./rules/sort-vue-attributes.mjs";
+import sortNamedExports, { RULE_NAME as RULE_NAME$9 } from "./rules/sort-named-exports.mjs";
+import sortNamedImports, { RULE_NAME as RULE_NAME$a } from "./rules/sort-named-imports.mjs";
+import sortObjectTypes, { RULE_NAME as RULE_NAME$b } from "./rules/sort-object-types.mjs";
+import sortUnionTypes, { RULE_NAME as RULE_NAME$f } from "./rules/sort-union-types.mjs";
+import sortInterfaces, { RULE_NAME as RULE_NAME$6 } from "./rules/sort-interfaces.mjs";
+import sortJsxProps, { RULE_NAME as RULE_NAME$7 } from "./rules/sort-jsx-props.mjs";
+import sortExports, { RULE_NAME as RULE_NAME$4 } from "./rules/sort-exports.mjs";
+import sortImports, { RULE_NAME as RULE_NAME$5 } from "./rules/sort-imports.mjs";
+import sortObjects, { RULE_NAME as RULE_NAME$c } from "./rules/sort-objects.mjs";
+import sortClasses, { RULE_NAME as RULE_NAME$2 } from "./rules/sort-classes.mjs";
+import sortEnums, { RULE_NAME as RULE_NAME$3 } from "./rules/sort-enums.mjs";
+import sortMaps, { RULE_NAME as RULE_NAME$8 } from "./rules/sort-maps.mjs";
+import { SortType, SortOrder } from "./typings/index.mjs";
+import { name } from "./package.json.mjs";
+let createConfigWithOptions = (options) => {
+  let recommendedRules = {
+    [RULE_NAME$5]: [
       "error",
       {
         groups: [
@@ -2163,7 +40,7 @@ let J = (e) => {
         "internal-pattern": ["~/**"]
       }
     ],
-    [le]: [
+    [RULE_NAME$2]: [
       "error",
       {
         groups: [
@@ -2180,78 +57,80 @@ let J = (e) => {
         ]
       }
     ],
-    [ne]: [
+    [RULE_NAME$c]: [
       "error",
       {
-        "partition-by-comment": !1
+        "partition-by-comment": false
       }
     ],
-    [Q]: [
+    [RULE_NAME]: [
       "error",
       {
-        "spread-last": !0
-      }
-    ],
-    [q]: ["error"],
-    [H]: ["error"],
-    [Y]: ["error"],
-    [Z]: ["error"],
-    [F]: ["error"],
-    [ee]: ["error"],
-    [te]: ["error"],
-    [re]: ["error"],
-    [se]: ["error"],
-    [ae]: ["error"],
-    [ie]: ["error"],
-    [pe]: ["error"]
+        "spread-last": true
+      }
+    ],
+    [RULE_NAME$e]: ["error"],
+    [RULE_NAME$d]: ["error"],
+    [RULE_NAME$1]: ["error"],
+    [RULE_NAME$g]: ["error"],
+    [RULE_NAME$9]: ["error"],
+    [RULE_NAME$a]: ["error"],
+    [RULE_NAME$b]: ["error"],
+    [RULE_NAME$f]: ["error"],
+    [RULE_NAME$6]: ["error"],
+    [RULE_NAME$7]: ["error"],
+    [RULE_NAME$4]: ["error"],
+    [RULE_NAME$3]: ["error"],
+    [RULE_NAME$8]: ["error"]
   };
   return {
     rules: Object.fromEntries(
-      Object.entries(i).map(([s, [l, r = {}]]) => [
-        `perfectionist/${s}`,
-        [l, Object.assign(r, e)]
+      Object.entries(recommendedRules).map(([key, [message, baseOptions = {}]]) => [
+        `perfectionist/${key}`,
+        [message, Object.assign(baseOptions, options)]
       ])
     ),
     plugins: ["perfectionist"]
   };
 };
-const De = {
+const mod = {
   rules: {
-    [Q]: he,
-    [H]: me,
-    [le]: Ie,
-    [ie]: Oe,
-    [ae]: Se,
-    [oe]: ke,
-    [re]: ve,
-    [se]: we,
-    [pe]: je,
-    [Z]: xe,
-    [F]: Ee,
-    [ee]: Ne,
-    [ne]: Ae,
-    [q]: ye,
-    [te]: Ce,
-    [Y]: be
+    [RULE_NAME]: sortArrayIncludes,
+    [RULE_NAME$1]: sortAstroAttributes,
+    [RULE_NAME$2]: sortClasses,
+    [RULE_NAME$3]: sortEnums,
+    [RULE_NAME$4]: sortExports,
+    [RULE_NAME$5]: sortImports,
+    [RULE_NAME$6]: sortInterfaces,
+    [RULE_NAME$7]: sortJsxProps,
+    [RULE_NAME$8]: sortMaps,
+    [RULE_NAME$9]: sortNamedExports,
+    [RULE_NAME$a]: sortNamedImports,
+    [RULE_NAME$b]: sortObjectTypes,
+    [RULE_NAME$c]: sortObjects,
+    [RULE_NAME$d]: sortSvelteAttributes,
+    [RULE_NAME$e]: sortIntersectionTypes,
+    [RULE_NAME$f]: sortUnionTypes,
+    [RULE_NAME$g]: sortVueAttributes
   },
   configs: {
-    "recommended-alphabetical": J({
-      type: u.alphabetical,
-      order: g.asc,
-      "ignore-case": !1
+    "recommended-alphabetical": createConfigWithOptions({
+      type: SortType.alphabetical,
+      order: SortOrder.asc,
+      "ignore-case": false
     }),
-    "recommended-natural": J({
-      type: u.natural,
-      order: g.asc,
-      "ignore-case": !1
+    "recommended-natural": createConfigWithOptions({
+      type: SortType.natural,
+      order: SortOrder.asc,
+      "ignore-case": false
     }),
-    "recommended-line-length": J({
-      type: u["line-length"],
-      order: g.desc
+    "recommended-line-length": createConfigWithOptions({
+      type: SortType["line-length"],
+      order: SortOrder.desc
     })
   },
-  name: Pe
+  name
 };
 export {
-  De as default
+  mod as default
 };