@debbl/eslint-config 1.1.1 → 2.0.0

package/dist/index.cjs

@@ -54,40 +54,16 @@ __export(src_exports, {
   combine: () => combine,
   comments: () => comments,
   config: () => config,
-  configPrettier: () => import_eslint_config_prettier.default,
   default: () => src_default,
   ignores: () => ignores,
   imports: () => imports,
+  interopDefault: () => interopDefault,
   javascript: () => javascript,
   jsdoc: () => jsdoc,
   jsonc: () => jsonc,
   markdown: () => markdown,
   node: () => node,
-  parserJsonc: () => import_jsonc_eslint_parser.default,
-  parserTs: () => parserTs,
-  parserVue: () => import_vue_eslint_parser.default,
-  parserYml: () => import_yaml_eslint_parser.default,
   perfectionist: () => perfectionist,
-  pluginAntfu: () => import_eslint_plugin_antfu.default,
-  pluginComments: () => import_eslint_plugin_eslint_comments.default,
-  pluginImport: () => pluginImport,
-  pluginJsdoc: () => import_eslint_plugin_jsdoc.default,
-  pluginJsonc: () => pluginJsonc,
-  pluginMarkdown: () => import_eslint_plugin_markdown.default,
-  pluginNext: () => pluginNext,
-  pluginNoOnlyTests: () => import_eslint_plugin_no_only_tests.default,
-  pluginNode: () => import_eslint_plugin_n.default,
-  pluginPerfectionist: () => import_eslint_plugin_perfectionist.default,
-  pluginPrettier: () => import_eslint_plugin_prettier.default,
-  pluginReact: () => import_eslint_plugin_react.default,
-  pluginReactHooks: () => import_eslint_plugin_react_hooks.default,
-  pluginTailwindcss: () => import_eslint_plugin_tailwindcss.default,
-  pluginTs: () => import_eslint_plugin.default,
-  pluginUnicorn: () => import_eslint_plugin_unicorn.default,
-  pluginUnusedImports: () => import_eslint_plugin_unused_imports.default,
-  pluginVitest: () => import_eslint_plugin_vitest.default,
-  pluginVue: () => import_eslint_plugin_vue.default,
-  pluginYml: () => pluginYml,
   prettier: () => prettier,
   sortPackageJson: () => sortPackageJson,
   sortTsconfig: () => sortTsconfig,
@@ -99,40 +75,17 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/plugins.ts
-var import_eslint_plugin_antfu = __toESM(require("eslint-plugin-antfu"), 1);
-var import_eslint_plugin_eslint_comments = __toESM(require("eslint-plugin-eslint-comments"), 1);
-var pluginImport = __toESM(require("eslint-plugin-i"), 1);
-var import_eslint_plugin_jsdoc = __toESM(require("eslint-plugin-jsdoc"), 1);
-var import_eslint_plugin_markdown = __toESM(require("eslint-plugin-markdown"), 1);
-var import_eslint_plugin_n = __toESM(require("eslint-plugin-n"), 1);
-var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
-var import_eslint_plugin_unused_imports = __toESM(require("eslint-plugin-unused-imports"), 1);
-var import_eslint_plugin_no_only_tests = __toESM(require("eslint-plugin-no-only-tests"), 1);
-var import_eslint_plugin_vitest = __toESM(require("eslint-plugin-vitest"), 1);
-var import_eslint_plugin_perfectionist = __toESM(require("eslint-plugin-perfectionist"), 1);
-var import_eslint_plugin_prettier = __toESM(require("eslint-plugin-prettier"), 1);
-var import_eslint_config_prettier = __toESM(require("eslint-config-prettier"), 1);
-var import_eslint_plugin_react = __toESM(require("eslint-plugin-react"), 1);
-var import_eslint_plugin_react_hooks = __toESM(require("eslint-plugin-react-hooks"), 1);
-var pluginNext = __toESM(require("@next/eslint-plugin-next"), 1);
-var parserTs = __toESM(require("@typescript-eslint/parser"), 1);
-var import_eslint_plugin = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
-var import_eslint_plugin_vue = __toESM(require("eslint-plugin-vue"), 1);
-var import_vue_eslint_parser = __toESM(require("vue-eslint-parser"), 1);
-var pluginYml = __toESM(require("eslint-plugin-yml"), 1);
-var import_yaml_eslint_parser = __toESM(require("yaml-eslint-parser"), 1);
-var pluginJsonc = __toESM(require("eslint-plugin-jsonc"), 1);
-var import_jsonc_eslint_parser = __toESM(require("jsonc-eslint-parser"), 1);
-var import_eslint_plugin_tailwindcss = __toESM(require("eslint-plugin-tailwindcss"), 1);
-
 // src/configs/comments.ts
-function comments() {
+async function comments() {
+  const pluginComments = await interopDefault(
+    // @ts-expect-error missing types
+    import("eslint-plugin-eslint-comments")
+  );
   return [
     {
       name: "eslint:eslint-comments",
       plugins: {
-        "eslint-comments": import_eslint_plugin_eslint_comments.default
+        "eslint-comments": pluginComments
       },
       rules: {
         "eslint-comments/no-aggregating-enable": "error",
@@ -214,7 +167,7 @@ var GLOB_EXCLUDE = [
 // src/configs/ignores.ts
 var REGEX_SPLIT_ALL_CRLF = /\r?\n/g;
 var splitPattern = (pattern) => pattern.split(REGEX_SPLIT_ALL_CRLF);
-function ignores(options) {
+async function ignores(options) {
   const { enableGitignore } = options;
   if (enableGitignore) {
     let ignorePath = ".gitignore";
@@ -239,13 +192,28 @@ function ignores(options) {
   ];
 }
 
+// src/utils.ts
+async function combine(...configs) {
+  const resolved = await Promise.all(configs);
+  return resolved.flat();
+}
+async function interopDefault(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+
 // src/configs/imports.ts
-function imports() {
+async function imports() {
+  const [pluginAntfu, pluginImport] = await Promise.all([
+    interopDefault(import("eslint-plugin-antfu")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-i"))
+  ]);
   return [
     {
       name: "eslint:imports",
       plugins: {
-        antfu: import_eslint_plugin_antfu.default,
+        antfu: pluginAntfu,
         import: pluginImport
       },
       rules: {
@@ -269,9 +237,15 @@ function imports() {
 
 // src/configs/javascript.ts
 var import_globals = __toESM(require("globals"), 1);
-function javascript() {
+async function javascript() {
+  const [pluginAntfu, pluginUnusedImports] = await Promise.all([
+    interopDefault(import("eslint-plugin-antfu")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-unused-imports"))
+  ]);
   return [
     {
+      name: "eslint:javascript",
       languageOptions: {
         ecmaVersion: 2022,
         globals: {
@@ -294,10 +268,9 @@ function javascript() {
       linterOptions: {
         reportUnusedDisableDirectives: true
       },
-      name: "eslint:javascript",
       plugins: {
-        "antfu": import_eslint_plugin_antfu.default,
-        "unused-imports": import_eslint_plugin_unused_imports.default
+        "antfu": pluginAntfu,
+        "unused-imports": pluginUnusedImports
       },
       rules: {
         "accessor-pairs": [
@@ -509,8 +482,8 @@ function javascript() {
       }
     },
     {
-      files: [`scripts/${GLOB_SRC}`, `cli.${GLOB_SRC_EXT}`],
       name: "eslint:scripts-overrides",
+      files: [`scripts/${GLOB_SRC}`, `cli.${GLOB_SRC_EXT}`],
       rules: {
         "no-console": "off"
       }
@@ -519,12 +492,13 @@ function javascript() {
 }
 
 // src/configs/jsdoc.ts
-function jsdoc() {
+async function jsdoc() {
   return [
     {
       name: "eslint:jsdoc",
       plugins: {
-        jsdoc: import_eslint_plugin_jsdoc.default
+        // @ts-expect-error missing types
+        jsdoc: await interopDefault(import("eslint-plugin-jsdoc"))
       },
       rules: {
         "jsdoc/check-access": "warn",
@@ -550,7 +524,11 @@ function jsdoc() {
 }
 
 // src/configs/jsonc.ts
-function jsonc() {
+async function jsonc() {
+  const [pluginJsonc, parserJsonc] = await Promise.all([
+    interopDefault(import("eslint-plugin-jsonc")),
+    interopDefault(import("jsonc-eslint-parser"))
+  ]);
   return [
     {
       name: "eslint:jsonc:setup",
@@ -559,11 +537,11 @@ function jsonc() {
       }
     },
     {
+      name: "eslint:jsonc:rules",
       files: [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
       languageOptions: {
-        parser: import_jsonc_eslint_parser.default
+        parser: parserJsonc
       },
-      name: "eslint:jsonc:rules",
       rules: {
         "jsonc/no-bigint-literals": "error",
         "jsonc/no-binary-expression": "error",
@@ -616,21 +594,23 @@ function jsonc() {
 }
 
 // src/configs/markdown.ts
-function markdown(options = {}) {
+async function markdown(options = {}) {
   const { componentExts = [] } = options;
   return [
     {
-      name: "antfu:markdown:setup",
+      name: "eslint:markdown:setup",
       plugins: {
-        markdown: import_eslint_plugin_markdown.default
+        // @ts-expect-error missing types
+        markdown: await interopDefault(import("eslint-plugin-markdown"))
       }
     },
     {
+      name: "eslint:markdown:processor",
       files: [GLOB_MARKDOWN],
-      name: "antfu:markdown:processor",
       processor: "markdown/markdown"
     },
     {
+      name: "eslint:markdown:rules",
       files: [
         GLOB_MARKDOWN_CODE,
         ...componentExts.map((ext) => `${GLOB_MARKDOWN}/**/*.${ext}`)
@@ -642,7 +622,6 @@ function markdown(options = {}) {
           }
         }
       },
-      name: "antfu:markdown:rules",
       rules: {
         "antfu/no-cjs-exports": "off",
         "antfu/no-ts-export-equal": "off",
@@ -689,12 +668,13 @@ function markdown(options = {}) {
 }
 
 // src/configs/node.ts
-function node() {
+async function node() {
+  const pluginNode = await interopDefault(import("eslint-plugin-n"));
   return [
     {
       name: "eslint:node",
       plugins: {
-        n: import_eslint_plugin_n.default
+        n: pluginNode
       },
       rules: {
         "n/handle-callback-err": ["error", "^(err|error)$"],
@@ -711,11 +691,11 @@ function node() {
 }
 
 // src/configs/sort.ts
-function sortPackageJson() {
+async function sortPackageJson() {
   return [
     {
-      files: ["**/package.json"],
       name: "eslint:sort-package-json",
+      files: ["**/package.json"],
       rules: {
         "jsonc/sort-array-values": [
           "error",
@@ -795,11 +775,11 @@ function sortPackageJson() {
     }
   ];
 }
-function sortTsconfig() {
+async function sortTsconfig() {
   return [
     {
-      files: ["**/tsconfig.json", "**/tsconfig.*.json"],
       name: "eslint:sort-tsconfig",
+      files: ["**/tsconfig.json", "**/tsconfig.*.json"],
       rules: {
         "jsonc/sort-keys": [
           "error",
@@ -923,44 +903,49 @@ function sortTsconfig() {
 
 // src/configs/typescript.ts
 var import_node_process = __toESM(require("process"), 1);
-function typescript(options) {
+var typeAwareRules = {
+  "dot-notation": "off",
+  "no-implied-eval": "off",
+  "no-throw-literal": "off",
+  "@typescript-eslint/await-thenable": "error",
+  "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+  "@typescript-eslint/no-floating-promises": "error",
+  "@typescript-eslint/no-for-in-array": "error",
+  "@typescript-eslint/no-implied-eval": "error",
+  "@typescript-eslint/no-misused-promises": "error",
+  "@typescript-eslint/no-throw-literal": "error",
+  "@typescript-eslint/no-unnecessary-type-assertion": "error",
+  "@typescript-eslint/no-unsafe-argument": "error",
+  "@typescript-eslint/no-unsafe-assignment": "error",
+  "@typescript-eslint/no-unsafe-call": "error",
+  "@typescript-eslint/no-unsafe-member-access": "error",
+  "@typescript-eslint/no-unsafe-return": "error",
+  "@typescript-eslint/restrict-plus-operands": "error",
+  "@typescript-eslint/restrict-template-expressions": "error",
+  "@typescript-eslint/unbound-method": "error"
+};
+async function typescript(options) {
   const {
     componentExts = [],
     parserOptions = {},
     tsconfigPath
   } = options ?? {};
-  const typeAwareRules = {
-    "dot-notation": "off",
-    "no-implied-eval": "off",
-    "no-throw-literal": "off",
-    "@typescript-eslint/await-thenable": "error",
-    "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
-    "@typescript-eslint/no-floating-promises": "error",
-    "@typescript-eslint/no-for-in-array": "error",
-    "@typescript-eslint/no-implied-eval": "error",
-    "@typescript-eslint/no-misused-promises": "error",
-    "@typescript-eslint/no-throw-literal": "error",
-    "@typescript-eslint/no-unnecessary-type-assertion": "error",
-    "@typescript-eslint/no-unsafe-argument": "error",
-    "@typescript-eslint/no-unsafe-assignment": "error",
-    "@typescript-eslint/no-unsafe-call": "error",
-    "@typescript-eslint/no-unsafe-member-access": "error",
-    "@typescript-eslint/no-unsafe-return": "error",
-    "@typescript-eslint/restrict-plus-operands": "error",
-    "@typescript-eslint/restrict-template-expressions": "error",
-    "@typescript-eslint/unbound-method": "error"
-  };
+  const [pluginTs, parserTs, pluginAntfu] = await Promise.all([
+    interopDefault(import("@typescript-eslint/eslint-plugin")),
+    interopDefault(import("@typescript-eslint/parser")),
+    interopDefault(import("eslint-plugin-antfu"))
+  ]);
   return [
     {
       // Install the plugins without globs, so they can be configured separately.
       name: "eslint:typescript:setup",
       plugins: {
-        "antfu": import_eslint_plugin_antfu.default,
-        "import": pluginImport,
-        "@typescript-eslint": import_eslint_plugin.default
+        "antfu": pluginAntfu,
+        "@typescript-eslint": pluginTs
       }
     },
     {
+      name: "eslint:typescript:rules",
       files: [GLOB_SRC, ...componentExts.map((ext) => `**/*.${ext}`)],
       languageOptions: {
         parser: parserTs,
@@ -974,10 +959,9 @@ function typescript(options) {
           ...parserOptions
         }
       },
-      name: "eslint:typescript:rules",
       rules: {
-        ...import_eslint_plugin.default.configs["eslint-recommended"].overrides[0].rules,
-        ...import_eslint_plugin.default.configs.strict.rules,
+        ...pluginTs.configs["eslint-recommended"].overrides[0].rules,
+        ...pluginTs.configs.strict.rules,
         "antfu/generic-spacing": "error",
         "antfu/named-tuple-spacing": "error",
         "antfu/no-cjs-exports": "error",
@@ -1027,8 +1011,8 @@ function typescript(options) {
       }
     },
     {
-      files: ["**/*.d.ts"],
       name: "eslint:typescript:dts-overrides",
+      files: ["**/*.d.ts"],
       rules: {
         "eslint-comments/no-unlimited-disable": "off",
         "import/no-duplicates": "off",
@@ -1037,8 +1021,8 @@ function typescript(options) {
       }
     },
     {
-      files: ["**/*.{test,spec}.ts?(x)"],
       name: "eslint:typescript:tests-overrides",
+      files: ["**/*.{test,spec}.ts?(x)"],
       rules: {
         "no-unused-expressions": "off"
       }
@@ -1055,12 +1039,13 @@ function typescript(options) {
 }
 
 // src/configs/unicorn.ts
-function unicorn() {
+async function unicorn() {
+  const pluginUnicorn = await interopDefault(import("eslint-plugin-unicorn"));
   return [
     {
       name: "eslint:unicorn",
       plugins: {
-        unicorn: import_eslint_plugin_unicorn.default
+        unicorn: pluginUnicorn
       },
       rules: {
         // Pass error message when throwing errors
@@ -1095,34 +1080,41 @@ function unicorn() {
 }
 
 // src/configs/vue.ts
-function vue(options = {}) {
+async function vue(options = {}) {
+  const [pluginVue, parserVue] = await Promise.all([
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-vue")),
+    interopDefault(import("vue-eslint-parser"))
+  ]);
   return [
     {
       name: "eslint:vue:setup",
       plugins: {
-        vue: import_eslint_plugin_vue.default
+        vue: pluginVue
       }
     },
     {
+      name: "eslint:vue:rules",
       files: [GLOB_VUE],
       languageOptions: {
-        parser: import_vue_eslint_parser.default,
+        parser: parserVue,
         parserOptions: {
           ecmaFeatures: {
             jsx: true
           },
           extraFileExtensions: [".vue"],
-          parser: options.typescript ? parserTs : null,
+          parser: options.typescript ? await interopDefault(
+            import("@typescript-eslint/parser")
+          ) : null,
           sourceType: "module"
         }
       },
-      name: "eslint:vue:rules",
-      processor: import_eslint_plugin_vue.default.processors[".vue"],
+      processor: pluginVue.processors[".vue"],
       rules: {
-        ...import_eslint_plugin_vue.default.configs.base.rules,
-        ...import_eslint_plugin_vue.default.configs["vue3-essential"].rules,
-        ...import_eslint_plugin_vue.default.configs["vue3-strongly-recommended"].rules,
-        ...import_eslint_plugin_vue.default.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/block-order": [
           "error",
@@ -1228,7 +1220,11 @@ function vue(options = {}) {
 }
 
 // src/configs/yml.ts
-function yml() {
+async function yml() {
+  const [pluginYml, parserYml] = await Promise.all([
+    interopDefault(import("eslint-plugin-yml")),
+    interopDefault(import("yaml-eslint-parser"))
+  ]);
   return [
     {
       name: "eslint:yaml:setup",
@@ -1237,11 +1233,11 @@ function yml() {
       }
     },
     {
+      name: "eslint:yaml:rules",
       files: [GLOB_YAML],
       languageOptions: {
-        parser: import_yaml_eslint_parser.default
+        parser: parserYml
       },
-      name: "eslint:yaml:rules",
       rules: {
         ...pluginYml.configs.standard.rules,
         ...pluginYml.configs.prettier.rules,
@@ -1259,24 +1255,29 @@ function yml() {
 }
 
 // src/configs/test.ts
-function test() {
+async function test() {
+  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: "eslint:test:setup",
       plugins: {
         test: {
-          ...import_eslint_plugin_vitest.default,
+          ...pluginVitest,
           rules: {
-            ...import_eslint_plugin_vitest.default.rules,
+            ...pluginVitest.rules,
             // extend `test/no-only-tests` rule
-            ...import_eslint_plugin_no_only_tests.default.rules
+            ...pluginNoOnlyTests.rules
           }
         }
       }
     },
     {
-      files: GLOB_TESTS,
       name: "eslint:test:rules",
+      files: GLOB_TESTS,
       rules: {
         "test/consistent-test-it": [
           "error",
@@ -1292,28 +1293,37 @@ function test() {
 }
 
 // src/configs/perfectionist.ts
-function perfectionist() {
+async function perfectionist() {
+  const pluginPerfectionist = await interopDefault(
+    // @ts-expect-error missing types
+    import("eslint-plugin-perfectionist")
+  );
   return [
     {
       name: "eslint:perfectionist",
       plugins: {
-        perfectionist: import_eslint_plugin_perfectionist.default
+        perfectionist: pluginPerfectionist
       }
     }
   ];
 }
 
 // src/configs/prettier.ts
-function prettier(options) {
+async function prettier(options) {
+  const [pluginPrettier, configPrettier] = await Promise.all([
+    interopDefault(import("eslint-plugin-prettier")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-config-prettier"))
+  ]);
   return [
     {
       name: "eslint:prettier",
       plugins: {
-        prettier: import_eslint_plugin_prettier.default
+        prettier: pluginPrettier
       },
       rules: {
-        ...import_eslint_config_prettier.default.rules,
-        ...import_eslint_plugin_prettier.default.configs.recommended.rules,
+        ...configPrettier.rules,
+        ...pluginPrettier.configs.recommended.rules,
         "prettier/prettier": [
           "warn",
           {
@@ -1326,17 +1336,31 @@ function prettier(options) {
   ];
 }
 
-// src/utils.ts
-function combine(...configs) {
-  return configs.flat();
-}
-
 // src/configs/react.ts
-function next() {
+async function next() {
+  const pluginNext = await interopDefault(import("@next/eslint-plugin-next"));
   return [
     {
+      name: "eslint:next:setup",
       plugins: {
         "@next/next": pluginNext
+      }
+    },
+    {
+      name: "eslint:next:rules",
+      files: [GLOB_TSX, GLOB_JSX],
+      languageOptions: {
+        parserOptions: {
+          sourceType: "module",
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
       },
       rules: {
         ...pluginNext.configs.recommended.rules,
@@ -1345,45 +1369,69 @@ function next() {
     }
   ];
 }
-function react(options = {}) {
+async function react(options = {}) {
   const { next: enableNext = false } = options;
-  const _react = {
-    name: "eslint:react",
-    plugins: {
-      "react": import_eslint_plugin_react.default,
-      "react-hooks": import_eslint_plugin_react_hooks.default
-    },
-    settings: {
-      react: {
-        version: "18.0"
+  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"))
+  ]);
+  const _react = [
+    {
+      name: "eslint:react:setup",
+      plugins: {
+        "react": pluginReact,
+        "react-hooks": pluginReactHooks
       }
     },
-    rules: {
-      ...import_eslint_plugin_react.default.configs.recommended.rules,
-      ...import_eslint_plugin_react_hooks.default.configs.recommended.rules,
-      "jsx-quotes": ["error", "prefer-double"],
-      "react/react-in-jsx-scope": "off",
-      "react/jsx-indent": [1, 2],
-      "react/jsx-indent-props": [1, 2],
-      "react/jsx-closing-bracket-location": [
-        1,
-        { selfClosing: "tag-aligned", nonEmpty: "tag-aligned" }
-      ]
+    {
+      name: "eslint:react:rules",
+      files: [GLOB_TSX, GLOB_JSX],
+      languageOptions: {
+        parserOptions: {
+          sourceType: "module",
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
+      },
+      rules: {
+        ...pluginReact.configs.recommended.rules,
+        ...pluginReactHooks.configs.recommended.rules,
+        "jsx-quotes": ["error", "prefer-double"],
+        "react/react-in-jsx-scope": "off",
+        "react/jsx-indent": [1, 2],
+        "react/jsx-indent-props": [1, 2],
+        "react/jsx-closing-bracket-location": [
+          1,
+          { selfClosing: "tag-aligned", nonEmpty: "tag-aligned" }
+        ]
+      }
     }
-  };
+  ];
   return combine(_react, enableNext ? next() : []);
 }
 
 // src/configs/tailwindcss.ts
-function tailwindcss() {
+async function tailwindcss() {
+  const pluginTailwindcss = await interopDefault(
+    // @ts-expect-error missing types
+    import("eslint-plugin-tailwindcss")
+  );
   return [
     {
       name: "eslint:tailwindcss",
       plugins: {
-        tailwindcss: import_eslint_plugin_tailwindcss.default
+        tailwindcss: pluginTailwindcss
       },
       rules: {
-        ...import_eslint_plugin_tailwindcss.default.configs.recommended.rules
+        ...pluginTailwindcss.configs.recommended.rules
       }
     }
   ];
@@ -1490,39 +1538,15 @@ var src_default = config;
   combine,
   comments,
   config,
-  configPrettier,
   ignores,
   imports,
+  interopDefault,
   javascript,
   jsdoc,
   jsonc,
   markdown,
   node,
-  parserJsonc,
-  parserTs,
-  parserVue,
-  parserYml,
   perfectionist,
-  pluginAntfu,
-  pluginComments,
-  pluginImport,
-  pluginJsdoc,
-  pluginJsonc,
-  pluginMarkdown,
-  pluginNext,
-  pluginNoOnlyTests,
-  pluginNode,
-  pluginPerfectionist,
-  pluginPrettier,
-  pluginReact,
-  pluginReactHooks,
-  pluginTailwindcss,
-  pluginTs,
-  pluginUnicorn,
-  pluginUnusedImports,
-  pluginVitest,
-  pluginVue,
-  pluginYml,
   prettier,
   sortPackageJson,
   sortTsconfig,