@vinicunca/eslint-config 2.0.11 → 2.0.13

package/dist/index.js

@@ -1,57 +1,3 @@
-// src/base.ts
-import { isPackageExists } from "local-pkg";
-import process3 from "process";
-
-// src/flags.ts
-var ERROR = "error";
-var OFF = "off";
-var WARN = "warn";
-var CONSISTENT = "consistent";
-var NEVER = "never";
-var ALWAYS = "always";
-
-// src/plugins.ts
-import { default as default2 } from "@stylistic/eslint-plugin";
-import { default as default3 } from "@typescript-eslint/eslint-plugin";
-import * as parserTs from "@typescript-eslint/parser";
-import { default as default4 } from "@vinicunca/eslint-plugin-vinicunca";
-import { default as default5 } from "eslint-plugin-eslint-comments";
-import * as pluginImport from "eslint-plugin-i";
-import { default as default6 } from "eslint-plugin-jsdoc";
-import * as pluginJsonc from "eslint-plugin-jsonc";
-import { default as default7 } from "eslint-plugin-markdown";
-import { default as default8 } from "eslint-plugin-n";
-import { default as default9 } from "eslint-plugin-no-only-tests";
-import { default as default10 } from "eslint-plugin-perfectionist";
-import { default as default11 } from "eslint-plugin-react";
-import { default as default12 } from "eslint-plugin-react-hooks";
-import { default as default13 } from "eslint-plugin-unicorn";
-import { default as default14 } from "eslint-plugin-unused-imports";
-import { default as default15 } from "eslint-plugin-vitest";
-import { default as default16 } from "eslint-plugin-vue";
-import * as pluginYaml from "eslint-plugin-yml";
-import { default as default17 } from "jsonc-eslint-parser";
-import { default as default18 } from "vue-eslint-parser";
-import { default as default19 } from "yaml-eslint-parser";
-
-// src/configs/comments.ts
-function comments() {
-  return [
-    {
-      name: "vinicunca:eslint-comments",
-      plugins: {
-        "eslint-comments": default5
-      },
-      rules: {
-        "eslint-comments/no-aggregating-enable": ERROR,
-        "eslint-comments/no-duplicate-disable": ERROR,
-        "eslint-comments/no-unlimited-disable": ERROR,
-        "eslint-comments/no-unused-enable": ERROR
-      }
-    }
-  ];
-}
-
 // ../node_modules/.pnpm/@vinicunca+perkakas@0.0.11/node_modules/@vinicunca/perkakas/dist/index.js
 function purry(fn, args, lazy) {
   const diff = fn.length - args.length;
@@ -72,6 +18,9 @@ function purry(fn, args, lazy) {
 function isArray(data) {
   return Array.isArray(data);
 }
+function isBoolean(data) {
+  return typeof data === "boolean";
+}
 function isDefined(data) {
   return typeof data !== "undefined" && data !== null;
 }
@@ -1026,6 +975,45 @@ function toPairs(object) {
   toPairs2.strict = strict;
 })(toPairs || (toPairs = {}));
 
+// src/base.ts
+import { isPackageExists } from "local-pkg";
+import process3 from "process";
+
+// src/flags.ts
+var ERROR = "error";
+var OFF = "off";
+var WARN = "warn";
+var CONSISTENT = "consistent";
+var NEVER = "never";
+var ALWAYS = "always";
+
+// src/plugins.ts
+import { default as default2 } from "@vinicunca/eslint-plugin-vinicunca";
+import { default as default3 } from "eslint-plugin-eslint-comments";
+import * as pluginImport from "eslint-plugin-i";
+import { default as default4 } from "eslint-plugin-n";
+import { default as default5 } from "eslint-plugin-perfectionist";
+import { default as default6 } from "eslint-plugin-unicorn";
+import { default as default7 } from "eslint-plugin-unused-imports";
+
+// src/configs/comments.ts
+async function comments() {
+  return [
+    {
+      name: "vinicunca:eslint-comments",
+      plugins: {
+        "eslint-comments": default3
+      },
+      rules: {
+        "eslint-comments/no-aggregating-enable": ERROR,
+        "eslint-comments/no-duplicate-disable": ERROR,
+        "eslint-comments/no-unlimited-disable": ERROR,
+        "eslint-comments/no-unused-enable": ERROR
+      }
+    }
+  ];
+}
+
 // src/configs/ignores.ts
 import fs from "fs";
 import parseGitignore from "parse-gitignore";
@@ -1079,10 +1067,11 @@ var GLOB_JSON5 = "**/*.json5";
 var GLOB_JSONC = "**/*.jsonc";
 var GLOB_YAML = "**/*.y?(a)ml";
 var GLOB_MARKDOWN = "**/*.md";
+var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
 var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
 
 // src/configs/ignores.ts
-function ignores({
+async function ignores({
   enableGitignore = true,
   items = [],
   replace = false
@@ -1114,13 +1103,13 @@ function ignores({
 }
 
 // src/configs/imports.ts
-function imports() {
+async function imports() {
   return [
     {
       name: "vinicunca:imports",
       plugins: {
         import: pluginImport,
-        vinicunca: default4
+        vinicunca: default2
       },
       rules: {
         "import/export": ERROR,
@@ -1145,7 +1134,7 @@ function imports() {
 
 // src/configs/javascript.ts
 import globals from "globals";
-function javascript(options = {}) {
+async function javascript(options = {}) {
   const {
     isInEditor = false,
     overrides = {}
@@ -1162,7 +1151,9 @@ function javascript(options = {}) {
           window: "readonly"
         },
         parserOptions: {
-          ecmaFeatures: { jsx: true },
+          ecmaFeatures: {
+            jsx: true
+          },
           ecmaVersion: 2022,
           sourceType: "module"
         },
@@ -1173,9 +1164,9 @@ function javascript(options = {}) {
       },
       name: "vinicunca:javascript",
       plugins: {
-        "perfectionist": default10,
-        "unused-imports": default14,
-        "vinicunca": default4
+        "perfectionist": default5,
+        "unused-imports": default7,
+        "vinicunca": default2
       },
       rules: {
         "accessor-pairs": [ERROR, {
@@ -1183,7 +1174,6 @@ function javascript(options = {}) {
           setWithoutGet: true
         }],
         "array-callback-return": [ERROR, { checkForEach: true }],
-        "arrow-parens": [ERROR, ALWAYS],
         "block-scoped-var": ERROR,
         "camelcase": [ERROR, {
           allow: ["^UNSAFE_"],
@@ -1396,8 +1386,8 @@ function javascript(options = {}) {
         }],
         "vars-on-top": ERROR,
         "yoda": [ERROR, NEVER],
-        ...default4.configs.recommended.rules,
-        ...default10.configs["recommended-natural"].rules,
+        ...default2.configs.recommended.rules,
+        ...default5.configs["recommended-natural"].rules,
         "perfectionist/sort-imports": [
           ERROR,
           {
@@ -1434,13 +1424,35 @@ function javascript(options = {}) {
   ];
 }
 
+// src/utils.ts
+async function combineConfigs(...configs) {
+  const resolvedConfigs = await Promise.all(configs);
+  return resolvedConfigs.flatMap((config) => Array.isArray(config) ? config : [config]);
+}
+function renameRules(rules, from, to) {
+  return Object.fromEntries(
+    Object.entries(rules).map(([key, value]) => {
+      if (key.startsWith(from)) {
+        return [to + key.slice(from.length), value];
+      }
+      ;
+      return [key, value];
+    })
+  );
+}
+async function interopDefault(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+
 // src/configs/jsdoc.ts
-function jsdoc() {
+async function jsdoc() {
   return [
     {
       name: "vinicunca:jsdoc",
       plugins: {
-        jsdoc: default6
+        // @ts-expect-error missing types
+        jsdoc: await interopDefault(import("eslint-plugin-jsdoc"))
       },
       rules: {
         "jsdoc/check-access": WARN,
@@ -1468,10 +1480,22 @@ function jsdoc() {
 }
 
 // src/configs/jsonc.ts
-function jsonc(options = {}) {
+async function jsonc(options = {}) {
   const {
-    overrides = {}
+    files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
+    overrides = {},
+    stylistic: stylistic2 = true
   } = options;
+  const {
+    indent = 2
+  } = isBoolean(stylistic2) ? {} : stylistic2;
+  const [
+    pluginJsonc,
+    parserJsonc
+  ] = await Promise.all([
+    interopDefault(import("eslint-plugin-jsonc")),
+    interopDefault(import("jsonc-eslint-parser"))
+  ]);
   return [
     {
       name: "vinicunca:jsonc:setup",
@@ -1480,17 +1504,12 @@ function jsonc(options = {}) {
       }
     },
     {
-      files: [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
+      files,
       languageOptions: {
-        parser: default17
+        parser: parserJsonc
       },
       name: "vinicunca:jsonc:rules",
       rules: {
-        "jsonc/array-bracket-spacing": [ERROR, NEVER],
-        "jsonc/comma-dangle": [ERROR, NEVER],
-        "jsonc/comma-style": [ERROR, "last"],
-        "jsonc/indent": [ERROR, 2],
-        "jsonc/key-spacing": [ERROR, { afterColon: true, beforeColon: false }],
         "jsonc/no-bigint-literals": ERROR,
         "jsonc/no-binary-expression": ERROR,
         "jsonc/no-binary-numeric-literals": ERROR,
@@ -1514,14 +1533,21 @@ function jsonc(options = {}) {
         "jsonc/no-undefined-value": ERROR,
         "jsonc/no-unicode-codepoint-escapes": ERROR,
         "jsonc/no-useless-escape": ERROR,
-        "jsonc/object-curly-newline": [ERROR, { consistent: true, multiline: true }],
-        "jsonc/object-curly-spacing": [ERROR, "always"],
-        "jsonc/object-property-newline": [ERROR, { allowMultiplePropertiesPerLine: true }],
-        "jsonc/quote-props": ERROR,
-        "jsonc/quotes": ERROR,
         "jsonc/space-unary-ops": ERROR,
         "jsonc/valid-json-number": ERROR,
         "jsonc/vue-custom-block/no-parsing-error": ERROR,
+        ...stylistic2 ? {
+          "jsonc/array-bracket-spacing": [ERROR, NEVER],
+          "jsonc/comma-dangle": [ERROR, NEVER],
+          "jsonc/comma-style": [ERROR, "last"],
+          "jsonc/indent": [ERROR, indent],
+          "jsonc/key-spacing": [ERROR, { afterColon: true, beforeColon: false }],
+          "jsonc/object-curly-newline": [ERROR, { consistent: true, multiline: true }],
+          "jsonc/object-curly-spacing": [ERROR, "always"],
+          "jsonc/object-property-newline": [ERROR, { allowMultiplePropertiesPerLine: true }],
+          "jsonc/quote-props": ERROR,
+          "jsonc/quotes": ERROR
+        } : {},
         ...overrides
       }
     }
@@ -1529,18 +1555,26 @@ function jsonc(options = {}) {
 }
 
 // src/configs/markdown.ts
-function markdown(options = {}) {
+async function markdown(options = {}) {
   const {
     componentExts = [],
+    files = [GLOB_MARKDOWN],
     overrides = {}
   } = options;
   return [
     {
       name: "vinicunca:markdown:setup",
       plugins: {
-        markdown: default7
+        // @ts-expect-error missing types
+        markdown: await interopDefault(import("eslint-plugin-markdown"))
       }
     },
+    {
+      files,
+      ignores: [GLOB_MARKDOWN_IN_MARKDOWN],
+      name: "vinicunca:markdown:processor",
+      processor: "markdown/markdown"
+    },
     {
       files: [GLOB_MARKDOWN],
       name: "vinicunca:markdown:processor",
@@ -1558,8 +1592,9 @@ function markdown(options = {}) {
           }
         }
       },
-      name: "vinicunca:markdown:rules",
+      name: "vinicunca:markdown:disables",
       rules: {
+        "import/newline-after-import": OFF,
         "no-alert": OFF,
         "no-console": OFF,
         "no-undef": OFF,
@@ -1597,7 +1632,6 @@ function markdown(options = {}) {
           "ts/restrict-template-expressions": OFF,
           "ts/unbound-method": OFF
         },
-        "vinicunca/no-cjs-exports": OFF,
         "vinicunca/no-ts-export-equal": OFF,
         ...overrides
       }
@@ -1606,12 +1640,12 @@ function markdown(options = {}) {
 }
 
 // src/configs/node.ts
-function node() {
+async function node() {
   return [
     {
       name: "vinicunca:node",
       plugins: {
-        node: default8
+        node: default4
       },
       rules: {
         "node/handle-callback-err": [ERROR, "^(err|error)$"],
@@ -1630,23 +1664,46 @@ function node() {
 
 // src/configs/react.ts
 var STR_PARENS_NEW_LINE = "parens-new-line";
-function react(options = {}) {
+async function react(options = {}) {
   const {
+    files = [GLOB_JSX, GLOB_TSX],
     overrides = {}
   } = options;
+  const [
+    pluginReact,
+    pluginReactHooks
+  ] = await Promise.all([
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-react")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-react-hooks"))
+  ]);
   return [
     {
       name: "vinicunca:react:setup",
       plugins: {
-        "react": default11,
-        "react-hooks": default12
+        "react": pluginReact,
+        "react-hooks": pluginReactHooks
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
       }
     },
     {
+      files,
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
       name: "vinicunca:react:rules",
       rules: {
-        ...default11.configs.recommended.rules,
-        ...default12.configs.recommended.rules,
+        ...pluginReact.configs.recommended.rules,
+        ...pluginReactHooks.configs.recommended.rules,
         "react/boolean-prop-naming": [OFF, {
           message: "",
           propTypeNames: ["bool", "mutuallyExclusiveTrueProps"],
@@ -1706,24 +1763,19 @@ function react(options = {}) {
           return: STR_PARENS_NEW_LINE
         }],
         "react/no-danger": WARN,
+        "react/no-unescaped-entities": OFF,
         "react/prop-types": OFF,
         "react/react-in-jsx-scope": OFF,
         "react/self-closing-comp": ERROR,
         "react/style-prop-object": ERROR,
-        "style/jsx-quotes": [ERROR, "prefer-double"],
         ...overrides
-      },
-      settings: {
-        react: {
-          version: "detect"
-        }
       }
     }
   ];
 }
 
 // src/configs/sort-package-json.ts
-function sortPackageJson() {
+async function sortPackageJson() {
   return [
     {
       files: ["**/package.json"],
@@ -1939,19 +1991,35 @@ function sortTsconfig() {
 }
 
 // src/configs/stylistic.ts
-function stylistic() {
+var STYLISTIC_CONFIG_DEFAULTS = {
+  indent: 2,
+  jsx: true,
+  quotes: "single",
+  semi: true
+};
+async function stylistic(options = {}) {
+  const {
+    indent,
+    quotes,
+    semi
+  } = {
+    ...STYLISTIC_CONFIG_DEFAULTS,
+    ...options
+  };
+  const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
   return [
     {
       name: "vinicunca:stylistic",
       plugins: {
-        style: default2,
-        vinicunca: default4
+        style: pluginStylistic,
+        vinicunca: default2
       },
       rules: {
         "curly": [ERROR, "all"],
         "style/array-bracket-newline": [ERROR, CONSISTENT],
         "style/array-bracket-spacing": [ERROR, NEVER],
         "style/array-element-newline": [ERROR, CONSISTENT],
+        "style/arrow-parens": [ERROR, ALWAYS],
         "style/arrow-spacing": [ERROR, { after: true, before: true }],
         "style/block-spacing": [ERROR, ALWAYS],
         "style/brace-style": [ERROR],
@@ -1962,7 +2030,7 @@ function stylistic() {
         "style/dot-location": [ERROR, "property"],
         "style/eol-last": ERROR,
         "style/func-call-spacing": [ERROR, NEVER],
-        "style/indent": [ERROR, 2, {
+        "style/indent": [ERROR, indent, {
           ArrayExpression: 1,
           CallExpression: { arguments: 1 },
           FunctionDeclaration: { body: 1, parameters: 1 },
@@ -2000,6 +2068,7 @@ function stylistic() {
           offsetTernaryExpressions: true,
           outerIIFEBody: 1
         }],
+        "style/indent-binary-ops": [ERROR, indent],
         "style/key-spacing": [ERROR, { afterColon: true, beforeColon: false }],
         "style/keyword-spacing": [ERROR, { after: true, before: true }],
         "style/lines-between-class-members": [ERROR, ALWAYS, { exceptAfterSingleLine: true }],
@@ -2029,9 +2098,9 @@ function stylistic() {
         "style/operator-linebreak": [ERROR, "before"],
         "style/padded-blocks": [ERROR, { blocks: NEVER, classes: NEVER, switches: NEVER }],
         "style/quote-props": [ERROR, "consistent-as-needed"],
-        "style/quotes": [ERROR, "single"],
+        "style/quotes": [ERROR, quotes],
         "style/rest-spread-spacing": [ERROR, NEVER],
-        "style/semi": [ERROR, ALWAYS],
+        "style/semi": [ERROR, semi ? ALWAYS : NEVER],
         "style/semi-spacing": [ERROR, { after: true, before: false }],
         "style/space-before-blocks": [ERROR, ALWAYS],
         "style/space-before-function-paren": [ERROR, {
@@ -2075,27 +2144,36 @@ function stylistic() {
 }
 
 // src/configs/test.ts
-function test(options = {}) {
+async function test(options = {}) {
   const {
+    files = GLOB_TESTS,
     isInEditor = false,
     overrides = {}
   } = options;
+  const [
+    pluginVitest,
+    pluginNoOnlyTests
+  ] = await Promise.all([
+    interopDefault(import("eslint-plugin-vitest")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-no-only-tests"))
+  ]);
   return [
     {
       name: "vinicunca:test:setup",
       plugins: {
         test: {
-          ...default15,
+          ...pluginVitest,
           rules: {
-            ...default15.rules,
+            ...pluginVitest.rules,
             // extend `test/no-only-tests` rule
-            ...default9.rules
+            ...pluginNoOnlyTests.rules
           }
         }
       }
     },
     {
-      files: GLOB_TESTS,
+      files,
       name: "vinicunca:test:rules",
       rules: {
         "test/consistent-test-it": [ERROR, { fn: "it", withinDescribe: "it" }],
@@ -2111,31 +2189,17 @@ function test(options = {}) {
 
 // src/configs/typescript.ts
 import process from "process";
-
-// src/utils.ts
-function combineConfigs(...configs) {
-  return configs.flatMap((config) => Array.isArray(config) ? config : [config]);
-}
-function renameRules(rules, from, to) {
-  return Object.fromEntries(
-    Object.entries(rules).map(([key, value]) => {
-      if (key.startsWith(from)) {
-        return [to + key.slice(from.length), value];
-      }
-      ;
-      return [key, value];
-    })
-  );
-}
-
-// src/configs/typescript.ts
-function typescript(options) {
+async function typescript(options = {}) {
   const {
     componentExts = [],
     overrides = {},
     parserOptions = {},
     tsconfigPath = []
   } = options ?? {};
+  const files = options.files ?? [
+    GLOB_SRC,
+    ...componentExts.map((ext) => `**/*.${ext}`)
+  ];
   const typeAwareRules = {
     "dot-notation": OFF,
     "no-implied-eval": OFF,
@@ -2160,21 +2224,28 @@ function typescript(options) {
     };
     additionalTypeAwareRules = typeAwareRules;
   }
+  const [
+    pluginTs,
+    parserTs,
+    pluginStylistic
+  ] = await Promise.all([
+    interopDefault(import("@typescript-eslint/eslint-plugin")),
+    interopDefault(import("@typescript-eslint/parser")),
+    interopDefault(import("@stylistic/eslint-plugin"))
+  ]);
   return [
     {
       // Install the plugins without globs, so they can be configured separately.
       name: "vinicunca:typescript:setup",
       plugins: {
         import: pluginImport,
-        ts: default3,
-        vinicunca: default4
+        style: pluginStylistic,
+        ts: pluginTs,
+        vinicunca: default2
       }
     },
     {
-      files: [
-        GLOB_SRC,
-        ...componentExts.map((ext) => `**/*.${ext}`)
-      ],
+      files,
       languageOptions: {
         parser: parserTs,
         parserOptions: {
@@ -2187,12 +2258,12 @@ function typescript(options) {
       name: "vinicunca:typescript:rules",
       rules: {
         ...renameRules(
-          default3.configs["eslint-recommended"].overrides[0].rules,
+          pluginTs.configs["eslint-recommended"].overrides[0].rules,
           "@typescript-eslint/",
           "ts/"
         ),
         ...renameRules(
-          default3.configs.strict.rules,
+          pluginTs.configs.strict.rules,
           "@typescript-eslint/",
           "ts/"
         ),
@@ -2203,6 +2274,8 @@ function typescript(options) {
         "no-unused-vars": OFF,
         "no-use-before-define": OFF,
         "no-useless-constructor": OFF,
+        "style/type-generic-spacing": ERROR,
+        "style/type-named-tuple-spacing": ERROR,
         "ts/ban-ts-comment": [ERROR, { "ts-ignore": "allow-with-description" }],
         "ts/ban-types": [ERROR, { types: { Function: false } }],
         "ts/consistent-type-definitions": [ERROR, "interface"],
@@ -2231,9 +2304,6 @@ function typescript(options) {
         "ts/parameter-properties": OFF,
         "ts/prefer-ts-expect-error": ERROR,
         "ts/triple-slash-reference": OFF,
-        "vinicunca/generic-spacing": ERROR,
-        "vinicunca/named-tuple-spacing": ERROR,
-        "vinicunca/no-cjs-exports": ERROR,
         "vinicunca/no-ts-export-equal": ERROR,
         ...additionalTypeAwareRules,
         ...overrides
@@ -2267,7 +2337,7 @@ function typescript(options) {
 }
 
 // src/configs/unicorn.ts
-function unicorn(options = {}) {
+async function unicorn(options = {}) {
   const {
     overrides = {}
   } = options;
@@ -2275,7 +2345,7 @@ function unicorn(options = {}) {
     {
       name: "vinicunca:unicorn",
       plugins: {
-        unicorn: default13
+        unicorn: default6
       },
       rules: {
         "unicorn/error-message": ERROR,
@@ -2297,13 +2367,48 @@ function unicorn(options = {}) {
   ];
 }
 
+// src/configs/unocss.ts
+async function unocss(options = {}) {
+  const {
+    attributify = false,
+    strict = false
+  } = options;
+  const [
+    pluginUnoCSS
+  ] = await Promise.all([
+    interopDefault(import("@unocss/eslint-plugin"))
+  ]);
+  return [
+    {
+      name: "vinicunca:unocss",
+      plugins: {
+        unocss: pluginUnoCSS
+      },
+      rules: {
+        "unocss/order": "warn",
+        ...attributify ? {
+          "unocss/order-attributify": "warn"
+        } : {},
+        ...strict ? {
+          "unocss/blocklist": "error"
+        } : {}
+      }
+    }
+  ];
+}
+
 // src/configs/vue.ts
 import process2 from "process";
-function vue(options = {}) {
+async function vue(options = {}) {
   const {
+    files = [GLOB_VUE],
     overrides = {},
+    stylistic: stylistic2 = true,
     typescript: typescript2 = {}
   } = options;
+  const {
+    indent = 2
+  } = isBoolean(stylistic2) ? {} : stylistic2;
   let tsConfigOptions = {};
   const tsconfigPath = typescript2.tsconfigPath ?? [];
   if (!isEmpty(tsconfigPath)) {
@@ -2312,34 +2417,42 @@ function vue(options = {}) {
       tsconfigRootDir: process2.cwd()
     };
   }
+  const [
+    pluginVue,
+    parserVue
+  ] = await Promise.all([
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-vue")),
+    interopDefault(import("vue-eslint-parser"))
+  ]);
   return [
     {
       name: "vinicunca:vue:setup",
       plugins: {
-        vue: default16
+        vue: pluginVue
       }
     },
     {
-      files: [GLOB_VUE],
+      files,
       languageOptions: {
-        parser: default18,
+        parser: parserVue,
         parserOptions: {
           ecmaFeatures: {
             jsx: true
           },
           extraFileExtensions: [".vue"],
-          parser: typescript2.enabled ? parserTs : void 0,
+          parser: typescript2.enabled ? await interopDefault(import("@typescript-eslint/parser")) : null,
           sourceType: "module",
           ...tsConfigOptions
         }
       },
       name: "vinicunca:vue:rules",
-      processor: default16.processors[".vue"],
+      processor: pluginVue.processors[".vue"],
       rules: {
-        ...default16.configs.base.rules,
-        ...default16.configs["vue3-essential"].rules,
-        ...default16.configs["vue3-strongly-recommended"].rules,
-        ...default16.configs["vue3-recommended"].rules,
+        ...pluginVue.configs.base.rules,
+        ...pluginVue.configs["vue3-essential"].rules,
+        ...pluginVue.configs["vue3-strongly-recommended"].rules,
+        ...pluginVue.configs["vue3-recommended"].rules,
         "node/prefer-global/process": OFF,
         "vue/array-bracket-spacing": [ERROR, NEVER],
         "vue/arrow-spacing": [ERROR, {
@@ -2373,6 +2486,7 @@ function vue(options = {}) {
         "vue/html-comment-content-spacing": [ERROR, ALWAYS, {
           exceptions: ["-"]
         }],
+        "vue/html-indent": [ERROR, indent],
         "vue/key-spacing": [ERROR, {
           afterColon: true,
           beforeColon: false
@@ -2432,10 +2546,23 @@ function vue(options = {}) {
 }
 
 // src/configs/yaml.ts
-function yaml(options = {}) {
+async function yaml(options = {}) {
   const {
-    overrides = {}
+    files = [GLOB_YAML],
+    overrides = {},
+    stylistic: stylistic2 = true
   } = options;
+  const {
+    indent = 2,
+    quotes = "single"
+  } = isBoolean(stylistic2) ? {} : stylistic2;
+  const [
+    pluginYaml,
+    parserYaml
+  ] = await Promise.all([
+    interopDefault(import("eslint-plugin-yml")),
+    interopDefault(import("yaml-eslint-parser"))
+  ]);
   return [
     {
       name: "vinicunca:yaml:setup",
@@ -2444,9 +2571,9 @@ function yaml(options = {}) {
       }
     },
     {
-      files: [GLOB_YAML],
+      files,
       languageOptions: {
-        parser: default19
+        parser: parserYaml
       },
       name: "vinicunca:yaml:rules",
       rules: {
@@ -2459,14 +2586,14 @@ function yaml(options = {}) {
         "yaml/flow-mapping-curly-spacing": ERROR,
         "yaml/flow-sequence-bracket-newline": ERROR,
         "yaml/flow-sequence-bracket-spacing": ERROR,
-        "yaml/indent": [ERROR, 2],
+        "yaml/indent": [ERROR, indent === "tab" ? 2 : indent],
         "yaml/key-spacing": ERROR,
         "yaml/no-empty-key": ERROR,
         "yaml/no-empty-sequence-entry": ERROR,
         "yaml/no-irregular-whitespace": ERROR,
         "yaml/no-tab-indent": ERROR,
         "yaml/plain-scalar": ERROR,
-        "yaml/quotes": [ERROR, { avoidEscape: false, prefer: "single" }],
+        "yaml/quotes": [ERROR, { avoidEscape: false, prefer: quotes }],
         "yaml/spaced-comment": ERROR,
         "yaml/vue-custom-block/no-parsing-error": ERROR,
         ...overrides
@@ -2482,7 +2609,7 @@ var VuePackages = [
   "vitepress",
   "@slidev/cli"
 ];
-function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
+async function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
   const {
     componentExts = [],
     isInEditor = !!((process3.env.VSCODE_PID || process3.env.JETBRAINS_IDE) && !process3.env.CI),
@@ -2490,14 +2617,24 @@ function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
     markdown: enableMarkdown = true,
     overrides = {},
     react: enableReact = false,
-    stylistic: enableStylistic = true,
     test: enableTest = true,
     typescript: tsOptions = {},
+    unocss: enableUnoCSS = false,
     vue: enableVue = VuePackages.some((i) => isPackageExists(i)),
     yaml: enableYaml = true
   } = options;
+  let stylisticOptions = true;
+  if (options.stylistic === false) {
+    stylisticOptions = false;
+  } else if (isObject(options.stylistic)) {
+    stylisticOptions = {
+      ...options.stylistic,
+      jsx: options.jsx ?? true
+    };
+  }
   const configs = [];
   configs.push(
+    ignores(options.ignores),
     javascript({
       isInEditor,
       overrides: overrides.javascript
@@ -2522,7 +2659,7 @@ function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
       overrides: overrides.typescript
     }));
   }
-  if (enableStylistic) {
+  if (stylisticOptions) {
     configs.push(stylistic());
   }
   if (enableTest) {
@@ -2542,10 +2679,21 @@ function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
     }));
   }
   ;
+  if (enableReact) {
+    configs.push(react({
+      overrides: overrides.react
+    }));
+  }
+  if (enableUnoCSS) {
+    configs.push(unocss(
+      isBoolean(enableUnoCSS) ? {} : enableUnoCSS
+    ));
+  }
   if (enableJsonc) {
     configs.push(
       jsonc({
-        overrides: overrides.jsonc
+        overrides: overrides.jsonc,
+        stylistic: stylisticOptions
       }),
       sortPackageJson(),
       sortTsconfig()
@@ -2553,7 +2701,8 @@ function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
   }
   if (enableYaml) {
     configs.push(yaml({
-      overrides: overrides.yaml
+      overrides: overrides.yaml,
+      stylistic: stylisticOptions
     }));
   }
   ;
@@ -2564,20 +2713,12 @@ function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
     }));
   }
   ;
-  if (enableReact) {
-    configs.push(react({
-      overrides: overrides.react
-    }));
-  }
   configs.push(ignores(options.ignores));
   return combineConfigs(
     ...configs,
     ...userConfigs
   );
 }
-
-// src/index.ts
-var src_default = vinicuncaESLint;
 export {
   GLOB_EXCLUDE,
   GLOB_JS,
@@ -2587,6 +2728,7 @@ export {
   GLOB_JSX,
   GLOB_MARKDOWN,
   GLOB_MARKDOWN_CODE,
+  GLOB_MARKDOWN_IN_MARKDOWN,
   GLOB_SRC,
   GLOB_SRC_EXT,
   GLOB_TESTS,
@@ -2596,36 +2738,21 @@ export {
   GLOB_YAML,
   combineConfigs,
   comments,
-  src_default as default,
   ignores,
   imports,
+  interopDefault,
   javascript,
   jsdoc,
   jsonc,
   markdown,
   node,
-  default17 as parserJsonc,
-  parserTs,
-  default18 as parserVue,
-  default19 as parserYaml,
-  default5 as pluginComments,
+  default3 as pluginComments,
   pluginImport,
-  default6 as pluginJsdoc,
-  pluginJsonc,
-  default7 as pluginMarkdown,
-  default9 as pluginNoOnlyTests,
-  default8 as pluginNode,
-  default10 as pluginPerfectionist,
-  default11 as pluginReact,
-  default12 as pluginReactHooks,
-  default2 as pluginStylistic,
-  default3 as pluginTs,
-  default13 as pluginUnicorn,
-  default14 as pluginUnusedImports,
-  default4 as pluginVinicunca,
-  default15 as pluginVitest,
-  default16 as pluginVue,
-  pluginYaml,
+  default4 as pluginNode,
+  default5 as pluginPerfectionist,
+  default6 as pluginUnicorn,
+  default7 as pluginUnusedImports,
+  default2 as pluginVinicunca,
   react,
   renameRules,
   sortPackageJson,
@@ -2634,6 +2761,7 @@ export {
   test,
   typescript,
   unicorn,
+  unocss,
   vinicuncaESLint,
   vue,
   yaml