@so1ve/eslint-config 0.123.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,1589 @@
+import pluginComments from '@eslint-community/eslint-plugin-eslint-comments';
+export { default as pluginComments } from '@eslint-community/eslint-plugin-eslint-comments';
+import pluginHtml from '@html-eslint/eslint-plugin';
+export { default as pluginHtml } from '@html-eslint/eslint-plugin';
+import parserHtml from '@html-eslint/parser';
+export { default as parserHtml } from '@html-eslint/parser';
+import pluginSo1ve from '@so1ve/eslint-plugin';
+export { default as pluginSo1ve } from '@so1ve/eslint-plugin';
+import pluginSortImports from '@so1ve/eslint-plugin-sort-imports';
+export { default as pluginSortImports } from '@so1ve/eslint-plugin-sort-imports';
+import pluginTs from '@typescript-eslint/eslint-plugin';
+export { default as pluginTs } from '@typescript-eslint/eslint-plugin';
+import parserTs from '@typescript-eslint/parser';
+export { default as parserTs } from '@typescript-eslint/parser';
+export { default as parserMdx } from 'eslint-mdx';
+import pluginArrayFunc from 'eslint-plugin-array-func';
+export { default as pluginArrayFunc } from 'eslint-plugin-array-func';
+import pluginEtc from 'eslint-plugin-etc';
+export { default as pluginEtc } from 'eslint-plugin-etc';
+import pluginHtmlJsSupport from 'eslint-plugin-html';
+export { default as pluginHtmlJsSupport } from 'eslint-plugin-html';
+import pluginImport from 'eslint-plugin-i';
+export { default as pluginImport } from 'eslint-plugin-i';
+import pluginJestFormatting from 'eslint-plugin-jest-formatting';
+export { default as pluginJestFormatting } from 'eslint-plugin-jest-formatting';
+import pluginJsonSchemaValidator from 'eslint-plugin-json-schema-validator';
+export { default as pluginJsonSchemaValidator } from 'eslint-plugin-json-schema-validator';
+import pluginJsonc from 'eslint-plugin-jsonc';
+export { default as pluginJsonc } from 'eslint-plugin-jsonc';
+import pluginMdx from 'eslint-plugin-mdx';
+export { default as pluginMdx } from 'eslint-plugin-mdx';
+import pluginNode from 'eslint-plugin-n';
+export { default as pluginNode } from 'eslint-plugin-n';
+import pluginNoOnlyTests from 'eslint-plugin-no-only-tests';
+export { default as pluginNoOnlyTests } from 'eslint-plugin-no-only-tests';
+import pluginOnlyError from 'eslint-plugin-only-error';
+export { default as pluginOnlyError } from 'eslint-plugin-only-error';
+import pluginPromise from 'eslint-plugin-promise';
+export { default as pluginPromise } from 'eslint-plugin-promise';
+import pluginRegexp from 'eslint-plugin-regexp';
+export { default as pluginRegexp } from 'eslint-plugin-regexp';
+import pluginSolid from 'eslint-plugin-solid';
+export { default as pluginSolid } from 'eslint-plugin-solid';
+import pluginToml from 'eslint-plugin-toml';
+export { default as pluginToml } from 'eslint-plugin-toml';
+import pluginUnicorn from 'eslint-plugin-unicorn';
+export { default as pluginUnicorn } from 'eslint-plugin-unicorn';
+import pluginUnusedImports from 'eslint-plugin-unused-imports';
+export { default as pluginUnusedImports } from 'eslint-plugin-unused-imports';
+import pluginVitest from 'eslint-plugin-vitest';
+export { default as pluginVitest } from 'eslint-plugin-vitest';
+import pluginVue from 'eslint-plugin-vue';
+export { default as pluginVue } from 'eslint-plugin-vue';
+import pluginYaml from 'eslint-plugin-yml';
+export { default as pluginYaml } from 'eslint-plugin-yml';
+import parserJsonc from 'jsonc-eslint-parser';
+export { default as parserJsonc } from 'jsonc-eslint-parser';
+import parserToml from 'toml-eslint-parser';
+export { default as parserToml } from 'toml-eslint-parser';
+import parserVue from 'vue-eslint-parser';
+export { default as parserVue } from 'vue-eslint-parser';
+import parserYaml from 'yaml-eslint-parser';
+export { default as parserYaml } from 'yaml-eslint-parser';
+import globals from 'globals';
+import fs from 'node:fs';
+import gitignore from 'eslint-config-flat-gitignore';
+import { isPackageExists } from 'local-pkg';
+
+const comments = () => [
+  {
+    plugins: {
+      "eslint-comments": pluginComments
+    }
+  },
+  {
+    rules: {
+      "eslint-comments/no-aggregating-enable": "error",
+      "eslint-comments/no-duplicate-disable": "error",
+      "eslint-comments/no-unused-enable": "error",
+      "eslint-comments/disable-enable-pair": "off",
+      "eslint-comments/no-unlimited-disable": "off"
+    }
+  }
+];
+
+const GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+const GLOB_SRC = `**/*.${GLOB_SRC_EXT}`;
+const GLOB_JS = "**/*.?([cm])js";
+const GLOB_JSX = "**/*.?([cm])jsx";
+const GLOB_TS = "**/*.?([cm])ts";
+const GLOB_TSX = "**/*.?([cm])tsx";
+const GLOB_DTS = "**/*.d.?([cm])tsx";
+const GLOB_STYLE = "**/*.{c,le,sc}ss";
+const GLOB_CSS = "**/*.css";
+const GLOB_LESS = "**/*.less";
+const GLOB_SCSS = "**/*.scss";
+const GLOB_JSON = "**/*.json";
+const GLOB_JSON5 = "**/*.json5";
+const GLOB_JSONC = "**/*.jsonc";
+const GLOB_ESLINTRC = "**/.eslintrc";
+const GLOB_MARKDOWN = "**/*.md?(x)";
+const GLOB_VUE = "**/*.vue";
+const GLOB_YAML = "**/*.y?(a)ml";
+const GLOB_TOML = "**/*.toml";
+const GLOB_HTML = "**/*.htm?(l)";
+const GLOB_PACKAGEJSON = "**/package.json";
+const GLOB_TSCONFIG = ["**/tsconfig.json", "**/tsconfig.*.json"];
+const GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
+const GLOB_TESTS = [
+  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
+  `**/*.spec.${GLOB_SRC_EXT}`,
+  `**/*.test.${GLOB_SRC_EXT}`,
+  `**/*.bench.${GLOB_SRC_EXT}`,
+  `**/*.benchmark.${GLOB_SRC_EXT}`
+];
+const GLOB_ALL_SRC = [
+  GLOB_SRC,
+  GLOB_STYLE,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_ESLINTRC,
+  GLOB_MARKDOWN,
+  GLOB_VUE,
+  GLOB_YAML,
+  GLOB_HTML
+];
+const GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/out",
+  "**/output",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/coverage",
+  "**/temp",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.nitro",
+  "**/.vercel",
+  "**/.netlify",
+  "**/.output",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.vite-inspect",
+  "**/.yarn",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts",
+  // Volar
+  "**/*.vue.js",
+  "**/*.vue.jsx",
+  "**/*.vue.ts",
+  "**/*.vue.tsx"
+];
+
+const formatting = (options) => {
+  var _a, _b;
+  return [
+    {
+      rules: {
+        "so1ve/no-useless-template-string": "error",
+        "so1ve/no-negated-comparison": "error",
+        "so1ve/no-import-promises-as": "error",
+        "so1ve/pad-after-last-import": "error",
+        "so1ve/function-style": "error",
+        "quote-props": ["error", "consistent-as-needed"],
+        "padding-line-between-statements": [
+          "error",
+          { blankLine: "always", prev: "*", next: "return" }
+        ]
+      }
+    },
+    ((_a = options.jsonc) != null ? _a : true) && [
+      {
+        files: [GLOB_PACKAGEJSON],
+        rules: {
+          "jsonc/sort-keys": [
+            "error",
+            {
+              pathPattern: "^exports$",
+              order: { type: "asc" }
+            },
+            {
+              pathPattern: "^exports.*$",
+              order: ["types", "require", "import", "default"]
+            }
+          ]
+        }
+      },
+      {
+        files: GLOB_TSCONFIG,
+        rules: {
+          "jsonc/sort-keys": [
+            "error",
+            {
+              order: [
+                "extends",
+                "compilerOptions",
+                "references",
+                "files",
+                "include",
+                "exclude"
+              ],
+              pathPattern: "^$"
+            },
+            {
+              order: [
+                /* Projects */
+                "incremental",
+                "composite",
+                "tsBuildInfoFile",
+                "disableSourceOfProjectReferenceRedirect",
+                "disableSolutionSearching",
+                "disableReferencedProjectLoad",
+                /* Language and Environment */
+                "target",
+                "jsx",
+                "jsxFactory",
+                "jsxFragmentFactory",
+                "jsxImportSource",
+                "lib",
+                "moduleDetection",
+                "noLib",
+                "reactNamespace",
+                "useDefineForClassFields",
+                "emitDecoratorMetadata",
+                "experimentalDecorators",
+                /* Modules */
+                "baseUrl",
+                "rootDir",
+                "rootDirs",
+                "customConditions",
+                "module",
+                "moduleResolution",
+                "moduleSuffixes",
+                "noResolve",
+                "paths",
+                "resolveJsonModule",
+                "resolvePackageJsonExports",
+                "resolvePackageJsonImports",
+                "typeRoots",
+                "types",
+                "allowArbitraryExtensions",
+                "allowImportingTsExtensions",
+                "allowUmdGlobalAccess",
+                /* JavaScript Support */
+                "allowJs",
+                "checkJs",
+                "maxNodeModuleJsDepth",
+                /* Type Checking */
+                "strict",
+                "strictBindCallApply",
+                "strictFunctionTypes",
+                "strictNullChecks",
+                "strictPropertyInitialization",
+                "allowUnreachableCode",
+                "allowUnusedLabels",
+                "alwaysStrict",
+                "exactOptionalPropertyTypes",
+                "noFallthroughCasesInSwitch",
+                "noImplicitAny",
+                "noImplicitOverride",
+                "noImplicitReturns",
+                "noImplicitThis",
+                "noPropertyAccessFromIndexSignature",
+                "noUncheckedIndexedAccess",
+                "noUnusedLocals",
+                "noUnusedParameters",
+                "useUnknownInCatchVariables",
+                /* Emit */
+                "declaration",
+                "declarationDir",
+                "declarationMap",
+                "downlevelIteration",
+                "emitBOM",
+                "emitDeclarationOnly",
+                "importHelpers",
+                "importsNotUsedAsValues",
+                "inlineSourceMap",
+                "inlineSources",
+                "mapRoot",
+                "newLine",
+                "noEmit",
+                "noEmitHelpers",
+                "noEmitOnError",
+                "outDir",
+                "outFile",
+                "preserveConstEnums",
+                "preserveValueImports",
+                "removeComments",
+                "sourceMap",
+                "sourceRoot",
+                "stripInternal",
+                /* Interop Constraints */
+                "allowSyntheticDefaultImports",
+                "esModuleInterop",
+                "forceConsistentCasingInFileNames",
+                "isolatedModules",
+                "preserveSymlinks",
+                "verbatimModuleSyntax",
+                /* Completeness */
+                "skipDefaultLibCheck",
+                "skipLibCheck"
+              ],
+              pathPattern: "^compilerOptions$"
+            }
+          ]
+        }
+      }
+    ],
+    ((_b = options.test) != null ? _b : true) && {
+      files: GLOB_TESTS,
+      rules: {
+        "jest-formatting/padding-around-all": "error"
+      }
+    }
+  ].flat().filter(Boolean);
+};
+
+const html = () => [
+  {
+    plugins: {
+      "html": pluginHtml,
+      "html-js-support": pluginHtmlJsSupport
+    }
+  },
+  {
+    languageOptions: {
+      parser: parserHtml
+    },
+    settings: {
+      "html/report-bad-indent": "off"
+    },
+    files: [GLOB_HTML],
+    rules: {
+      ...pluginHtml.configs.recommended.rules,
+      "html/indent": "off",
+      "html/no-trailing-spaces": "off",
+      "html/require-closing-tags": "off",
+      "html/no-extra-spacing-attrs": "off",
+      "html/quotes": "off"
+    }
+  }
+];
+
+const ignores = () => [
+  { ignores: GLOB_EXCLUDE }
+];
+
+const imports = (options = {}) => [
+  {
+    plugins: {
+      import: pluginImport
+    }
+  },
+  {
+    settings: {
+      "import/parsers": {
+        espree: [".js", ".cjs", ".mjs", ".jsx"]
+      },
+      "import/resolver": {
+        ...options.typescript ? {
+          node: {
+            extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".d.ts"]
+          },
+          typescript: {
+            extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".d.ts"]
+          }
+        } : {
+          node: { extensions: [".js", ".mjs"] }
+        }
+      }
+    },
+    rules: {
+      ...pluginImport.configs.recommended.rules,
+      "import/first": "error",
+      "import/no-mutable-exports": "error",
+      "import/no-useless-path-segments": ["error", { noUselessIndex: true }],
+      "import/no-unresolved": "off",
+      "import/no-absolute-path": "off",
+      "import/namespace": "off",
+      // Disable this for better performance
+      "import/export": "error",
+      "import/no-duplicates": "error",
+      "import/no-named-default": "error",
+      "import/no-webpack-loader-syntax": "error",
+      "import/no-named-as-default-member": "off"
+    }
+  },
+  {
+    files: [GLOB_DTS],
+    rules: {
+      "import/no-duplicates": "off"
+    }
+  }
+];
+
+const javascript = ({
+  overrides
+} = {}) => [
+  {
+    plugins: {
+      "so1ve": pluginSo1ve,
+      "unused-imports": pluginUnusedImports,
+      "sort-imports": pluginSortImports,
+      "array-func": pluginArrayFunc,
+      "json-schema-validator": pluginJsonSchemaValidator,
+      "regexp": pluginRegexp
+    }
+  },
+  {
+    languageOptions: {
+      ecmaVersion: 2022,
+      globals: {
+        ...globals.browser,
+        ...globals.es2021,
+        ...globals.node,
+        document: "readonly",
+        navigator: "readonly",
+        window: "readonly"
+      },
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        },
+        ecmaVersion: 2022,
+        sourceType: "module"
+      },
+      sourceType: "module"
+    },
+    rules: {
+      // Common
+      "array-bracket-newline": "off",
+      "array-element-newline": "off",
+      "arrow-body-style": "off",
+      "arrow-parens": "off",
+      "dot-notation": ["error", { allowKeywords: true }],
+      "function-call-argument-newline": "off",
+      "function-paren-newline": "off",
+      "generator-star": "off",
+      "implicit-arrow-linebreak": "off",
+      "indent": "off",
+      "indent-legacy": "off",
+      "jsx-quotes": "off",
+      "linebreak-style": "off",
+      "newline-per-chained-call": "off",
+      "no-arrow-condition": "off",
+      "no-comma-dangle": "off",
+      "no-confusing-arrow": "off",
+      "no-extra-semi": "off",
+      "no-reserved-keys": "off",
+      "no-spaced-func": "off",
+      "no-space-before-semi": "off",
+      "no-wrap-func": "off",
+      "nonblock-statement-body-position": "off",
+      "one-var-declaration-per-line": "off",
+      "switch-colon-spacing": "off",
+      "symbol-description": "off",
+      "wrap-regex": "off",
+      "unused-imports/no-unused-imports": "error",
+      "unused-imports/no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          varsIgnorePattern: "^_",
+          args: "after-used",
+          argsIgnorePattern: "^_"
+        }
+      ],
+      "accessor-pairs": [
+        "error",
+        { setWithoutGet: true, enforceForClassMembers: true }
+      ],
+      "constructor-super": "error",
+      "default-case-last": "error",
+      "lines-between-class-members": [
+        "error",
+        "always",
+        { exceptAfterSingleLine: true }
+      ],
+      "new-cap": [
+        "error",
+        { newIsCap: true, capIsNew: false, properties: true }
+      ],
+      "no-array-constructor": "error",
+      "no-async-promise-executor": "error",
+      "no-caller": "error",
+      "no-class-assign": "error",
+      "no-compare-neg-zero": "error",
+      "no-const-assign": "error",
+      "no-control-regex": "error",
+      "no-delete-var": "error",
+      "no-dupe-args": "error",
+      "no-dupe-class-members": "error",
+      "no-dupe-keys": "error",
+      "no-duplicate-case": "error",
+      "no-useless-backreference": "error",
+      "no-useless-call": "error",
+      "no-useless-computed-key": "error",
+      "no-useless-constructor": "error",
+      "no-useless-rename": "error",
+      "no-useless-return": "error",
+      "no-void": "error",
+      "no-empty": ["error", { allowEmptyCatch: true }],
+      "no-empty-character-class": "error",
+      "no-empty-pattern": "error",
+      "no-eval": "error",
+      "no-ex-assign": "error",
+      "no-extend-native": "error",
+      "no-extra-bind": "error",
+      "no-extra-boolean-cast": "error",
+      "no-extra-parens": ["error", "functions"],
+      "no-fallthrough": "error",
+      "no-func-assign": "error",
+      "no-global-assign": "error",
+      "no-implied-eval": "error",
+      "no-import-assign": "error",
+      "no-invalid-regexp": "error",
+      "no-irregular-whitespace": "error",
+      "no-iterator": "error",
+      "no-labels": ["error", { allowLoop: true, allowSwitch: false }],
+      "no-lone-blocks": "error",
+      "no-loss-of-precision": "error",
+      "no-misleading-character-class": "error",
+      "no-new-func": "error",
+      "no-new-object": "error",
+      "no-new-symbol": "error",
+      "no-new-wrappers": "error",
+      "no-prototype-builtins": "error",
+      "no-useless-catch": "error",
+      "no-param-reassign": "off",
+      "no-constant-condition": "error",
+      "no-debugger": "error",
+      "no-console": ["error", { allow: ["error", "warn", "table", "time"] }],
+      "no-cond-assign": ["error", "always"],
+      "no-restricted-syntax": [
+        "error",
+        "DebuggerStatement",
+        "LabeledStatement",
+        "WithStatement"
+      ],
+      "no-restricted-globals": [
+        "error",
+        { name: "global", message: "Use `globalThis` instead." },
+        { name: "self", message: "Use `globalThis` instead." },
+        { name: "isNaN", message: "Use `Number.isNaN` instead" },
+        { name: "isFinite", message: "Use `Number.isFinite` instead" },
+        { name: "parseFloat", message: "Use `Number.parseFloat` instead" },
+        { name: "parseInt", message: "Use `Number.parseInt` instead" }
+      ],
+      "no-restricted-properties": [
+        "error",
+        {
+          object: "globalThis",
+          property: "isNaN",
+          message: "Use `Number.isNaN` instead"
+        },
+        {
+          object: "globalThis",
+          property: "isFinite",
+          message: "Use `Number.isFinite` instead"
+        },
+        {
+          object: "globalThis",
+          property: "parseFloat",
+          message: "Use `Number.parseFloat` instead"
+        },
+        {
+          object: "globalThis",
+          property: "parseInt",
+          message: "Use `Number.parseInt` instead"
+        },
+        {
+          object: "window",
+          property: "isNaN",
+          message: "Use `Number.isNaN` instead"
+        },
+        {
+          object: "window",
+          property: "isFinite",
+          message: "Use `Number.isFinite` instead"
+        },
+        {
+          object: "window",
+          property: "parseFloat",
+          message: "Use `Number.parseFloat` instead"
+        },
+        {
+          object: "window",
+          property: "parseInt",
+          message: "Use `Number.parseInt` instead"
+        }
+      ],
+      "no-obj-calls": "error",
+      "no-octal": "error",
+      "no-octal-escape": "error",
+      "no-proto": "error",
+      "no-redeclare": ["error", { builtinGlobals: false }],
+      "no-regex-spaces": "error",
+      "no-self-assign": ["error", { props: true }],
+      "no-self-compare": "error",
+      "no-sequences": "error",
+      "no-shadow-restricted-names": "error",
+      "no-template-curly-in-string": "error",
+      "no-this-before-super": "error",
+      "no-throw-literal": "error",
+      "no-undef": "error",
+      "no-undef-init": "error",
+      "no-unexpected-multiline": "error",
+      "no-unmodified-loop-condition": "error",
+      "no-unneeded-ternary": ["error", { defaultAssignment: false }],
+      "no-unreachable": "error",
+      "no-unreachable-loop": "error",
+      "no-unsafe-finally": "error",
+      "no-unsafe-negation": "error",
+      "no-return-await": "off",
+      // es6
+      "no-var": "error",
+      "prefer-const": [
+        "error",
+        {
+          destructuring: "all",
+          ignoreReadBeforeAssign: true
+        }
+      ],
+      "prefer-arrow-callback": [
+        "error",
+        {
+          allowNamedFunctions: false,
+          allowUnboundThis: true
+        }
+      ],
+      "one-var": ["error", "never"],
+      "object-shorthand": [
+        "error",
+        "always",
+        {
+          ignoreConstructors: false
+        }
+      ],
+      "prefer-exponentiation-operator": "error",
+      "prefer-rest-params": "error",
+      "prefer-spread": "error",
+      "prefer-template": "error",
+      "prefer-promise-reject-errors": "error",
+      "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+      "yoda": ["error", "never"],
+      "spaced-comment": [
+        "error",
+        "always",
+        {
+          line: {
+            markers: ["/"],
+            exceptions: ["/", "#"]
+          },
+          block: {
+            markers: ["!"],
+            exceptions: ["*"],
+            balanced: true
+          }
+        }
+      ],
+      // best-practice
+      "array-callback-return": "error",
+      "block-scoped-var": "error",
+      "no-unused-expressions": [
+        "error",
+        {
+          allowShortCircuit: true,
+          allowTernary: true,
+          allowTaggedTemplates: true
+        }
+      ],
+      "no-unused-vars": [
+        "error",
+        {
+          args: "none",
+          caughtErrors: "none",
+          ignoreRestSiblings: true,
+          vars: "all"
+        }
+      ],
+      "no-use-before-define": [
+        "error",
+        { functions: false, classes: false, variables: true }
+      ],
+      "consistent-return": "off",
+      "complexity": ["off", 11],
+      "eqeqeq": ["error", "smart"],
+      "no-alert": "error",
+      "no-case-declarations": "error",
+      "no-multi-str": "error",
+      "no-with": "error",
+      "no-invalid-this": "error",
+      "vars-on-top": "error",
+      "require-await": "off",
+      "use-isnan": [
+        "error",
+        {
+          enforceForSwitchCase: true,
+          enforceForIndexOf: true
+        }
+      ],
+      "valid-typeof": ["error", { requireStringLiterals: true }],
+      // so1ve
+      "so1ve/import-dedupe": "error",
+      "so1ve/use-async-with-await": "error",
+      // Sort Imports
+      "sort-imports/imports": ["error"],
+      "sort-imports/exports": "error",
+      // array-func
+      "array-func/prefer-array-from": "off",
+      // json-schema-validator
+      "json-schema-validator/no-invalid": "warn",
+      // regexp
+      "regexp/no-unused-capturing-group": "warn",
+      ...overrides
+    }
+  },
+  {
+    files: [`scripts/${GLOB_SRC}`, `cli.${GLOB_SRC_EXT}`],
+    rules: {
+      "no-console": "off"
+    }
+  }
+];
+
+const jsonc = () => [
+  {
+    plugins: {
+      jsonc: pluginJsonc
+    }
+  },
+  {
+    files: [GLOB_JSON, GLOB_JSON5, GLOB_JSONC, GLOB_ESLINTRC],
+    languageOptions: {
+      parser: parserJsonc
+    },
+    rules: {
+      ...pluginJsonc.configs.base.overrides[0].rules,
+      ...pluginJsonc.configs["recommended-with-jsonc"].rules,
+      "jsonc/no-octal-escape": "error",
+      "jsonc/quotes": "off",
+      "jsonc/quotes-props": "off"
+    }
+  }
+];
+
+const mdx = ({
+  componentExts = [],
+  overrides
+} = {}) => [
+  {
+    ...pluginMdx.flat,
+    processor: pluginMdx.createRemarkProcessor({
+      lintCodeBlocks: true,
+      languageMapper: {}
+    })
+  },
+  {
+    ...pluginMdx.flatCodeBlocks,
+    files: [
+      ...pluginMdx.flatCodeBlocks.files,
+      ...componentExts.map((ext) => `${GLOB_MARKDOWN}/*.${ext}`)
+    ],
+    rules: {
+      ...pluginMdx.flatCodeBlocks.rules,
+      "html/require-doctype": "off",
+      "ts/no-redeclare": "off",
+      "ts/no-unused-vars": "off",
+      "ts/no-use-before-define": "off",
+      "ts/no-var-requires": "off",
+      "ts/consistent-type-imports": "off",
+      "ts/no-namespace": "off",
+      "ts/no-require-imports": "off",
+      "import/no-unresolved": "off",
+      "unused-imports/no-unused-imports": "off",
+      "unused-imports/no-unused-vars": "off",
+      "no-alert": "off",
+      "no-console": "off",
+      "no-restricted-imports": "off",
+      "no-undef": "off",
+      "no-unused-expressions": "off",
+      ...overrides
+    }
+  }
+];
+
+const node = () => [
+  {
+    plugins: {
+      node: pluginNode
+    }
+  },
+  {
+    rules: {
+      "node/no-callback-literal": "off",
+      "node/handle-callback-err": ["error", "^(err|error)$"],
+      "node/no-deprecated-api": "error",
+      "node/no-exports-assign": "error",
+      "node/no-new-require": "error",
+      "node/no-path-concat": "error",
+      "node/process-exit-as-throw": "error"
+    }
+  }
+];
+
+const onlyError = () => [
+  {
+    plugins: {
+      "only-error": pluginOnlyError
+    }
+  }
+];
+
+const promise = () => [
+  {
+    plugins: {
+      promise: pluginPromise
+    }
+  },
+  {
+    rules: {
+      "promise/param-names": "error"
+    }
+  }
+];
+
+const solid = ({
+  overrides,
+  typescript
+} = {}) => [
+  {
+    plugins: {
+      solid: pluginSolid
+    }
+  },
+  {
+    languageOptions: {
+      sourceType: "module",
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        }
+      }
+    },
+    rules: {
+      ...pluginSolid.configs.recommended.rules,
+      ...typescript ? pluginSolid.configs.typescript.rules : {},
+      ...overrides
+    }
+  }
+];
+
+const sortImports = () => [
+  {
+    plugins: {
+      "sort-imports": pluginSortImports
+    }
+  },
+  {
+    rules: {
+      "sort-imports/imports": "error",
+      "sort-imports/exports": "error"
+    }
+  }
+];
+
+const test = ({
+  overrides
+} = {}) => [
+  {
+    plugins: {
+      "no-only-tests": pluginNoOnlyTests,
+      "vitest": pluginVitest,
+      "jest-formatting": pluginJestFormatting
+    }
+  },
+  {
+    files: GLOB_TESTS,
+    rules: {
+      ...pluginVitest.configs.recommended.rules,
+      "no-only-tests/no-only-tests": "error",
+      "vitest/expect-expect": "off",
+      "vitest/valid-describe-callback": "off",
+      "vitest/no-alias-methods": "error",
+      "vitest/no-interpolation-in-snapshots": "error",
+      "vitest/no-test-prefixes": "error",
+      "vitest/prefer-expect-resolves": "error",
+      "vitest/prefer-comparison-matcher": "error",
+      "vitest/prefer-mock-promise-shorthand": "error",
+      "vitest/prefer-spy-on": "error",
+      "vitest/prefer-to-be-falsy": "error",
+      "vitest/prefer-to-be-object": "error",
+      "vitest/prefer-to-be-truthy": "error",
+      "vitest/prefer-to-contain": "error",
+      "vitest/prefer-to-have-length": "error",
+      "vitest/prefer-todo": "error",
+      "vitest/valid-title": ["error", { allowArguments: true }],
+      ...overrides
+    }
+  }
+];
+
+const toml = ({
+  overrides
+} = {}) => [
+  {
+    plugins: {
+      toml: pluginToml
+    }
+  },
+  {
+    languageOptions: {
+      parser: parserToml
+    },
+    files: [GLOB_TOML],
+    rules: {
+      ...pluginToml.configs.recommended.rules,
+      "no-irregular-whitespace": "off",
+      "spaced-comment": "off",
+      ...overrides
+    }
+  }
+];
+
+const combine = (...configs) => configs.flatMap((config) => Array.isArray(config) ? config : [config]);
+const renameRules = (rules, from, to) => Object.fromEntries(
+  Object.entries(rules).map(([key, value]) => {
+    if (key.startsWith(from)) {
+      return [to + key.slice(from.length), value];
+    }
+    return [key, value];
+  })
+);
+const rulesOn = /* @__PURE__ */ new Set();
+const rulesOff = /* @__PURE__ */ new Set();
+function recordRulesStateConfigs(configs) {
+  var _a;
+  for (const config of configs) {
+    recordRulesState((_a = config.rules) != null ? _a : {});
+  }
+  return configs;
+}
+function recordRulesState(rules) {
+  for (const [key, value] of Object.entries(rules != null ? rules : {})) {
+    const firstValue = Array.isArray(value) ? value[0] : value;
+    if (firstValue == null) {
+      continue;
+    }
+    if (firstValue === "off" || firstValue === 0) {
+      rulesOff.add(key);
+    } else {
+      rulesOn.add(key);
+    }
+  }
+  return rules;
+}
+function warnUnnecessaryOffRules() {
+  const unnecessaryOffRules = [...rulesOff].filter((key) => !rulesOn.has(key));
+  for (const off of unnecessaryOffRules) {
+    console.warn(
+      `[eslint] rule \`${off}\` is never turned on, you can remove the rule from your config`
+    );
+  }
+}
+
+function typescript({
+  componentExts = [],
+  parserOptions,
+  overrides
+} = {}) {
+  const typeAwareRules = {
+    "etc/no-assign-mutated-array": "error",
+    "etc/no-deprecated": "warn",
+    "etc/no-internal": "error",
+    "no-throw-literal": "off",
+    "ts/no-throw-literal": "error",
+    "no-implied-eval": "off",
+    "ts/no-implied-eval": "error",
+    "dot-notation": "off",
+    "ts/dot-notation": ["error", { allowKeywords: true }],
+    "no-void": ["error", { allowAsStatement: true }],
+    "ts/await-thenable": "error",
+    "ts/no-for-in-array": "error",
+    "ts/no-unnecessary-type-assertion": "error",
+    "ts/restrict-template-expressions": [
+      "error",
+      {
+        allowAny: true,
+        allowNumber: true,
+        allowBoolean: true
+      }
+    ],
+    "ts/array-type": ["error", { default: "array", readonly: "array" }],
+    "ts/consistent-generic-constructors": "error",
+    "ts/consistent-type-exports": "error",
+    "ts/consistent-type-assertions": [
+      "error",
+      { assertionStyle: "as", objectLiteralTypeAssertions: "allow" }
+    ],
+    "ts/prefer-nullish-coalescing": "error",
+    "ts/prefer-optional-chain": "error",
+    "ts/prefer-return-this-type": "error",
+    "ts/no-unnecessary-type-arguments": "error",
+    "ts/non-nullable-type-assertion-style": "error"
+  };
+  return [
+    {
+      // Install the plugins without globs, so they can be configured separately.
+      plugins: {
+        import: pluginImport,
+        ts: pluginTs,
+        etc: pluginEtc
+      }
+    },
+    {
+      files: [GLOB_TS, GLOB_TSX, ...componentExts.map((ext) => `**/*.${ext}`)],
+      languageOptions: {
+        parser: parserTs,
+        parserOptions: {
+          sourceType: "module",
+          extraFileExtensions: componentExts.map((ext) => `.${ext}`),
+          EXPERIMENTAL_useProjectService: true,
+          ...parserOptions
+        }
+      },
+      settings: {
+        "import/resolver": {
+          node: { extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".d.ts"] },
+          typescript: {
+            extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".d.ts"]
+          }
+        }
+      },
+      rules: {
+        ...renameRules(
+          pluginTs.configs["eslint-recommended"].overrides[0].rules,
+          "@typescript-eslint/",
+          "ts/"
+        ),
+        ...renameRules(
+          pluginTs.configs.recommended.rules,
+          "@typescript-eslint/",
+          "ts/"
+        ),
+        "import/named": "off",
+        // TS
+        "ts/comma-dangle": "off",
+        "ts/brace-style": "off",
+        "ts/comma-spacing": "off",
+        "ts/func-call-spacing": "off",
+        "ts/indent": "off",
+        "ts/keyword-spacing": "off",
+        "ts/member-delimiter-style": "off",
+        "ts/no-extra-parens": "off",
+        "ts/no-extra-semi": "off",
+        "ts/quotes": "off",
+        "ts/semi": "off",
+        "ts/space-before-function-paren": "off",
+        "ts/type-annotation-spacing": "off",
+        "ts/ban-ts-comment": [
+          "error",
+          {
+            minimumDescriptionLength: 0
+          }
+        ],
+        "ts/ban-types": [
+          "error",
+          {
+            extendDefaults: false,
+            types: {
+              String: {
+                message: "Use `string` instead.",
+                fixWith: "string"
+              },
+              Number: {
+                message: "Use `number` instead.",
+                fixWith: "number"
+              },
+              Boolean: {
+                message: "Use `boolean` instead.",
+                fixWith: "boolean"
+              },
+              Symbol: {
+                message: "Use `symbol` instead.",
+                fixWith: "symbol"
+              },
+              BigInt: {
+                message: "Use `bigint` instead.",
+                fixWith: "bigint"
+              },
+              Object: {
+                message: "The `Object` type is mostly the same as `unknown`. You probably want `Record<PropertyKey, unknown>` instead. See https://github.com/typescript-eslint/typescript-eslint/pull/848",
+                fixWith: "Record<PropertyKey, unknown>"
+              },
+              object: {
+                message: "The `object` type is hard to use. Use `Record<PropertyKey, unknown>` instead. See: https://github.com/typescript-eslint/typescript-eslint/pull/848",
+                fixWith: "Record<PropertyKey, unknown>"
+              },
+              Function: {
+                message: "Use `(...args: any[]) => any` instead.",
+                fixWith: "(...args: any[]) => any"
+              }
+            }
+          }
+        ],
+        "ts/consistent-type-imports": [
+          "error",
+          { prefer: "type-imports", disallowTypeAnnotations: false }
+        ],
+        "ts/consistent-type-definitions": ["error", "interface"],
+        "ts/consistent-indexed-object-style": ["error", "record"],
+        "ts/prefer-ts-expect-error": "error",
+        "ts/no-require-imports": "error",
+        "ts/method-signature-style": ["error", "property"],
+        // Override JS
+        "no-useless-constructor": "off",
+        "no-invalid-this": "off",
+        "ts/no-invalid-this": "error",
+        "no-redeclare": "off",
+        "ts/no-redeclare": "error",
+        "no-use-before-define": "off",
+        "ts/no-use-before-define": [
+          "error",
+          { functions: false, classes: false, variables: true }
+        ],
+        "object-curly-spacing": "off",
+        "space-before-blocks": "off",
+        "ts/space-before-blocks": "off",
+        "space-before-function-paren": "off",
+        "no-dupe-class-members": "off",
+        "ts/no-dupe-class-members": "error",
+        "no-loss-of-precision": "off",
+        "ts/no-loss-of-precision": "error",
+        "lines-between-class-members": "off",
+        "ts/lines-between-class-members": [
+          "error",
+          "always",
+          { exceptAfterSingleLine: true }
+        ],
+        // so1ve
+        "so1ve/no-inline-type-import": "error",
+        // off
+        "ts/camelcase": "off",
+        "ts/explicit-function-return-type": "off",
+        "ts/explicit-member-accessibility": "off",
+        "ts/no-explicit-any": "off",
+        "ts/no-parameter-properties": "off",
+        "ts/no-empty-interface": "off",
+        "ts/ban-ts-ignore": "off",
+        "ts/no-empty-function": "off",
+        "ts/no-non-null-assertion": "off",
+        "ts/explicit-module-boundary-types": "off",
+        "ts/triple-slash-reference": "off",
+        "ts/prefer-for-of": "error",
+        "ts/no-duplicate-enum-values": "error",
+        "ts/no-non-null-asserted-nullish-coalescing": "error",
+        // handled by unused-imports/no-unused-imports
+        "ts/no-unused-vars": "off",
+        ...typeAwareRules,
+        ...overrides
+      }
+    },
+    {
+      files: [GLOB_MARKDOWN_CODE],
+      languageOptions: {
+        parser: parserTs,
+        parserOptions: {
+          sourceType: "module"
+        }
+      },
+      rules: {
+        ...Object.fromEntries(
+          Object.keys(typeAwareRules).map((k) => [k, "off"])
+        )
+      }
+    },
+    {
+      files: ["**/*.d.ts"],
+      rules: {
+        "eslint-comments/no-unlimited-disable": "off",
+        "import/no-duplicates": "off",
+        "unused-imports/no-unused-vars": "off"
+      }
+    },
+    {
+      files: ["**/*.js", "**/*.cjs"],
+      rules: {
+        "ts/no-require-imports": "off",
+        "ts/no-var-requires": "off"
+      }
+    }
+  ];
+}
+
+const unicorn = () => [
+  {
+    plugins: {
+      unicorn: pluginUnicorn
+    },
+    rules: {
+      "unicorn/throw-new-error": "error",
+      "unicorn/relative-url-style": ["error", "always"],
+      "unicorn/switch-case-braces": "error",
+      "unicorn/number-literal-case": "error",
+      "unicorn/numeric-separators-style": "error",
+      "unicorn/new-for-builtins": "error",
+      "unicorn/error-message": "error",
+      "unicorn/escape-case": "error",
+      "unicorn/explicit-length-check": "error",
+      "unicorn/no-instanceof-array": "error",
+      "unicorn/no-new-buffer": "error",
+      "unicorn/no-new-array": "error",
+      "unicorn/no-array-for-each": "error",
+      "unicorn/no-array-method-this-argument": "error",
+      "unicorn/no-for-loop": "error",
+      "unicorn/no-lonely-if": "error",
+      "unicorn/no-negated-condition": "error",
+      "unicorn/no-useless-spread": "error",
+      "unicorn/prefer-ternary": "error",
+      "unicorn/prefer-query-selector": "error",
+      "unicorn/prefer-modern-dom-apis": "error",
+      "unicorn/prefer-modern-math-apis": "error",
+      "unicorn/prefer-json-parse-buffer": "error",
+      "unicorn/prefer-date-now": "error",
+      "unicorn/prefer-array-some": "error",
+      "unicorn/prefer-array-index-of": "error",
+      "unicorn/prefer-array-flat": "error",
+      "unicorn/prefer-array-find": "error",
+      "unicorn/prefer-spread": "error",
+      "unicorn/prefer-set-size": "error",
+      "unicorn/prefer-string-slice": "error",
+      "unicorn/prefer-includes": "error",
+      "unicorn/prefer-string-starts-ends-with": "error",
+      "unicorn/prefer-text-content": "error",
+      "unicorn/prefer-type-error": "error",
+      "unicorn/prefer-node-protocol": "error",
+      "unicorn/prefer-negative-index": "error",
+      "unicorn/prefer-regexp-test": "error",
+      "unicorn/prefer-optional-catch-binding": "error",
+      "unicorn/prefer-object-from-entries": "error",
+      "unicorn/prefer-prototype-methods": "error"
+    }
+  }
+];
+
+const vue = ({
+  overrides,
+  typescript
+} = {}) => [
+  {
+    plugins: {
+      vue: pluginVue
+    }
+  },
+  {
+    files: [GLOB_VUE],
+    languageOptions: {
+      parser: parserVue,
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        },
+        extraFileExtensions: [".vue"],
+        parser: typescript ? parserTs : null,
+        sourceType: "module"
+      }
+    },
+    processor: pluginVue.processors[".vue"],
+    rules: {
+      ...pluginVue.configs.base.rules,
+      ...pluginVue.configs["vue3-essential"].rules,
+      ...pluginVue.configs["vue3-strongly-recommended"].rules,
+      ...pluginVue.configs["vue3-recommended"].rules,
+      "no-unused-vars": "off",
+      "no-undef": "off",
+      "@typescript-eslint/no-unused-vars": "off",
+      "vue/no-v-html": "off",
+      "vue/require-prop-types": "off",
+      "vue/require-default-prop": "off",
+      "vue/multi-word-component-names": "off",
+      "vue/no-ref-object-reactivity-loss": "error",
+      "vue/no-setup-props-reactivity-loss": "error",
+      "vue/block-order": [
+        "error",
+        {
+          order: ["script:not([setup])", "script[setup]", "template", "style"]
+        }
+      ],
+      "vue/component-api-style": ["error", ["script-setup", "composition"]],
+      "vue/component-name-in-template-casing": [
+        "error",
+        "PascalCase",
+        { registeredComponentsOnly: false }
+      ],
+      "vue/component-options-name-casing": ["error", "PascalCase"],
+      "vue/custom-event-name-casing": ["error", "camelCase"],
+      "vue/define-macros-order": [
+        "error",
+        {
+          order: ["defineOptions", "defineEmits", "defineProps", "defineSlots"]
+        }
+      ],
+      "vue/html-comment-content-spacing": [
+        "error",
+        "always",
+        { exceptions: ["-"] }
+      ],
+      "vue/no-restricted-v-bind": ["error", "/^v-/"],
+      "vue/no-useless-v-bind": ["error", { ignoreIncludesComment: true }],
+      "vue/no-unused-refs": "error",
+      "vue/no-v-text-v-html-on-component": "error",
+      "vue/padding-line-between-blocks": ["error", "always"],
+      "vue/prefer-separate-static-class": "error",
+      // extensions
+      "vue/dot-location": ["error", "property"],
+      "vue/dot-notation": ["error", { allowKeywords: true }],
+      "vue/eqeqeq": ["error", "smart"],
+      "vue/no-constant-condition": "error",
+      "vue/no-empty-pattern": "error",
+      "vue/no-irregular-whitespace": "error",
+      "vue/no-loss-of-precision": "error",
+      "vue/no-restricted-syntax": [
+        "error",
+        "DebuggerStatement",
+        "LabeledStatement",
+        "WithStatement"
+      ],
+      "vue/no-sparse-arrays": "error",
+      "vue/object-curly-newline": [
+        "error",
+        { multiline: true, consistent: true }
+      ],
+      "vue/object-property-newline": [
+        "error",
+        { allowMultiplePropertiesPerLine: true }
+      ],
+      "vue/object-shorthand": [
+        "error",
+        "always",
+        { ignoreConstructors: false, avoidQuotes: true }
+      ],
+      "vue/prefer-template": "error",
+      "vue/quote-props": ["error", "consistent-as-needed"],
+      "vue/block-lang": [
+        "error",
+        {
+          script: {
+            lang: ["js", "ts"]
+          },
+          template: {
+            lang: ["html", "jade", "pug", "ejs"]
+          },
+          style: {
+            lang: ["css", "sass", "scss", "less", "stylus", "postcss"]
+          }
+        }
+      ],
+      "vue/require-macro-variable-name": [
+        "error",
+        {
+          defineProps: "props",
+          defineEmits: "emit",
+          defineSlots: "slots",
+          useSlots: "slots",
+          useAttrs: "attrs"
+        }
+      ],
+      "vue/require-typed-ref": "error",
+      "vue/no-static-inline-styles": ["error", { allowBinding: true }],
+      "vue/no-console": [
+        "error",
+        { allow: ["error", "warn", "table", "time"] }
+      ],
+      "vue/camelcase": "error",
+      "vue/v-for-delimiter-style": ["error", "in"],
+      "vue/attributes-order": [
+        "error",
+        {
+          order: [
+            "DEFINITION",
+            "LIST_RENDERING",
+            "CONDITIONALS",
+            "RENDER_MODIFIERS",
+            "TWO_WAY_BINDING",
+            "OTHER_DIRECTIVES",
+            ["UNIQUE", "SLOT"],
+            "GLOBAL",
+            "OTHER_ATTR",
+            "EVENTS",
+            "CONTENT"
+          ],
+          alphabetical: true
+        }
+      ],
+      "vue/prefer-true-attribute-shorthand": "error",
+      "vue/prefer-define-options": "error",
+      "vue/html-comment-content-newline": [
+        "error",
+        { singleline: "ignore", multiline: "always" }
+      ],
+      "vue/html-comment-indent": ["error", "tab"],
+      "vue/html-self-closing": [
+        "error",
+        {
+          html: {
+            void: "always",
+            normal: "always",
+            component: "always"
+          },
+          svg: "always",
+          math: "always"
+        }
+      ],
+      "vue/no-useless-concat": "error",
+      // off
+      "vue/no-multiple-template-root": "off",
+      "vue/multiline-html-element-content-newline": "off",
+      "vue/singleline-html-element-content-newline": "off",
+      "vue/no-extra-parens": "off",
+      "vue/array-bracket-spacing": "off",
+      "vue/arrow-spacing": "off",
+      "vue/block-spacing": "off",
+      "vue/brace-style": "off",
+      "vue/comma-dangle": "off",
+      "vue/comma-spacing": "off",
+      "vue/comma-style": "off",
+      "vue/operator-linebreak": "off",
+      "vue/template-curly-spacing": "off",
+      "vue/key-spacing": "off",
+      "vue/keyword-spacing": "off",
+      "vue/html-quotes": "off",
+      "vue/html-indent": "off",
+      "vue/no-multi-spaces": "off",
+      "vue/max-attributes-per-line": "off",
+      "vue/html-closing-bracket-spacing": "off",
+      ...overrides
+    }
+  }
+];
+
+const yaml = ({
+  overrides
+} = {}) => [
+  {
+    plugins: {
+      yaml: pluginYaml
+    },
+    languageOptions: {
+      parser: parserYaml
+    },
+    files: [GLOB_YAML],
+    rules: {
+      ...renameRules(pluginYaml.configs.prettier.rules, "yml/", "yaml/"),
+      ...renameRules(pluginYaml.configs.recommended.rules, "yml/", "yaml/"),
+      "yaml/no-empty-document": "off",
+      "spaced-comment": "off",
+      ...overrides
+    }
+  }
+];
+
+const flatConfigProps = [
+  "files",
+  "ignores",
+  "languageOptions",
+  "linterOptions",
+  "processor",
+  "plugins",
+  "rules",
+  "settings"
+];
+const VuePackages = ["vue", "nuxt", "vitepress", "@slidev/cli"];
+function so1ve(options = {}, ...userConfigs) {
+  var _a, _b, _c, _d, _e, _f;
+  const {
+    vue: enableVue = VuePackages.some((i) => isPackageExists(i)),
+    solid: enableSolid = isPackageExists("solid-js"),
+    typescript: enableTypeScript = isPackageExists("typescript"),
+    gitignore: enableGitignore = true,
+    overrides = {},
+    componentExts = []
+  } = options;
+  const configs = [];
+  if (enableGitignore) {
+    if (typeof enableGitignore === "boolean") {
+      if (fs.existsSync(".gitignore")) {
+        configs.push([gitignore()]);
+      }
+    } else {
+      configs.push([gitignore(enableGitignore)]);
+    }
+  }
+  configs.push(
+    ignores(),
+    javascript({
+      overrides: overrides.javascript
+    }),
+    comments(),
+    node(),
+    onlyError(),
+    promise(),
+    sortImports(),
+    imports(),
+    unicorn()
+  );
+  if (enableVue) {
+    componentExts.push("vue");
+  }
+  if (enableTypeScript) {
+    configs.push(
+      typescript({
+        componentExts,
+        overrides: overrides.typescript
+      })
+    );
+  }
+  if ((_a = options.test) != null ? _a : true) {
+    configs.push(
+      test({
+        overrides: overrides.test
+      })
+    );
+  }
+  if (enableVue) {
+    configs.push(
+      vue({
+        overrides: overrides.vue,
+        typescript: !!enableTypeScript
+      })
+    );
+  }
+  if (enableSolid) {
+    configs.push(
+      solid({
+        overrides: overrides.solid,
+        typescript: !!enableTypeScript
+      })
+    );
+  }
+  if ((_b = options.jsonc) != null ? _b : true) {
+    configs.push(jsonc());
+  }
+  if ((_c = options.toml) != null ? _c : true) {
+    configs.push(
+      toml({
+        overrides: overrides.toml
+      })
+    );
+  }
+  if ((_d = options.yaml) != null ? _d : true) {
+    configs.push(
+      yaml({
+        overrides: overrides.yaml
+      })
+    );
+  }
+  if ((_e = options.mdx) != null ? _e : true) {
+    configs.push(
+      mdx({
+        componentExts,
+        overrides: overrides.mdx
+      })
+    );
+  }
+  if ((_f = options.formatting) != null ? _f : true) {
+    configs.push(formatting(options));
+  }
+  const fusedConfig = flatConfigProps.reduce((acc, key) => {
+    if (key in options) {
+      acc[key] = options[key];
+    }
+    return acc;
+  }, {});
+  if (Object.keys(fusedConfig).length > 0) {
+    configs.push([fusedConfig]);
+  }
+  const merged = combine(...configs, ...userConfigs);
+  return merged;
+}
+
+export { GLOB_ALL_SRC, GLOB_CSS, GLOB_DTS, GLOB_ESLINTRC, GLOB_EXCLUDE, GLOB_HTML, GLOB_JS, GLOB_JSON, GLOB_JSON5, GLOB_JSONC, GLOB_JSX, GLOB_LESS, GLOB_MARKDOWN, GLOB_MARKDOWN_CODE, GLOB_PACKAGEJSON, GLOB_SCSS, GLOB_SRC, GLOB_SRC_EXT, GLOB_STYLE, GLOB_TESTS, GLOB_TOML, GLOB_TS, GLOB_TSCONFIG, GLOB_TSX, GLOB_VUE, GLOB_YAML, combine, comments, formatting, html, ignores, imports, javascript, jsonc, mdx, node, onlyError, promise, recordRulesState, recordRulesStateConfigs, renameRules, so1ve, solid, sortImports, test, toml, typescript, unicorn, vue, warnUnnecessaryOffRules, yaml };