@cany748/eslint-config 3.0.4 → 3.0.5

package/dist/index.cjs

@@ -1,1354 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  GLOB_ALL_SRC: () => GLOB_ALL_SRC,
-  GLOB_ASTRO: () => GLOB_ASTRO,
-  GLOB_ASTRO_TS: () => GLOB_ASTRO_TS,
-  GLOB_CSS: () => GLOB_CSS,
-  GLOB_EXCLUDE: () => GLOB_EXCLUDE,
-  GLOB_GRAPHQL: () => GLOB_GRAPHQL,
-  GLOB_HTML: () => GLOB_HTML,
-  GLOB_JS: () => GLOB_JS,
-  GLOB_JSON: () => GLOB_JSON,
-  GLOB_JSON5: () => GLOB_JSON5,
-  GLOB_JSONC: () => GLOB_JSONC,
-  GLOB_JSX: () => GLOB_JSX,
-  GLOB_LESS: () => GLOB_LESS,
-  GLOB_MARKDOWN: () => GLOB_MARKDOWN,
-  GLOB_MARKDOWN_CODE: () => GLOB_MARKDOWN_CODE,
-  GLOB_MARKDOWN_IN_MARKDOWN: () => GLOB_MARKDOWN_IN_MARKDOWN,
-  GLOB_POSTCSS: () => GLOB_POSTCSS,
-  GLOB_SCSS: () => GLOB_SCSS,
-  GLOB_SRC: () => GLOB_SRC,
-  GLOB_SRC_EXT: () => GLOB_SRC_EXT,
-  GLOB_STYLE: () => GLOB_STYLE,
-  GLOB_SVELTE: () => GLOB_SVELTE,
-  GLOB_TESTS: () => GLOB_TESTS,
-  GLOB_TOML: () => GLOB_TOML,
-  GLOB_TS: () => GLOB_TS,
-  GLOB_TSX: () => GLOB_TSX,
-  GLOB_VUE: () => GLOB_VUE,
-  GLOB_XML: () => GLOB_XML,
-  GLOB_YAML: () => GLOB_YAML,
-  combine: () => combine,
-  comments: () => comments,
-  disables: () => disables,
-  factoryConfig: () => factoryConfig,
-  formatters: () => formatters,
-  ignores: () => ignores,
-  imports: () => imports,
-  interopDefault: () => interopDefault,
-  isInEditorEnv: () => isInEditorEnv,
-  isInGitHooksOrLintStaged: () => isInGitHooksOrLintStaged,
-  javascript: () => javascript,
-  jsonc: () => jsonc,
-  node: () => node,
-  parserPlain: () => parserPlain,
-  regexp: () => regexp,
-  sortPackageJson: () => sortPackageJson,
-  sortTsconfig: () => sortTsconfig,
-  test: () => test,
-  toArray: () => toArray,
-  typescript: () => typescript,
-  unicorn: () => unicorn,
-  unocss: () => unocss,
-  vue: () => vue
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/configs/comments.ts
-var import_eslint_plugin_eslint_comments = __toESM(require("@eslint-community/eslint-plugin-eslint-comments"), 1);
-function comments() {
-  return [
-    {
-      name: "@eslint-community/eslint-comments",
-      plugins: {
-        "@eslint-community/eslint-comments": import_eslint_plugin_eslint_comments.default
-      },
-      rules: {
-        ...import_eslint_plugin_eslint_comments.default.configs.recommended.rules,
-        "@eslint-community/eslint-comments/disable-enable-pair": "off"
-      }
-    }
-  ];
-}
-
-// src/globs.ts
-var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
-var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
-var GLOB_JS = "**/*.?([cm])js";
-var GLOB_JSX = "**/*.?([cm])jsx";
-var GLOB_TS = "**/*.?([cm])ts";
-var GLOB_TSX = "**/*.?([cm])tsx";
-var GLOB_STYLE = "**/*.{c,le,sc}ss";
-var GLOB_CSS = "**/*.css";
-var GLOB_POSTCSS = "**/*.{p,post}css";
-var GLOB_LESS = "**/*.less";
-var GLOB_SCSS = "**/*.scss";
-var GLOB_JSON = "**/*.json";
-var GLOB_JSON5 = "**/*.json5";
-var GLOB_JSONC = "**/*.jsonc";
-var GLOB_MARKDOWN = "**/*.md";
-var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
-var GLOB_SVELTE = "**/*.svelte";
-var GLOB_VUE = "**/*.vue";
-var GLOB_YAML = "**/*.y?(a)ml";
-var GLOB_TOML = "**/*.toml";
-var GLOB_XML = "**/*.xml";
-var GLOB_HTML = "**/*.htm?(l)";
-var GLOB_ASTRO = "**/*.astro";
-var GLOB_ASTRO_TS = "**/*.astro/*.ts";
-var GLOB_GRAPHQL = "**/*.{g,graph}ql";
-var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
-var GLOB_TESTS = [
-  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
-  `**/*.spec.${GLOB_SRC_EXT}`,
-  `**/*.test.${GLOB_SRC_EXT}`,
-  `**/*.bench.${GLOB_SRC_EXT}`,
-  `**/*.benchmark.${GLOB_SRC_EXT}`
-];
-var GLOB_ALL_SRC = [
-  GLOB_SRC,
-  GLOB_STYLE,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_MARKDOWN,
-  GLOB_SVELTE,
-  GLOB_VUE,
-  GLOB_YAML,
-  GLOB_XML,
-  GLOB_HTML
-];
-var GLOB_EXCLUDE = [
-  "**/node_modules",
-  "**/dist",
-  "**/build",
-  "**/vendor",
-  "**/public",
-  "**/out",
-  "**/package-lock.json",
-  "**/yarn.lock",
-  "**/pnpm-lock.yaml",
-  "**/bun.lockb",
-  "**/output",
-  "**/coverage",
-  "**/temp",
-  "**/.temp",
-  "**/tmp",
-  "**/.tmp",
-  "**/.history",
-  "**/.vitepress/cache",
-  "**/.nuxt",
-  "**/.next",
-  "**/.svelte-kit",
-  "**/.vercel",
-  "**/.netlify",
-  "**/.changeset",
-  "**/.idea",
-  "**/.cache",
-  "**/.output",
-  "**/.vite-inspect",
-  "**/.yarn",
-  "**/vite.config.*.timestamp-*",
-  "**/CHANGELOG*.md",
-  "**/*.min.*",
-  "**/LICENSE*",
-  "**/__snapshots__",
-  "**/auto-import?(s).d.ts",
-  "**/components.d.ts"
-];
-
-// src/configs/disables.ts
-function disables() {
-  return [
-    {
-      files: [`**/scripts/${GLOB_SRC}`],
-      name: "disables/scripts",
-      rules: {
-        "no-console": "off",
-        "@typescript-eslint/explicit-function-return-type": "off"
-      }
-    },
-    {
-      files: [`**/cli/${GLOB_SRC}`, `**/cli.${GLOB_SRC_EXT}`],
-      name: "disables/cli",
-      rules: {
-        "no-console": "off"
-      }
-    },
-    {
-      files: ["**/*.d.?([cm])ts"],
-      name: "disables/dts",
-      rules: {
-        "@eslint-community/eslint-comments/no-unlimited-disable": "off",
-        "import/no-duplicates": "off",
-        "no-restricted-syntax": "off",
-        "unused-imports/no-unused-vars": "off"
-      }
-    },
-    {
-      files: ["**/*.{test,spec}.([tj])s?(x)"],
-      name: "disables/test",
-      rules: {
-        "no-unused-expressions": "off"
-      }
-    },
-    {
-      files: ["**/*.js", "**/*.cjs"],
-      name: "disables/cjs",
-      rules: {
-        "@typescript-eslint/no-require-imports": "off"
-      }
-    },
-    {
-      files: [`**/*.config.${GLOB_SRC_EXT}`, `**/*.config.*.${GLOB_SRC_EXT}`],
-      name: "disables/config-files",
-      rules: {
-        "no-console": "off",
-        "@typescript-eslint/explicit-function-return-type": "off"
-      }
-    }
-  ];
-}
-
-// src/configs/formatters.ts
-var import_eslint_plugin_prettier = __toESM(require("eslint-plugin-prettier"), 1);
-var import_recommended = __toESM(require("eslint-plugin-prettier/recommended"), 1);
-
-// src/utils.ts
-var parserPlain = {
-  meta: {
-    name: "parser-plain"
-  },
-  parseForESLint: (code) => ({
-    ast: {
-      body: [],
-      comments: [],
-      loc: { end: code.length, start: 0 },
-      range: [0, code.length],
-      tokens: [],
-      type: "Program"
-    },
-    scopeManager: null,
-    services: { isPlain: true },
-    visitorKeys: {
-      Program: []
-    }
-  })
-};
-async function combine(...configs2) {
-  const resolved = await Promise.all(configs2);
-  return resolved.flat();
-}
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-async function interopDefault(m) {
-  const resolved = await m;
-  return resolved.default || resolved;
-}
-function isInGitHooksOrLintStaged() {
-  return !!// eslint-disable-next-line no-constant-binary-expression
-  (process.env.GIT_PARAMS || process.env.VSCODE_GIT_COMMAND || process.env.npm_lifecycle_script?.startsWith("lint-staged"));
-}
-function isInEditorEnv() {
-  if (process.env.CI) return false;
-  if (isInGitHooksOrLintStaged()) return false;
-  return !!(process.env.VSCODE_PID || process.env.VSCODE_CWD || process.env.JETBRAINS_IDE || process.env.VIM || process.env.NVIM);
-}
-
-// src/configs/formatters.ts
-function formatters(options = true) {
-  if (options === true) {
-    options = {
-      css: true,
-      graphql: true,
-      html: true,
-      markdown: true
-    };
-  }
-  const configs2 = [
-    {
-      name: "formatter/setup",
-      plugins: {
-        prettier: import_eslint_plugin_prettier.default
-      },
-      rules: import_recommended.default.rules
-    }
-  ];
-  if (options.css) {
-    configs2.push(
-      {
-        files: [GLOB_CSS, GLOB_POSTCSS],
-        languageOptions: {
-          parser: parserPlain
-        },
-        name: "formatter/css",
-        rules: {
-          "prettier/prettier": ["error", { parser: "css" }]
-        }
-      },
-      {
-        files: [GLOB_SCSS],
-        languageOptions: {
-          parser: parserPlain
-        },
-        name: "formatter/scss",
-        rules: {
-          "prettier/prettier": ["error", { parser: "scss" }]
-        }
-      },
-      {
-        files: [GLOB_LESS],
-        languageOptions: {
-          parser: parserPlain
-        },
-        name: "formatter/less",
-        rules: {
-          "prettier/prettier": ["error", { parser: "less" }]
-        }
-      }
-    );
-  }
-  if (options.graphql) {
-    configs2.push({
-      files: [GLOB_GRAPHQL],
-      languageOptions: {
-        parser: parserPlain
-      },
-      name: "formatter/graphql",
-      rules: {
-        "prettier/prettier": ["error", { parser: "graphql" }]
-      }
-    });
-  }
-  if (options.html) {
-    configs2.push({
-      files: [GLOB_HTML],
-      languageOptions: {
-        parser: parserPlain
-      },
-      name: "formatter/html",
-      rules: {
-        "prettier/prettier": ["error", { parser: "html" }]
-      }
-    });
-  }
-  if (options.markdown) {
-    configs2.push({
-      files: [GLOB_MARKDOWN],
-      languageOptions: {
-        parser: parserPlain
-      },
-      name: "formatter/markdown",
-      rules: {
-        "prettier/prettier": ["error", { parser: "markdown" }]
-      }
-    });
-  }
-  return configs2;
-}
-
-// src/configs/ignores.ts
-function ignores(userIgnores = []) {
-  return [
-    {
-      ignores: [...GLOB_EXCLUDE, ...userIgnores]
-    }
-  ];
-}
-
-// src/configs/imports.ts
-var pluginImport = __toESM(require("eslint-plugin-import-x"), 1);
-function imports() {
-  return [
-    {
-      name: "imports",
-      plugins: {
-        import: pluginImport
-      },
-      rules: {
-        "import/export": "error",
-        "import/first": "error",
-        "import/newline-after-import": ["error", { considerComments: true, count: 1 }],
-        "import/no-duplicates": "error",
-        "import/no-mutable-exports": "error",
-        "import/no-named-default": "error",
-        "import/no-self-import": "error",
-        "import/no-webpack-loader-syntax": "error",
-        "import/order": "error"
-      }
-    }
-  ];
-}
-
-// src/configs/javascript.ts
-var import_globals = __toESM(require("globals"), 1);
-var import_eslint_plugin_unused_imports = __toESM(require("eslint-plugin-unused-imports"), 1);
-function javascript(options = {}) {
-  const { isInEditor = false, overrides = {} } = options;
-  return [
-    {
-      languageOptions: {
-        ecmaVersion: 2022,
-        globals: {
-          ...import_globals.default.browser,
-          ...import_globals.default.es2021,
-          ...import_globals.default.node,
-          document: "readonly",
-          navigator: "readonly",
-          window: "readonly"
-        },
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true
-          },
-          ecmaVersion: 2022,
-          sourceType: "module"
-        },
-        sourceType: "module"
-      },
-      linterOptions: {
-        reportUnusedDisableDirectives: true
-      },
-      name: "javascript/rules",
-      plugins: {
-        "unused-imports": import_eslint_plugin_unused_imports.default
-      },
-      rules: {
-        "accessor-pairs": ["error", { enforceForClassMembers: true, setWithoutGet: true }],
-        "array-callback-return": "error",
-        "block-scoped-var": "error",
-        camelcase: [
-          "error",
-          { properties: "never", ignoreDestructuring: true, ignoreGlobals: true, ignoreImports: true, allow: ["^UNSAFE_"] }
-        ],
-        "constructor-super": "error",
-        "default-case-last": "error",
-        "dot-notation": ["error", { allowKeywords: true }],
-        eqeqeq: ["error", "smart"],
-        "for-direction": "error",
-        "getter-return": "error",
-        "new-cap": ["error", { capIsNew: false, newIsCap: true, properties: true }],
-        "no-alert": "error",
-        "no-array-constructor": "error",
-        "no-async-promise-executor": "error",
-        "no-caller": "error",
-        "no-case-declarations": "error",
-        "no-class-assign": "error",
-        "no-compare-neg-zero": "error",
-        "no-cond-assign": ["error", "always"],
-        "no-console": ["error", { allow: ["warn", "error"] }],
-        "no-const-assign": "error",
-        "no-constant-binary-expression": "error",
-        "no-constant-condition": "error",
-        "no-control-regex": "error",
-        "no-debugger": "error",
-        "no-delete-var": "error",
-        "no-dupe-args": "error",
-        "no-dupe-class-members": "error",
-        "no-dupe-else-if": "error",
-        "no-dupe-keys": "error",
-        "no-duplicate-case": "error",
-        "no-empty-character-class": "error",
-        "no-empty-pattern": "error",
-        "no-empty-static-block": "error",
-        "no-empty": ["error", { allowEmptyCatch: true }],
-        "no-eval": "error",
-        "no-ex-assign": "error",
-        "no-extend-native": "error",
-        "no-extra-bind": "error",
-        "no-extra-boolean-cast": "error",
-        "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: false, allowSwitch: false }],
-        "no-lone-blocks": "error",
-        "no-lonely-if": "error",
-        "no-loss-of-precision": "error",
-        "no-misleading-character-class": "error",
-        "no-multi-str": "error",
-        "no-new-func": "error",
-        "no-new-native-nonconstructor": "error",
-        "no-new-wrappers": "error",
-        "no-new": "error",
-        "no-nonoctal-decimal-escape": "error",
-        "no-obj-calls": "error",
-        "no-octal-escape": "error",
-        "no-octal": "error",
-        "no-proto": "error",
-        "no-prototype-builtins": "error",
-        "no-redeclare": ["error", { builtinGlobals: false }],
-        "no-regex-spaces": "error",
-        "no-restricted-globals": [
-          "error",
-          { message: "Use `globalThis` instead.", name: "global" },
-          { message: "Use `globalThis` instead.", name: "self" }
-        ],
-        "no-restricted-properties": [
-          "error",
-          { message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.", property: "__proto__" },
-          { message: "Use `Object.defineProperty` instead.", property: "__defineGetter__" },
-          { message: "Use `Object.defineProperty` instead.", property: "__defineSetter__" },
-          { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupGetter__" },
-          { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupSetter__" }
-        ],
-        "no-restricted-syntax": ["error", "TSEnumDeclaration[const=true]", "TSExportAssignment"],
-        "no-return-assign": ["error", "except-parens"],
-        "no-self-assign": ["error", { props: true }],
-        "no-self-compare": "error",
-        "no-sequences": "error",
-        "no-setter-return": "error",
-        "no-shadow-restricted-names": "error",
-        "no-sparse-arrays": "error",
-        "no-template-curly-in-string": "error",
-        "no-this-before-super": "error",
-        "no-throw-literal": "error",
-        "no-undef-init": "error",
-        "no-undef": "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-unsafe-optional-chaining": "error",
-        "no-unused-expressions": [
-          "error",
-          {
-            allowShortCircuit: true,
-            allowTaggedTemplates: true,
-            allowTernary: true
-          }
-        ],
-        "no-unused-private-class-members": "error",
-        "no-unused-vars": "off",
-        "no-use-before-define": ["error", { classes: false, functions: false, variables: true }],
-        "no-useless-backreference": "error",
-        "no-useless-call": "error",
-        "no-useless-catch": "error",
-        "no-useless-computed-key": "error",
-        "no-useless-constructor": "error",
-        "no-useless-escape": "error",
-        "no-useless-rename": "error",
-        "no-useless-return": "error",
-        "no-var": "error",
-        "no-void": ["error", { allowAsStatement: true }],
-        "no-with": "error",
-        "object-shorthand": [
-          "error",
-          "always",
-          {
-            avoidQuotes: true,
-            ignoreConstructors: false
-          }
-        ],
-        "one-var": ["error", { initialized: "never" }],
-        "prefer-arrow-callback": [
-          "error",
-          {
-            allowNamedFunctions: false,
-            allowUnboundThis: true
-          }
-        ],
-        "prefer-const": isInEditor ? "warn" : ["error", { destructuring: "all", ignoreReadBeforeAssign: true }],
-        "prefer-exponentiation-operator": "error",
-        "prefer-promise-reject-errors": "error",
-        "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
-        "prefer-rest-params": "error",
-        "prefer-spread": "error",
-        "prefer-template": "error",
-        "require-await": "error",
-        "require-yield": "error",
-        "sort-imports": [
-          "error",
-          {
-            allowSeparatedGroups: false,
-            ignoreCase: false,
-            ignoreDeclarationSort: true,
-            ignoreMemberSort: false,
-            memberSyntaxSortOrder: ["none", "all", "multiple", "single"]
-          }
-        ],
-        "symbol-description": "error",
-        "unicode-bom": ["error", "never"],
-        "unused-imports/no-unused-imports": isInEditor ? "warn" : "error",
-        "unused-imports/no-unused-vars": [
-          "error",
-          {
-            args: "after-used",
-            argsIgnorePattern: "^_",
-            ignoreRestSiblings: true,
-            vars: "all",
-            varsIgnorePattern: "^_"
-          }
-        ],
-        "use-isnan": ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }],
-        "valid-typeof": ["error", { requireStringLiterals: true }],
-        "vars-on-top": "error",
-        yoda: ["error", "never"],
-        ...overrides
-      }
-    }
-  ];
-}
-
-// src/configs/jsonc.ts
-async function jsonc(options = {}) {
-  const { files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC] } = options;
-  const [pluginJsonc, parserJsonc] = await Promise.all([
-    interopDefault(import("eslint-plugin-jsonc")),
-    interopDefault(import("jsonc-eslint-parser"))
-  ]);
-  return [
-    {
-      name: "jsonc",
-      files,
-      languageOptions: {
-        parser: parserJsonc
-      },
-      plugins: {
-        jsonc: pluginJsonc
-      },
-      rules: {
-        ...pluginJsonc.configs["recommended-with-jsonc"].rules,
-        ...pluginJsonc.configs.prettier.rules
-      }
-    }
-  ];
-}
-
-// src/configs/node.ts
-var import_eslint_plugin_n = __toESM(require("eslint-plugin-n"), 1);
-function node() {
-  return [
-    {
-      name: "node",
-      plugins: {
-        n: import_eslint_plugin_n.default
-      },
-      rules: {
-        "n/handle-callback-err": ["error", "^(err|error)$"],
-        "n/no-deprecated-api": "error",
-        "n/no-exports-assign": "error",
-        "n/no-new-require": "error",
-        "n/no-path-concat": "error",
-        "n/prefer-global/buffer": ["error", "always"],
-        "n/prefer-global/console": ["error", "always"],
-        "n/prefer-global/process": ["error", "always"],
-        "n/prefer-global/text-decoder": ["error", "always"],
-        "n/prefer-global/text-encoder": ["error", "always"],
-        "n/prefer-global/url": ["error", "always"],
-        "n/prefer-global/url-search-params": ["error", "always"],
-        "n/process-exit-as-throw": "error"
-      }
-    }
-  ];
-}
-
-// src/configs/regexp.ts
-var import_eslint_plugin_regexp = require("eslint-plugin-regexp");
-function regexp(options = {}) {
-  const config = import_eslint_plugin_regexp.configs["flat/recommended"];
-  return [
-    {
-      ...config,
-      name: "regexp",
-      rules: {
-        ...config.rules,
-        "regexp/no-obscure-range": "off",
-        ...options.overrides
-      }
-    }
-  ];
-}
-
-// src/configs/sort.ts
-function sortPackageJson() {
-  return [
-    {
-      files: ["**/package.json"],
-      name: "sort/package-json",
-      rules: {
-        "jsonc/sort-array-values": [
-          "error",
-          {
-            order: { type: "asc" },
-            pathPattern: "^files$"
-          }
-        ],
-        "jsonc/sort-keys": [
-          "error",
-          {
-            order: [
-              "publisher",
-              "name",
-              "displayName",
-              "type",
-              "version",
-              "private",
-              "packageManager",
-              "description",
-              "author",
-              "contributors",
-              "license",
-              "funding",
-              "homepage",
-              "repository",
-              "bugs",
-              "keywords",
-              "categories",
-              "sideEffects",
-              "exports",
-              "main",
-              "module",
-              "unpkg",
-              "jsdelivr",
-              "types",
-              "typesVersions",
-              "bin",
-              "icon",
-              "files",
-              "engines",
-              "activationEvents",
-              "contributes",
-              "scripts",
-              "peerDependencies",
-              "peerDependenciesMeta",
-              "dependencies",
-              "optionalDependencies",
-              "devDependencies",
-              "pnpm",
-              "overrides",
-              "resolutions",
-              "husky",
-              "simple-git-hooks",
-              "lint-staged",
-              "eslintConfig",
-              "prettier",
-              "stylelint"
-            ],
-            pathPattern: "^$"
-          },
-          {
-            order: { type: "asc" },
-            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$"
-          },
-          {
-            order: { type: "asc" },
-            pathPattern: "^(?:resolutions|overrides|pnpm.overrides)$"
-          },
-          {
-            order: ["types", "import", "require", "default"],
-            pathPattern: "^exports.*$"
-          },
-          {
-            order: [
-              // client hooks only
-              "pre-commit",
-              "prepare-commit-msg",
-              "commit-msg",
-              "post-commit",
-              "pre-rebase",
-              "post-rewrite",
-              "post-checkout",
-              "post-merge",
-              "pre-push",
-              "pre-auto-gc"
-            ],
-            pathPattern: "^(?:gitHooks|husky|simple-git-hooks)$"
-          }
-        ]
-      }
-    }
-  ];
-}
-function sortTsconfig() {
-  return [
-    {
-      files: ["**/tsconfig.json", "**/tsconfig.*.json"],
-      name: "sort/tsconfig-json",
-      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",
-              "isolatedDeclarations",
-              "isolatedModules",
-              "preserveSymlinks",
-              "verbatimModuleSyntax",
-              /* Completeness */
-              "skipDefaultLibCheck",
-              "skipLibCheck"
-            ],
-            pathPattern: "^compilerOptions$"
-          }
-        ]
-      }
-    }
-  ];
-}
-
-// src/configs/test.ts
-var _pluginTest;
-async function test(options = {}) {
-  const { files = GLOB_TESTS, isInEditor = false, overrides = {} } = options;
-  const [pluginVitest, pluginNoOnlyTests] = await Promise.all([
-    interopDefault(import("@vitest/eslint-plugin")),
-    interopDefault(import("eslint-plugin-no-only-tests"))
-  ]);
-  _pluginTest = _pluginTest || {
-    ...pluginVitest,
-    rules: {
-      ...pluginVitest.rules,
-      ...pluginNoOnlyTests.rules
-    }
-  };
-  return [
-    {
-      files,
-      name: "test",
-      plugins: {
-        test: _pluginTest
-      },
-      rules: {
-        "test/consistent-test-it": ["error", { fn: "it", withinDescribe: "it" }],
-        "test/no-identical-title": "error",
-        "test/no-import-node-test": "error",
-        "test/no-only-tests": isInEditor ? "warn" : "error",
-        "test/prefer-hooks-in-order": "error",
-        "test/prefer-lowercase-title": "error",
-        "no-unused-expressions": "off",
-        "n/prefer-global/process": "off",
-        "@typescript-eslint/explicit-function-return-type": "off",
-        ...overrides
-      }
-    }
-  ];
-}
-
-// src/configs/typescript.ts
-async function typescript(options = {}) {
-  const { componentExts = [], overrides = {}, overridesTypeAware = {}, parserOptions = {}, type = "app" } = options;
-  const files = options.files ?? [GLOB_TS, GLOB_TSX, ...componentExts.map((ext) => `**/*.${ext}`)];
-  const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
-  const ignoresTypeAware = options.ignoresTypeAware ?? [`${GLOB_MARKDOWN}/**`, GLOB_ASTRO_TS];
-  const tsconfigPath = options?.tsconfigPath;
-  const isTypeAware = !!tsconfigPath;
-  const [pluginTs, parserTs] = await Promise.all([
-    interopDefault(import("@typescript-eslint/eslint-plugin")),
-    interopDefault(import("@typescript-eslint/parser"))
-  ]);
-  function makeParser(typeAware, files2, ignores2) {
-    return {
-      files: files2,
-      ...ignores2 ? { ignores: ignores2 } : {},
-      languageOptions: {
-        parser: parserTs,
-        parserOptions: {
-          extraFileExtensions: componentExts.map((ext) => `.${ext}`),
-          sourceType: "module",
-          ...typeAware ? {
-            projectService: {
-              allowDefaultProject: ["./*.js"],
-              defaultProject: tsconfigPath
-            },
-            tsconfigRootDir: process.cwd()
-          } : {},
-          ...parserOptions
-        }
-      },
-      name: `typescript/${typeAware ? "type-aware-parser" : "parser"}`
-    };
-  }
-  return [
-    {
-      // Install the plugins without globs, so they can be configured separately.
-      name: "typescript/setup",
-      plugins: {
-        "@typescript-eslint": pluginTs
-      }
-    },
-    // assign type-aware parser for type-aware files and type-unaware parser for the rest
-    ...isTypeAware ? [makeParser(false, files), makeParser(true, filesTypeAware, ignoresTypeAware)] : [makeParser(false, files)],
-    {
-      files,
-      name: "typescript/rules",
-      rules: {
-        ...pluginTs.configs["eslint-recommended"].overrides[0].rules,
-        ...pluginTs.configs.strict.rules,
-        "@typescript-eslint/consistent-type-assertions": "error",
-        "@typescript-eslint/consistent-type-definitions": "off",
-        "@typescript-eslint/consistent-type-imports": [
-          "error",
-          { disallowTypeAnnotations: false, prefer: "type-imports", fixStyle: "inline-type-imports" }
-        ],
-        "@typescript-eslint/method-signature-style": "error",
-        "@typescript-eslint/no-dynamic-delete": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-import-type-side-effects": "error",
-        "@typescript-eslint/no-invalid-void-type": "off",
-        "@typescript-eslint/no-non-null-assertion": "off",
-        "@typescript-eslint/no-require-imports": "error",
-        "@typescript-eslint/triple-slash-reference": "off",
-        "@typescript-eslint/unified-signatures": "off",
-        // handled by unused-imports/no-unused-imports
-        "@typescript-eslint/no-unused-vars": "off",
-        "no-dupe-class-members": "off",
-        "@typescript-eslint/no-dupe-class-members": "error",
-        "no-invalid-this": "off",
-        "@typescript-eslint/no-invalid-this": "error",
-        "no-redeclare": "off",
-        "@typescript-eslint/no-redeclare": ["error", { builtinGlobals: false }],
-        "no-unused-expressions": "off",
-        "@typescript-eslint/no-unused-expressions": ["error", { allowShortCircuit: true, allowTernary: true, allowTaggedTemplates: true }],
-        "no-use-before-define": "off",
-        "@typescript-eslint/no-use-before-define": "error",
-        ...type === "lib" ? {
-          "@typescript-eslint/explicit-function-return-type": [
-            "error",
-            {
-              allowExpressions: true,
-              allowHigherOrderFunctions: true,
-              allowIIFEs: true
-            }
-          ]
-        } : {},
-        ...overrides
-      }
-    },
-    ...isTypeAware ? [
-      {
-        files: filesTypeAware,
-        ignores: ignoresTypeAware,
-        name: "typescript/rules-type-aware",
-        rules: {
-          ...tsconfigPath ? {
-            ...pluginTs.configs["recommended-type-checked-only"].rules,
-            "@typescript-eslint/no-confusing-void-expression": "error",
-            "@typescript-eslint/promise-function-async": "error",
-            "@typescript-eslint/restrict-template-expressions": "off",
-            "@typescript-eslint/strict-boolean-expressions": "off",
-            "dot-notation": "off",
-            "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
-            "no-throw-literal": "off",
-            "@typescript-eslint/only-throw-error": "error"
-          } : {},
-          ...overridesTypeAware
-        }
-      }
-    ] : []
-  ];
-}
-
-// src/configs/unicorn.ts
-var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
-function unicorn() {
-  return [
-    {
-      name: "unicorn",
-      plugins: {
-        unicorn: import_eslint_plugin_unicorn.default
-      },
-      rules: {
-        ...import_eslint_plugin_unicorn.default.configs["flat/recommended"].rules,
-        "unicorn/consistent-function-scoping": "off",
-        "unicorn/filename-case": "off",
-        "unicorn/import-style": "off",
-        "unicorn/no-array-callback-reference": "off",
-        "unicorn/no-null": "off",
-        "unicorn/prefer-string-replace-all": "off",
-        "unicorn/prefer-structured-clone": "off",
-        "unicorn/prefer-top-level-await": "off",
-        "unicorn/prevent-abbreviations": "off"
-      }
-    }
-  ];
-}
-
-// src/configs/unocss.ts
-async function unocss() {
-  const pluginUnoCSS = await interopDefault(import("@unocss/eslint-plugin"));
-  return [
-    {
-      ...pluginUnoCSS.configs.flat,
-      name: "unocss"
-    }
-  ];
-}
-
-// src/configs/vue.ts
-async function vue(options = {}) {
-  const { files = [GLOB_VUE], overrides = {}, vueVersion = 3 } = options;
-  const [pluginVue, parserVue] = await Promise.all([
-    interopDefault(import("eslint-plugin-vue")),
-    interopDefault(import("vue-eslint-parser"))
-  ]);
-  return [
-    {
-      files,
-      languageOptions: {
-        parser: parserVue,
-        globals: {
-          computed: "readonly",
-          defineEmits: "readonly",
-          defineExpose: "readonly",
-          defineProps: "readonly",
-          onMounted: "readonly",
-          onUnmounted: "readonly",
-          reactive: "readonly",
-          ref: "readonly",
-          shallowReactive: "readonly",
-          shallowRef: "readonly",
-          toRef: "readonly",
-          toRefs: "readonly",
-          watch: "readonly",
-          watchEffect: "readonly"
-        },
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true
-          },
-          extraFileExtensions: [".vue"],
-          parser: options.typescript ? await interopDefault(import("@typescript-eslint/parser")) : null,
-          sourceType: "module"
-        }
-      },
-      name: "vue",
-      processor: pluginVue.processors[".vue"],
-      plugins: {
-        vue: pluginVue
-      },
-      rules: {
-        ...pluginVue.configs.base.rules,
-        ...vueVersion === 2 ? {
-          ...pluginVue.configs.essential.rules,
-          ...pluginVue.configs["strongly-recommended"].rules,
-          ...pluginVue.configs.recommended.rules
-        } : {
-          ...pluginVue.configs["vue3-essential"].rules,
-          ...pluginVue.configs["vue3-strongly-recommended"].rules,
-          ...pluginVue.configs["vue3-recommended"].rules
-        },
-        "vue/component-name-in-template-casing": ["error", "PascalCase"],
-        "vue/component-options-name-casing": ["error", "PascalCase"],
-        "vue/custom-event-name-casing": ["error", "camelCase"],
-        "vue/define-macros-order": [
-          "error",
-          {
-            order: ["defineOptions", "defineModel", "defineProps", "defineEmits", "defineSlots"]
-          }
-        ],
-        "vue/dot-notation": "error",
-        "vue/eqeqeq": ["error", "smart"],
-        "vue/html-comment-content-spacing": ["error", "always", { exceptions: ["-"] }],
-        "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-restricted-v-bind": ["error", "/^v-/"],
-        "vue/no-sparse-arrays": "error",
-        "vue/no-unused-refs": "error",
-        "vue/no-useless-v-bind": "error",
-        "vue/no-v-html": "off",
-        "vue/object-shorthand": ["error", "always", { avoidQuotes: true, ignoreConstructors: false }],
-        "vue/prefer-separate-static-class": "error",
-        "vue/prefer-template": "error",
-        "vue/padding-line-between-blocks": ["error", "always"],
-        "vue/component-tags-order": "off",
-        "@typescript-eslint/explicit-function-return-type": "off",
-        ...overrides
-      }
-    }
-  ];
-}
-
-// src/factory.ts
-var import_local_pkg = require("local-pkg");
-var import_eslint_flat_config_utils = require("eslint-flat-config-utils");
-var flatConfigProps = [
-  "name",
-  "languageOptions",
-  "linterOptions",
-  "processor",
-  "plugins",
-  "rules",
-  "settings"
-];
-var VuePackages = ["vue", "nuxt", "vitepress", "@slidev/cli"];
-var factoryConfig = function(options = {}, ...userConfigs) {
-  const {
-    componentExts = [],
-    formatters: enableFormatters = true,
-    gitignore: enableGitignore = true,
-    jsonc: enableJSONC = true,
-    regexp: enableRegexp = true,
-    test: enableTest = true,
-    typescript: enableTypeScript = (0, import_local_pkg.isPackageExists)("typescript"),
-    unocss: enableUnoCSS = (0, import_local_pkg.isPackageExists)("unocss"),
-    vue: enableVue = VuePackages.some((i) => (0, import_local_pkg.isPackageExists)(i))
-  } = options;
-  let isInEditor = options.isInEditor;
-  if (isInEditor == null) {
-    isInEditor = isInEditorEnv();
-    if (isInEditor) console.log("[@cany748/eslint-config] Detected running in editor, some rules are disabled.");
-  }
-  const configs2 = [];
-  if (enableGitignore) {
-    if (typeof enableGitignore === "boolean") {
-      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r({ strict: false })]));
-    } else {
-      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r(enableGitignore)]));
-    }
-  }
-  configs2.push(
-    comments(),
-    ignores(options.ignores),
-    imports(),
-    javascript({
-      isInEditor,
-      overrides: options.javascript?.overrides
-    }),
-    node(),
-    unicorn()
-  );
-  if (enableVue) {
-    componentExts.push("vue");
-  }
-  if (enableTypeScript) {
-    configs2.push(
-      typescript({
-        ...typeof enableTypeScript === "boolean" ? {} : enableTypeScript || {},
-        componentExts,
-        type: options.type
-      })
-    );
-  }
-  if (enableRegexp) {
-    configs2.push(regexp(typeof enableRegexp === "boolean" ? {} : enableRegexp));
-  }
-  if (enableTest) {
-    configs2.push(
-      test({
-        isInEditor,
-        overrides: typeof enableTest === "boolean" ? {} : enableTest?.overrides
-      })
-    );
-  }
-  if (enableVue) {
-    configs2.push(
-      vue({
-        ...typeof enableVue === "boolean" ? {} : enableVue || {},
-        typescript: !!enableTypeScript
-      })
-    );
-  }
-  if (enableUnoCSS) {
-    configs2.push(unocss());
-  }
-  if (enableJSONC) {
-    configs2.push(jsonc(typeof enableJSONC === "boolean" ? {} : enableJSONC), sortPackageJson(), sortTsconfig());
-  }
-  if (enableFormatters) {
-    configs2.push(formatters(enableFormatters));
-  }
-  configs2.push(disables());
-  if ("files" in options) {
-    throw new Error(
-      '[@cany748/eslint-config] The first argument should not contain the "files" property as the options are supposed to be global. Place it in the second or later config instead.'
-    );
-  }
-  const fusedConfig = flatConfigProps.reduce((acc, key) => {
-    if (key in options) acc[key] = options[key];
-    return acc;
-  }, {});
-  if (Object.keys(fusedConfig).length > 0) configs2.push([fusedConfig]);
-  let composer = new import_eslint_flat_config_utils.FlatConfigComposer();
-  composer = composer.append(...configs2, ...userConfigs);
-  return composer;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GLOB_ALL_SRC,
-  GLOB_ASTRO,
-  GLOB_ASTRO_TS,
-  GLOB_CSS,
-  GLOB_EXCLUDE,
-  GLOB_GRAPHQL,
-  GLOB_HTML,
-  GLOB_JS,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_JSONC,
-  GLOB_JSX,
-  GLOB_LESS,
-  GLOB_MARKDOWN,
-  GLOB_MARKDOWN_CODE,
-  GLOB_MARKDOWN_IN_MARKDOWN,
-  GLOB_POSTCSS,
-  GLOB_SCSS,
-  GLOB_SRC,
-  GLOB_SRC_EXT,
-  GLOB_STYLE,
-  GLOB_SVELTE,
-  GLOB_TESTS,
-  GLOB_TOML,
-  GLOB_TS,
-  GLOB_TSX,
-  GLOB_VUE,
-  GLOB_XML,
-  GLOB_YAML,
-  combine,
-  comments,
-  disables,
-  factoryConfig,
-  formatters,
-  ignores,
-  imports,
-  interopDefault,
-  isInEditorEnv,
-  isInGitHooksOrLintStaged,
-  javascript,
-  jsonc,
-  node,
-  parserPlain,
-  regexp,
-  sortPackageJson,
-  sortTsconfig,
-  test,
-  toArray,
-  typescript,
-  unicorn,
-  unocss,
-  vue
-});