@jsse/eslint-config 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2259 @@
+"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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+// node_modules/.pnpm/natural-compare@1.4.0/node_modules/natural-compare/index.js
+var require_natural_compare = __commonJS({
+  "node_modules/.pnpm/natural-compare@1.4.0/node_modules/natural-compare/index.js"(exports, module2) {
+    "use strict";
+    var naturalCompare = function(a, b) {
+      var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
+      function getCode(str, pos, code) {
+        if (code) {
+          for (i = pos; code = getCode(str, i), code < 76 && code > 65; )
+            ++i;
+          return +str.slice(pos - 1, i);
+        }
+        code = alphabet && alphabet.indexOf(str.charAt(pos));
+        return code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127) ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
+      }
+      if ((a += "") != (b += ""))
+        for (; codeB; ) {
+          codeA = getCode(a, posA++);
+          codeB = getCode(b, posB++);
+          if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+            codeA = getCode(a, posA, posA);
+            codeB = getCode(b, posB, posA = i);
+            posB = i;
+          }
+          if (codeA != codeB)
+            return codeA < codeB ? -1 : 1;
+        }
+      return 0;
+    };
+    try {
+      module2.exports = naturalCompare;
+    } catch (e) {
+      String.naturalCompare = naturalCompare;
+    }
+  }
+});
+
+// node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/rules/sort-keys-fix.js
+var require_sort_keys_fix = __commonJS({
+  "node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/rules/sort-keys-fix.js"(exports, module2) {
+    "use strict";
+    var naturalCompare = require_natural_compare();
+    module2.exports = {
+      meta: {
+        type: "suggestion",
+        fixable: "code",
+        docs: {
+          description: "require object keys to be sorted",
+          category: "Stylistic Issues",
+          recommended: false,
+          url: "https://github.com/namnm/eslint-plugin-sort-keys"
+        },
+        schema: [
+          {
+            enum: ["asc", "desc"]
+          },
+          {
+            type: "object",
+            properties: {
+              caseSensitive: {
+                type: "boolean",
+                default: true
+              },
+              natural: {
+                type: "boolean",
+                default: false
+              },
+              minKeys: {
+                type: "integer",
+                minimum: 2,
+                default: 2
+              }
+            },
+            additionalProperties: false
+          }
+        ],
+        messages: {
+          sortKeys: "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'."
+        }
+      },
+      create(ctx) {
+        const order = ctx.options[0] || "asc";
+        const options = ctx.options[1];
+        const insensitive = (options && options.caseSensitive) === false;
+        const natural = Boolean(options && options.natural);
+        const isValidOrder = isValidOrders[order + (insensitive ? "I" : "") + (natural ? "N" : "")];
+        const minKeys = Number(options && options.minKeys) || 2;
+        let stack = null;
+        const SpreadElement = (node2) => {
+          if (node2.parent.type === "ObjectExpression") {
+            stack.prevName = null;
+          }
+        };
+        return {
+          ExperimentalSpreadProperty: SpreadElement,
+          SpreadElement,
+          ObjectExpression() {
+            stack = {
+              upper: stack,
+              prevName: null,
+              prevNode: null
+            };
+          },
+          "ObjectExpression:exit"() {
+            stack = stack.upper;
+          },
+          Property(node2) {
+            if (node2.parent.type === "ObjectPattern") {
+              return;
+            }
+            if (node2.parent.properties.length < minKeys) {
+              return;
+            }
+            const prevName = stack.prevName;
+            const prevNode = stack.prevNode;
+            const thisName = getPropertyName(node2);
+            if (thisName !== null) {
+              stack.prevName = thisName;
+              stack.prevNode = node2 || prevNode;
+            }
+            if (prevName === null || thisName === null) {
+              return;
+            }
+            if (!isValidOrder(prevName, thisName)) {
+              ctx.report({
+                node: node2,
+                loc: node2.key.loc,
+                messageId: "sortKeys",
+                data: {
+                  thisName,
+                  prevName,
+                  order,
+                  insensitive: insensitive ? "insensitive " : "",
+                  natural: natural ? "natural " : ""
+                },
+                fix(fixer) {
+                  if (node2.parent.__alreadySorted || node2.parent.properties.__alreadySorted) {
+                    return [];
+                  }
+                  node2.parent.__alreadySorted = true;
+                  node2.parent.properties.__alreadySorted = true;
+                  const src = ctx.getSourceCode();
+                  const props = node2.parent.properties;
+                  const parts = [];
+                  let part = [];
+                  props.forEach((p) => {
+                    if (!p.key) {
+                      parts.push(part);
+                      part = [];
+                    } else {
+                      part.push(p);
+                    }
+                  });
+                  parts.push(part);
+                  parts.forEach((part2) => {
+                    part2.sort((p1, p2) => {
+                      const n1 = getPropertyName(p1);
+                      const n2 = getPropertyName(p2);
+                      if (insensitive && n1.toLowerCase() === n2.toLowerCase()) {
+                        return 0;
+                      }
+                      return isValidOrder(n1, n2) ? -1 : 1;
+                    });
+                  });
+                  const fixes = [];
+                  let newIndex = 0;
+                  parts.forEach((part2) => {
+                    part2.forEach((p) => {
+                      moveProperty(p, props[newIndex], fixer, src).forEach(
+                        (f) => fixes.push(f)
+                      );
+                      newIndex++;
+                    });
+                    newIndex++;
+                  });
+                  return fixes;
+                }
+              });
+            }
+          }
+        };
+      }
+    };
+    var moveProperty = (thisNode, toNode, fixer, src) => {
+      if (thisNode === toNode) {
+        return [];
+      }
+      const fixes = [];
+      fixes.push(fixer.replaceText(toNode, src.getText(thisNode)));
+      const prev = findTokenPrevLine(thisNode, src);
+      const cond = (c) => !prev || prev.loc.end.line !== c.loc.start.line;
+      const commentsBefore = src.getCommentsBefore(thisNode).filter(cond);
+      if (commentsBefore.length) {
+        const prevComments = src.getCommentsBefore(thisNode).filter((c) => !cond(c));
+        const b = prevComments.length ? prevComments[prevComments.length - 1].range[1] : prev ? prev.range[1] : commentsBefore[0].range[0];
+        const e = commentsBefore[commentsBefore.length - 1].range[1];
+        fixes.push(fixer.replaceTextRange([b, e], ""));
+        const toPrev = src.getTokenBefore(toNode, { includeComments: true });
+        const txt = src.text.substring(b, e);
+        fixes.push(fixer.insertTextAfter(toPrev, txt));
+      }
+      const next = findCommaSameLine(thisNode, src) || thisNode;
+      const commentsAfter = src.getCommentsAfter(next).filter((c) => thisNode.loc.end.line === c.loc.start.line);
+      if (commentsAfter.length) {
+        const b = next.range[1];
+        const e = commentsAfter[commentsAfter.length - 1].range[1];
+        fixes.push(fixer.replaceTextRange([b, e], ""));
+        const toNext = findCommaSameLine(toNode, src) || toNode;
+        const txt = src.text.substring(b, e);
+        fixes.push(fixer.insertTextAfter(toNext, txt));
+      }
+      return fixes;
+    };
+    var findTokenPrevLine = (node2, src) => {
+      let t = src.getTokenBefore(node2);
+      while (true) {
+        if (!t || t.range[0] < node2.parent.range[0]) {
+          return null;
+        }
+        if (t.loc.end.line < node2.loc.start.line) {
+          return t;
+        }
+        t = src.getTokenBefore(t);
+      }
+    };
+    var findCommaSameLine = (node2, src) => {
+      const t = src.getTokenAfter(node2);
+      return t && t.value === "," && node2.loc.end.line === t.loc.start.line ? t : null;
+    };
+    var isValidOrders = {
+      asc: (a, b) => a <= b,
+      ascI: (a, b) => a.toLowerCase() <= b.toLowerCase(),
+      ascN: (a, b) => naturalCompare(a, b) <= 0,
+      ascIN: (a, b) => naturalCompare(a.toLowerCase(), b.toLowerCase()) <= 0,
+      desc: (a, b) => isValidOrders.asc(b, a),
+      descI: (a, b) => isValidOrders.ascI(b, a),
+      descN: (a, b) => isValidOrders.ascN(b, a),
+      descIN: (a, b) => isValidOrders.ascIN(b, a)
+    };
+    var getPropertyName = (node2) => {
+      let prop;
+      switch (node2 && node2.type) {
+        case "Property":
+        case "MethodDefinition":
+          prop = node2.key;
+          break;
+        case "MemberExpression":
+          prop = node2.property;
+          break;
+      }
+      switch (prop && prop.type) {
+        case "Literal":
+          return String(prop.value);
+        case "TemplateLiteral":
+          if (prop.expressions.length === 0 && prop.quasis.length === 1) {
+            return prop.quasis[0].value.cooked;
+          }
+          break;
+        case "Identifier":
+          if (!node2.computed) {
+            return prop.name;
+          }
+          break;
+      }
+      return node2.key && node2.key.name || null;
+    };
+  }
+});
+
+// node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/index.js
+var require_eslint_plugin_sort_keys = __commonJS({
+  "node_modules/.pnpm/eslint-plugin-sort-keys@2.3.5/node_modules/eslint-plugin-sort-keys/index.js"(exports, module2) {
+    "use strict";
+    module2.exports.rules = {
+      "sort-keys-fix": require_sort_keys_fix()
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  GLOB_ALL_SRC: () => GLOB_ALL_SRC,
+  GLOB_CSS: () => GLOB_CSS,
+  GLOB_EXCLUDE: () => GLOB_EXCLUDE,
+  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_SCSS: () => GLOB_SCSS,
+  GLOB_SRC: () => GLOB_SRC,
+  GLOB_SRC_EXT: () => GLOB_SRC_EXT,
+  GLOB_STYLE: () => GLOB_STYLE,
+  GLOB_TESTS: () => GLOB_TESTS,
+  GLOB_TS: () => GLOB_TS,
+  GLOB_TSX: () => GLOB_TSX,
+  GLOB_YAML: () => GLOB_YAML,
+  combine: () => combine,
+  comments: () => comments,
+  default: () => jsse,
+  ignores: () => ignores,
+  imports: () => imports,
+  isCI: () => isCI,
+  isInEditor: () => isInEditor,
+  javascript: () => javascript,
+  jsdoc: () => jsdoc,
+  jsonc: () => jsonc,
+  jsse: () => jsse,
+  node: () => node,
+  parserJsonc: () => import_jsonc_eslint_parser.default,
+  parserTs: () => parserTs,
+  pluginEslintComments: () => import_eslint_plugin_eslint_comments.default,
+  pluginImport: () => pluginImport,
+  pluginJsdoc: () => import_eslint_plugin_jsdoc.default,
+  pluginJsonc: () => pluginJsonc,
+  pluginNoOnlyTests: () => import_eslint_plugin_no_only_tests.default,
+  pluginNode: () => import_eslint_plugin_n.default,
+  pluginReact: () => import_eslint_plugin_react.default,
+  pluginReactHooks: () => import_eslint_plugin_react_hooks.default,
+  pluginReactRefresh: () => pluginReactRefresh,
+  pluginSortKeys: () => pluginSortKeys,
+  pluginStylistic: () => import_eslint_plugin.default,
+  pluginTailwind: () => import_eslint_plugin_tailwindcss.default,
+  pluginTs: () => import_eslint_plugin2.default,
+  pluginUnicorn: () => import_eslint_plugin_unicorn.default,
+  pluginUnusedImports: () => import_eslint_plugin_unused_imports.default,
+  pluginVitest: () => import_eslint_plugin_vitest.default,
+  react: () => react,
+  reactHooks: () => reactHooks,
+  renameRules: () => renameRules,
+  sortPackageJson: () => sortPackageJson,
+  sortTsconfig: () => sortTsconfig,
+  test: () => test,
+  typescript: () => typescript,
+  unicorn: () => unicorn
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/plugins.ts
+var import_eslint_plugin = __toESM(require("@stylistic/eslint-plugin"), 1);
+var import_eslint_plugin2 = __toESM(require("@typescript-eslint/eslint-plugin"), 1);
+var parserTs = __toESM(require("@typescript-eslint/parser"), 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 pluginJsonc = __toESM(require("eslint-plugin-jsonc"), 1);
+var import_eslint_plugin_n = __toESM(require("eslint-plugin-n"), 1);
+var import_eslint_plugin_no_only_tests = __toESM(require("eslint-plugin-no-only-tests"), 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 pluginReactRefresh = __toESM(require("eslint-plugin-react-refresh"), 1);
+var pluginSortKeys = __toESM(require_eslint_plugin_sort_keys(), 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_tailwindcss = __toESM(require("eslint-plugin-tailwindcss"), 1);
+var import_eslint_plugin_vitest = __toESM(require("eslint-plugin-vitest"), 1);
+var import_jsonc_eslint_parser = __toESM(require("jsonc-eslint-parser"), 1);
+
+// src/configs/comments.ts
+function comments() {
+  return [
+    {
+      name: "jsse:eslint-comments",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        "eslint-comments": import_eslint_plugin_eslint_comments.default
+      },
+      rules: {
+        "eslint-comments/no-aggregating-enable": "error",
+        "eslint-comments/no-duplicate-disable": "error",
+        "eslint-comments/no-unlimited-disable": "error",
+        "eslint-comments/no-unused-enable": "error"
+      }
+    }
+  ];
+}
+
+// src/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_LESS = "**/*.less";
+var GLOB_SCSS = "**/*.scss";
+var GLOB_JSON = "**/*.json";
+var GLOB_JSON5 = "**/*.json5";
+var GLOB_JSONC = "**/*.jsonc";
+var GLOB_MARKDOWN = "**/*.md";
+var GLOB_YAML = "**/*.y?(a)ml";
+var GLOB_HTML = "**/*.htm?(l)";
+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_YAML, GLOB_HTML];
+var GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/output",
+  "**/out",
+  "**/coverage",
+  "**/temp",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.next",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts",
+  "**/scratch",
+  "**/tmp",
+  "**/temp"
+];
+
+// src/configs/ignores.ts
+function ignores() {
+  return [
+    {
+      ignores: GLOB_EXCLUDE
+    }
+  ];
+}
+
+// src/configs/imports.ts
+function imports(options = {}) {
+  const { stylistic = true } = options;
+  return [
+    {
+      name: "jsse:imports",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        import: pluginImport
+      },
+      rules: {
+        "import/first": "error",
+        "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",
+        ...stylistic ? {
+          "import/newline-after-import": ["error", { considerComments: true, count: 1 }]
+        } : {}
+      }
+    }
+  ];
+}
+
+// src/configs/javascript.ts
+var import_js = __toESM(require("@eslint/js"), 1);
+var import_globals = __toESM(require("globals"), 1);
+function javascript(options = {}) {
+  const { isInEditor: isInEditor2 = false, overrides = {} } = options;
+  return [
+    {
+      languageOptions: {
+        ecmaVersion: 2022,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        globals: {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          ...import_globals.default.browser,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          ...import_globals.default.es2021,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          ...import_globals.default.node,
+          document: "readonly",
+          navigator: "readonly",
+          window: "readonly"
+        },
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          ecmaVersion: 2022,
+          sourceType: "module"
+        },
+        sourceType: "module"
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: options.reportUnusedDisableDirectives ?? true
+      },
+      name: "jsse:javascript",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        "unused-imports": import_eslint_plugin_unused_imports.default
+      },
+      rules: {
+        ...import_js.default.configs.recommended.rules,
+        "accessor-pairs": ["error", { enforceForClassMembers: true, setWithoutGet: true }],
+        "array-callback-return": "error",
+        "arrow-parens": ["error", "as-needed", { requireForBlockBody: true }],
+        "block-scoped-var": "error",
+        "constructor-super": "error",
+        "default-case-last": "error",
+        "dot-notation": ["error", { allowKeywords: true }],
+        eqeqeq: ["error", "smart"],
+        "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-control-regex": "error",
+        "no-debugger": "error",
+        "no-delete-var": "error",
+        "no-dupe-args": "error",
+        "no-dupe-class-members": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "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-fallthrough": "error",
+        "no-func-assign": "error",
+        "no-global-assign": "error",
+        "no-implied-eval": "error",
+        "no-import-assign": "error",
+        "no-invalid-regexp": "error",
+        "no-invalid-this": "error",
+        "no-irregular-whitespace": "error",
+        "no-iterator": "error",
+        "no-labels": ["error", { allowLoop: false, allowSwitch: false }],
+        "no-lone-blocks": "error",
+        "no-loss-of-precision": "error",
+        "no-misleading-character-class": "error",
+        "no-multi-str": "error",
+        "no-nested-ternary": "off",
+        "no-new": "error",
+        "no-new-func": "error",
+        "no-new-object": "error",
+        "no-new-symbol": "error",
+        "no-new-wrappers": "error",
+        "no-obj-calls": "error",
+        "no-octal": "error",
+        "no-octal-escape": "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",
+          "DebuggerStatement",
+          "LabeledStatement",
+          "WithStatement",
+          "TSEnumDeclaration[const=true]",
+          "TSExportAssignment"
+        ],
+        "no-self-assign": ["error", { props: true }],
+        "no-self-compare": "error",
+        "no-sequences": "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": "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-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: true,
+            allowTaggedTemplates: true,
+            allowTernary: true
+          }
+        ],
+        "no-unused-vars": [
+          "error",
+          {
+            args: "none",
+            caughtErrors: "none",
+            ignoreRestSiblings: true,
+            vars: "all"
+          }
+        ],
+        "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-rename": "error",
+        "no-useless-return": "error",
+        "no-var": "error",
+        "no-void": "error",
+        "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": [
+          "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",
+        "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": isInEditor2 ? "off" : "error",
+        "unused-imports/no-unused-vars": [
+          "error",
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            vars: "all",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        "use-isnan": ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }],
+        "valid-typeof": ["error", { requireStringLiterals: true }],
+        "vars-on-top": "error",
+        yoda: ["error", "never"],
+        ...overrides
+      }
+    },
+    {
+      files: [`scripts/${GLOB_SRC}`, `cli.${GLOB_SRC_EXT}`],
+      name: "jsse:scripts-overrides",
+      rules: {
+        "no-console": "off"
+      }
+    }
+  ];
+}
+
+// src/configs/jsdoc.ts
+function jsdoc(options = {}) {
+  const { stylistic = true } = options;
+  return [
+    {
+      name: "jsse:jsdoc",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        jsdoc: import_eslint_plugin_jsdoc.default
+      },
+      rules: {
+        "jsdoc/check-access": "warn",
+        "jsdoc/check-param-names": "warn",
+        "jsdoc/check-property-names": "warn",
+        "jsdoc/check-types": "warn",
+        "jsdoc/empty-tags": "warn",
+        "jsdoc/implements-on-classes": "warn",
+        "jsdoc/no-defaults": "warn",
+        "jsdoc/no-multi-asterisks": "warn",
+        "jsdoc/require-param-name": "warn",
+        "jsdoc/require-property": "warn",
+        "jsdoc/require-property-description": "warn",
+        "jsdoc/require-property-name": "warn",
+        "jsdoc/require-returns-check": "warn",
+        "jsdoc/require-returns-description": "warn",
+        "jsdoc/require-yields-check": "warn",
+        ...stylistic ? {
+          "jsdoc/check-alignment": "warn",
+          "jsdoc/multiline-blocks": "warn"
+        } : {}
+      }
+    }
+  ];
+}
+
+// src/configs/jsonc.ts
+function jsonc(options = {}) {
+  const { stylistic = true, overrides = {} } = options;
+  const { indent = 2 } = typeof stylistic === "boolean" ? {} : stylistic;
+  return [
+    {
+      name: "jsse:jsonc:setup",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+        jsonc: pluginJsonc
+      }
+    },
+    {
+      files: [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
+      languageOptions: {
+        parser: import_jsonc_eslint_parser.default
+      },
+      name: "jsse:jsonc:rules",
+      rules: {
+        "jsonc/no-bigint-literals": "error",
+        "jsonc/no-binary-expression": "error",
+        "jsonc/no-binary-numeric-literals": "error",
+        "jsonc/no-dupe-keys": "error",
+        "jsonc/no-escape-sequence-in-identifier": "error",
+        "jsonc/no-floating-decimal": "error",
+        "jsonc/no-hexadecimal-numeric-literals": "error",
+        "jsonc/no-infinity": "error",
+        "jsonc/no-multi-str": "error",
+        "jsonc/no-nan": "error",
+        "jsonc/no-number-props": "error",
+        "jsonc/no-numeric-separators": "error",
+        "jsonc/no-octal": "error",
+        "jsonc/no-octal-escape": "error",
+        "jsonc/no-octal-numeric-literals": "error",
+        "jsonc/no-parenthesized": "error",
+        "jsonc/no-plus-sign": "error",
+        "jsonc/no-regexp-literals": "error",
+        "jsonc/no-sparse-arrays": "error",
+        "jsonc/no-template-literals": "error",
+        "jsonc/no-undefined-value": "error",
+        "jsonc/no-unicode-codepoint-escapes": "error",
+        "jsonc/no-useless-escape": "error",
+        "jsonc/space-unary-ops": "error",
+        "jsonc/valid-json-number": "error",
+        "jsonc/vue-custom-block/no-parsing-error": "error",
+        ...stylistic ? {
+          "jsonc/array-bracket-spacing": ["error", "never"],
+          "jsonc/comma-dangle": ["error", "never"],
+          "jsonc/comma-style": ["error", "last"],
+          "jsonc/indent": ["error", indent],
+          "jsonc/key-spacing": ["error", { afterColon: true, beforeColon: false }],
+          "jsonc/object-curly-newline": ["error", { consistent: true, multiline: true }],
+          "jsonc/object-curly-spacing": ["error", "always"],
+          "jsonc/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
+          "jsonc/quote-props": "error",
+          "jsonc/quotes": "error"
+        } : {},
+        ...overrides
+      }
+    }
+  ];
+}
+
+// src/configs/node.ts
+function node() {
+  return [
+    {
+      name: "jsse:node",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        node: import_eslint_plugin_n.default
+      },
+      rules: {
+        "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/prefer-global/buffer": ["error", "never"],
+        "node/prefer-global/process": ["error", "never"],
+        "node/process-exit-as-throw": "error"
+      }
+    }
+  ];
+}
+
+// src/configs/ts/typescript-language-options.ts
+var import_node_process = __toESM(require("process"), 1);
+function parserOptionProject(tsconfigPath) {
+  if (typeof tsconfigPath === "string") {
+    return [tsconfigPath];
+  }
+  return tsconfigPath;
+}
+function typescriptLanguageOptions(options) {
+  const { parserOptions = {}, tsconfigPath, react: react2 } = options ?? {};
+  if (react2) {
+    return {
+      parser: parserTs,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      parserOptions: {
+        ecmaFeatures: { jsx: true, modules: true },
+        jsxPragma: null,
+        sourceType: "module",
+        ...tsconfigPath ? {
+          project: parserOptionProject(tsconfigPath),
+          tsconfigRootDir: import_node_process.default.cwd()
+        } : {},
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ...parserOptions
+      }
+    };
+  }
+  return {
+    parser: parserTs,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    parserOptions: {
+      sourceType: "module",
+      ...tsconfigPath ? {
+        project: parserOptionProject(tsconfigPath),
+        tsconfigRootDir: import_node_process.default.cwd()
+      } : {},
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ...parserOptions
+    }
+  };
+}
+
+// src/configs/react.ts
+var reactRules = {
+  "react-hooks/exhaustive-deps": "error",
+  "react-hooks/rules-of-hooks": "error",
+  "react/boolean-prop-naming": [
+    "error",
+    {
+      rule: ["^(is|has)[A-Z]([A-Za-z0-9]?)+", "|^(debug|disabled|hidden|required|selected|highlight)$"].join(""),
+      validateNested: true
+    }
+  ],
+  "react/button-has-type": "error",
+  "react/function-component-definition": [
+    "error",
+    {
+      namedComponents: "function-declaration",
+      unnamedComponents: "arrow-function"
+    }
+  ],
+  "react/hook-use-state": "error",
+  "react/iframe-missing-sandbox": "error",
+  "react/jsx-boolean-value": "error",
+  "react/jsx-child-element-spacing": "error",
+  "react/jsx-closing-bracket-location": [
+    "error",
+    {
+      nonEmpty: "tag-aligned",
+      selfClosing: false
+    }
+  ],
+  "react/jsx-closing-tag-location": "error",
+  "react/jsx-curly-brace-presence": [
+    "error",
+    {
+      children: "never",
+      propElementValues: "always",
+      props: "never"
+    }
+  ],
+  "react/jsx-curly-newline": [
+    "error",
+    {
+      multiline: "consistent",
+      singleline: "forbid"
+    }
+  ],
+  "react/jsx-curly-spacing": ["error", "never"],
+  "react/jsx-equals-spacing": ["error", "never"],
+  "react/jsx-first-prop-new-line": "error",
+  "react/jsx-fragments": ["error", "syntax"],
+  "react/jsx-indent": ["error", 2],
+  "react/jsx-indent-props": ["error", 2],
+  "react/jsx-key": "warn",
+  "react/jsx-max-props-per-line": [
+    "error",
+    {
+      maximum: 3,
+      when: "multiline"
+    }
+  ],
+  "react/jsx-no-bind": [
+    "error",
+    {
+      allowArrowFunctions: true
+    }
+  ],
+  "react/jsx-no-comment-textnodes": "error",
+  "react/jsx-no-constructed-context-values": "error",
+  "react/jsx-no-duplicate-props": [
+    "error",
+    {
+      ignoreCase: true
+    }
+  ],
+  "react/jsx-no-script-url": "error",
+  "react/jsx-no-target-blank": [
+    "error",
+    {
+      forms: true,
+      warnOnSpreadAttributes: true
+    }
+  ],
+  "react/jsx-no-undef": "error",
+  "react/jsx-no-useless-fragment": "error",
+  "react/jsx-pascal-case": "error",
+  "react/jsx-props-no-multi-spaces": "error",
+  "react/jsx-sort-props": [
+    "error",
+    {
+      callbacksLast: true,
+      noSortAlphabetically: true,
+      reservedFirst: true,
+      shorthandFirst: true
+    }
+  ],
+  "react/jsx-tag-spacing": [
+    "error",
+    {
+      afterOpening: "never",
+      beforeClosing: "never",
+      beforeSelfClosing: "never",
+      closingSlash: "never"
+    }
+  ],
+  "react/jsx-uses-react": "error",
+  "react/jsx-uses-vars": "error",
+  "react/jsx-wrap-multilines": [
+    "error",
+    {
+      arrow: "parens-new-line",
+      assignment: "parens-new-line",
+      condition: "ignore",
+      declaration: "parens-new-line",
+      logical: "ignore",
+      prop: "ignore",
+      return: "parens-new-line"
+    }
+  ],
+  "react/no-access-state-in-setstate": "error",
+  "react/no-array-index-key": "error",
+  "react/no-arrow-function-lifecycle": "error",
+  "react/no-children-prop": "error",
+  "react/no-danger": "error",
+  "react/no-danger-with-children": "error",
+  "react/no-deprecated": "error",
+  "react/no-did-update-set-state": "error",
+  "react/no-direct-mutation-state": "error",
+  "react/no-find-dom-node": "error",
+  "react/no-invalid-html-attribute": "error",
+  "react/no-is-mounted": "error",
+  "react/no-namespace": "error",
+  "react/no-redundant-should-component-update": "error",
+  "react/no-render-return-value": "error",
+  "react/no-string-refs": [
+    "error",
+    {
+      noTemplateLiterals: true
+    }
+  ],
+  "react/no-this-in-sfc": "error",
+  "react/no-typos": "error",
+  "react/no-unescaped-entities": "error",
+  "react/no-unsafe": "error",
+  // "react/no-unused-prop-types": "error",
+  "react/no-unused-state": "error",
+  "react/prefer-read-only-props": "error",
+  // "react/prop-types": "error",
+  "react/react-in-jsx-scope": "off",
+  "react/require-default-props": [
+    "error",
+    {
+      forbidDefaultForRequired: true,
+      ignoreFunctionalComponents: true
+    }
+  ],
+  "react/self-closing-comp": "error",
+  "react/state-in-constructor": ["error", "never"],
+  "react/static-property-placement": "error",
+  "react/style-prop-object": [
+    "error",
+    {
+      allow: ["FormattedNumber"]
+    }
+  ],
+  "react/void-dom-elements-no-children": "error"
+};
+function reactHooks() {
+  return [
+    {
+      files: [GLOB_SRC],
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      plugins: { "react-hooks": import_eslint_plugin_react_hooks.default },
+      rules: {
+        "react-hooks/exhaustive-deps": "error",
+        "react-hooks/rules-of-hooks": "error"
+      }
+    }
+  ];
+}
+function reactRefreshFlatConfigs() {
+  return [
+    {
+      files: [GLOB_SRC],
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      plugins: { "react-refresh": pluginReactRefresh },
+      rules: {
+        "react-refresh/only-export-components": "error"
+      }
+    },
+    {
+      files: ["**/*.stories.tsx"],
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      plugins: { "react-refresh": pluginReactRefresh },
+      rules: {
+        "react-refresh/only-export-components": "off"
+      }
+    }
+  ];
+}
+function reactRecomendedRules() {
+  return {
+    "react/display-name": 2,
+    "react/jsx-key": 2,
+    "react/jsx-no-comment-textnodes": 2,
+    "react/jsx-no-duplicate-props": 2,
+    "react/jsx-no-target-blank": 2,
+    "react/jsx-no-undef": 2,
+    "react/jsx-uses-react": 2,
+    "react/jsx-uses-vars": 2,
+    "react/no-children-prop": 2,
+    "react/no-danger-with-children": 2,
+    "react/no-deprecated": 2,
+    "react/no-direct-mutation-state": 2,
+    "react/no-find-dom-node": 2,
+    "react/no-is-mounted": 2,
+    "react/no-render-return-value": 2,
+    "react/no-string-refs": 2,
+    "react/no-unescaped-entities": 2,
+    // this rule has a bug w/ typescript-eslint-parser
+    // 'react/no-unknown-property': 2,
+    "react/no-unsafe": 0,
+    "react/prop-types": 1,
+    "react/react-in-jsx-scope": 2,
+    "react/require-render-return": 2
+  };
+}
+function react(options) {
+  const { parserOptions = {}, tsconfigPath, react: react2, reactRefresh } = options ?? {};
+  const config = [
+    {
+      files: [GLOB_SRC],
+      languageOptions: typescriptLanguageOptions({
+        parserOptions,
+        react: react2,
+        tsconfigPath
+      }),
+      name: "jsse:react:setup",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        react: import_eslint_plugin_react.default,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        "react-hooks": import_eslint_plugin_react_hooks.default
+      }
+    },
+    {
+      files: [GLOB_SRC],
+      plugins: {
+        // react: pluginReact,
+        // },
+      },
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      rules: {
+        ...reactRecomendedRules(),
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        ...import_eslint_plugin_react.default.configs["jsx-runtime"].rules,
+        ...reactRules
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
+      }
+    }
+  ];
+  if (reactRefresh) {
+    config.push(...reactRefreshFlatConfigs());
+  }
+  return config;
+}
+
+// src/configs/sort.ts
+function sortPackageJson() {
+  return [
+    {
+      files: ["**/package.json"],
+      name: "jsse: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",
+              "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"
+            ],
+            pathPattern: "^$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^resolutions$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^pnpm.overrides$"
+          },
+          {
+            order: ["types", "import", "require", "default"],
+            pathPattern: "^exports.*$"
+          }
+        ]
+      }
+    }
+  ];
+}
+function sortTsconfig() {
+  return [
+    {
+      files: ["**/tsconfig.json", "**/tsconfig.*.json"],
+      name: "antfu:sort-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$"
+          }
+        ]
+      }
+    }
+  ];
+}
+
+// src/utils.ts
+var import_node_process2 = __toESM(require("process"), 1);
+function combine(...configs) {
+  return configs.flatMap((config) => Array.isArray(config) ? config : [config]);
+}
+function renameRules(rules, from, to) {
+  if (from === to) {
+    return rules;
+  }
+  return Object.fromEntries(
+    Object.entries(rules).map(([key, value]) => {
+      if (key.startsWith(from)) {
+        return [to + key.slice(from.length), value];
+      }
+      return [key, value];
+    })
+  );
+}
+function isCI() {
+  return !!import_node_process2.default.env.CI;
+}
+function isInEditor() {
+  return !!((import_node_process2.default.env.VSCODE_PID || import_node_process2.default.env.JETBRAINS_IDE) && !isCI());
+}
+
+// src/configs/test.ts
+function test(options = {}) {
+  const { isInEditor: isInEditor2 = false, overrides = {} } = options;
+  return [
+    {
+      name: "jsse:test:setup",
+      plugins: {
+        test: {
+          ...import_eslint_plugin_vitest.default,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          rules: {
+            ...import_eslint_plugin_vitest.default.rules,
+            // extend `test/no-only-tests` rule
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            ...import_eslint_plugin_no_only_tests.default.rules
+          }
+        }
+      }
+    },
+    {
+      files: GLOB_TESTS,
+      name: "jsse:test:rules",
+      rules: {
+        "test/consistent-test-it": ["error", { fn: "it", withinDescribe: "it" }],
+        "test/no-identical-title": "error",
+        "test/no-only-tests": isInEditor2 ? "off" : isCI() ? "error" : "warn",
+        "test/prefer-hooks-in-order": "error",
+        "test/prefer-lowercase-title": "error",
+        "unicorn/no-null": "off",
+        ...overrides
+      }
+    }
+  ];
+}
+
+// src/configs/ts/typescript-rules.ts
+function typescriptRulesTypeAware() {
+  return {
+    "@typescript-eslint/await-thenable": "error",
+    "@typescript-eslint/no-for-in-array": "error",
+    "no-implied-eval": "off",
+    "@typescript-eslint/consistent-type-exports": [
+      "error",
+      {
+        fixMixedExportsWithInlineTypeSpecifier: true
+      }
+    ],
+    "dot-notation": "off",
+    "@typescript-eslint/dot-notation": [
+      "error",
+      {
+        allowPattern: "^_",
+        allowKeywords: true
+      }
+    ],
+    "@typescript-eslint/no-implied-eval": "error",
+    "@typescript-eslint/no-misused-promises": "error",
+    "@typescript-eslint/no-unnecessary-qualifier": "error",
+    "@typescript-eslint/no-unnecessary-type-arguments": "off",
+    "@typescript-eslint/no-unnecessary-type-assertion": "error",
+    "no-throw-literal": "off",
+    "@typescript-eslint/no-throw-literal": "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",
+    "@typescript-eslint/naming-convention": [
+      "error",
+      {
+        selector: ["variable"],
+        modifiers: ["global"],
+        format: ["camelCase", "snake_case", "UPPER_CASE", "PascalCase"],
+        leadingUnderscore: "allowSingleOrDouble",
+        trailingUnderscore: "allow",
+        filter: {
+          regex: "[- ]",
+          match: false
+        }
+      },
+      {
+        selector: [
+          "classProperty",
+          "objectLiteralProperty",
+          "typeProperty",
+          "classMethod",
+          "objectLiteralMethod",
+          "typeMethod",
+          "accessor",
+          "enumMember"
+        ],
+        format: null,
+        modifiers: ["requiresQuotes"]
+      },
+      {
+        selector: [
+          "variable",
+          "function",
+          "classProperty",
+          "objectLiteralProperty",
+          "parameterProperty",
+          "classMethod",
+          "objectLiteralMethod",
+          "typeMethod",
+          "accessor"
+        ],
+        format: ["camelCase", "snake_case", "PascalCase"],
+        leadingUnderscore: "allowSingleOrDouble",
+        trailingUnderscore: "allow",
+        filter: {
+          // also allow when '/' is in object key
+          regex: "^[0-9]|[- ]|[/]",
+          match: false
+        }
+      },
+      {
+        selector: "typeLike",
+        format: ["PascalCase"]
+      },
+      {
+        selector: "variable",
+        types: ["boolean"],
+        format: ["PascalCase", "camelCase"],
+        prefix: ["is", "has", "can", "should", "will", "did"]
+      },
+      {
+        selector: "interface",
+        format: ["PascalCase"]
+      },
+      {
+        selector: "typeParameter",
+        filter: "^T$|^[A-Z][a-zA-Z]+$",
+        format: ["PascalCase"]
+      }
+    ],
+    "@typescript-eslint/no-floating-promises": [
+      "error",
+      {
+        ignoreVoid: true,
+        ignoreIIFE: true
+      }
+    ]
+  };
+}
+function typescriptRulesTypeOblivious() {
+  return {
+    eqeqeq: "error",
+    camelcase: "off",
+    yoda: "error",
+    "arrow-parens": "off",
+    "no-console": [
+      "warn",
+      {
+        allow: [
+          "log",
+          "warn",
+          "dir",
+          "time",
+          "timeEnd",
+          "timeLog",
+          "trace",
+          "assert",
+          "clear",
+          "count",
+          "countReset",
+          "group",
+          "groupEnd",
+          "table",
+          "debug",
+          "info",
+          "dirxml",
+          "error",
+          "groupCollapsed",
+          "Console",
+          "profile",
+          "profileEnd",
+          "timeStamp",
+          "context"
+        ]
+      }
+    ],
+    "object-curly-spacing": "off",
+    "@typescript-eslint/object-curly-spacing": "off",
+    "@typescript-eslint/no-inferrable-types": "off",
+    "@typescript-eslint/prefer-ts-expect-error": "error",
+    "@typescript-eslint/consistent-type-imports": [
+      "error",
+      {
+        prefer: "type-imports",
+        fixStyle: "separate-type-imports"
+      }
+    ],
+    "@typescript-eslint/adjacent-overload-signatures": "error",
+    "@typescript-eslint/ban-types": [
+      "warn",
+      {
+        extendDefaults: false,
+        types: {
+          String: {
+            message: 'Use "string" instead',
+            fixWith: "string"
+          },
+          Boolean: {
+            message: 'Use "boolean" instead',
+            fixWith: "boolean"
+          },
+          Number: {
+            message: 'Use "number" instead',
+            fixWith: "number"
+          },
+          BigInt: {
+            message: "Use `bigint` instead.",
+            fixWith: "bigint"
+          },
+          Object: {
+            message: "The `Object` type is mostly the same as `unknown`. You probably want `Record<string, unknown>` instead. See https://github.com/typescript-eslint/typescript-eslint/pull/848",
+            fixWith: "Record<string, unknown>"
+          },
+          object: {
+            message: "The `object` type is hard to use. Use `Record<string, unknown>` instead. See: https://github.com/typescript-eslint/typescript-eslint/pull/848",
+            fixWith: "Record<string, unknown>"
+          },
+          Symbol: {
+            message: 'Use "symbol" instead',
+            fixWith: "symbol"
+          },
+          Function: {
+            message: 'The "Function" type accepts any function-like value.\nIt provides no type safety when calling the function, which can be a common source of bugs.\nIt also accepts things like class declarations, which will throw at runtime as they will not be called with "new".\nIf you are expecting the function to accept certain arguments, you should explicitly define the function shape.'
+          },
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          "{}": {
+            message: "The `{}` type is mostly the same as `unknown`. You probably want `Record<string, unknown>` instead.",
+            fixWith: "Record<string, unknown>"
+          },
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          "[]": "Don't use the empty array type `[]`. It only allows empty arrays. Use `SomeType[]` instead.",
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          "[[]]": "Don't use `[[]]`. It only allows an array with a single element which is an empty array. Use `SomeType[][]` instead.",
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          "[[[]]]": "Don't use `[[[]]]`. Use `SomeType[][][]` instead."
+        }
+      }
+    ],
+    "@typescript-eslint/consistent-type-assertions": "error",
+    "@typescript-eslint/consistent-type-definitions": ["error", "type"],
+    "@typescript-eslint/member-ordering": [
+      "warn",
+      {
+        default: "never",
+        classes: ["field", "constructor", "method"]
+      }
+    ],
+    "no-array-constructor": "off",
+    "@typescript-eslint/no-array-constructor": "error",
+    "@typescript-eslint/no-explicit-any": "error",
+    "@typescript-eslint/no-misused-new": "error",
+    "@typescript-eslint/no-namespace": [
+      "error",
+      {
+        allowDeclarations: false,
+        allowDefinitionFiles: false
+      }
+    ],
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": [
+      "warn",
+      {
+        vars: "all",
+        args: "none",
+        argsIgnorePattern: "^_",
+        varsIgnorePattern: "^_",
+        caughtErrorsIgnorePattern: "^_"
+      }
+    ],
+    "no-use-before-define": "off",
+    "@typescript-eslint/no-use-before-define": [
+      "error",
+      {
+        functions: false,
+        classes: true,
+        variables: true,
+        enums: true,
+        typedefs: true
+      }
+    ],
+    "@typescript-eslint/prefer-namespace-keyword": "warn",
+    "@typescript-eslint/typedef": [
+      "warn",
+      {
+        arrayDestructuring: false,
+        arrowParameter: false,
+        memberVariableDeclaration: true,
+        objectDestructuring: false,
+        parameter: true,
+        propertyDeclaration: true,
+        variableDeclaration: false,
+        variableDeclarationIgnoreFunction: true
+      }
+    ],
+    "accessor-pairs": "error",
+    "for-direction": "warn",
+    "guard-for-in": "error",
+    "max-lines": [
+      "warn",
+      {
+        max: 2e3
+      }
+    ],
+    "no-async-promise-executor": "error",
+    "no-bitwise": [
+      "warn",
+      {
+        allow: ["^", "<<", ">>", ">>>", "^=", "<<=", ">>=", ">>>=", "~"]
+      }
+    ],
+    "no-caller": "error",
+    "no-compare-neg-zero": "error",
+    "no-cond-assign": "error",
+    "no-constant-condition": "warn",
+    "no-control-regex": "error",
+    "no-debugger": "warn",
+    "no-delete-var": "error",
+    "no-duplicate-case": "error",
+    "no-empty": "warn",
+    "no-empty-character-class": "error",
+    "no-empty-pattern": "warn",
+    "no-eval": "warn",
+    "no-ex-assign": "error",
+    "no-extend-native": "error",
+    "no-extra-boolean-cast": "warn",
+    "no-extra-label": "warn",
+    "no-fallthrough": "error",
+    "no-func-assign": "warn",
+    "no-implied-eval": "error",
+    "no-invalid-regexp": "error",
+    "no-label-var": "error",
+    "no-lone-blocks": "warn",
+    "no-misleading-character-class": "error",
+    "no-multi-str": "error",
+    "no-new": "warn",
+    "no-new-func": "error",
+    "no-new-wrappers": "warn",
+    "no-octal": "error",
+    "no-octal-escape": "error",
+    "no-regex-spaces": "error",
+    "no-return-assign": "error",
+    "no-script-url": "warn",
+    "no-self-assign": "error",
+    "no-self-compare": "error",
+    "no-sequences": "error",
+    "no-shadow-restricted-names": "error",
+    "no-sparse-arrays": "error",
+    "no-unmodified-loop-condition": "warn",
+    "no-unsafe-finally": "error",
+    "no-unused-expressions": "off",
+    "@typescript-eslint/no-unused-expressions": "error",
+    "no-unused-labels": "error",
+    "no-useless-catch": "warn",
+    "no-useless-concat": "error",
+    "no-var": "error",
+    "no-void": [
+      "error",
+      {
+        allowAsStatement: true
+      }
+    ],
+    "no-with": "error",
+    "prefer-const": "error",
+    "require-atomic-updates": "error",
+    "require-yield": "warn",
+    strict: ["error", "never"],
+    "use-isnan": "error",
+    "no-useless-constructor": "off",
+    "@typescript-eslint/no-useless-constructor": "error",
+    "@typescript-eslint/no-unnecessary-type-constraint": "error",
+    "@typescript-eslint/brace-style": [
+      "error",
+      "1tbs",
+      {
+        allowSingleLine: false
+      }
+    ],
+    "comma-spacing": "off",
+    "@typescript-eslint/comma-spacing": [
+      "error",
+      {
+        before: false,
+        after: true
+      }
+    ],
+    "default-param-last": "off",
+    "@typescript-eslint/default-param-last": "error",
+    "func-call-spacing": "off",
+    "@typescript-eslint/func-call-spacing": ["error", "never"],
+    "keyword-spacing": "off",
+    "@typescript-eslint/keyword-spacing": "error",
+    "lines-between-class-members": "off",
+    "@typescript-eslint/lines-between-class-members": [
+      "error",
+      "always",
+      {
+        exceptAfterSingleLine: true
+      }
+    ],
+    "no-dupe-class-members": "off",
+    "@typescript-eslint/no-dupe-class-members": "error",
+    "no-empty-function": "off",
+    "@typescript-eslint/no-empty-function": "error",
+    "no-extra-parens": "off",
+    "no-extra-semi": "off",
+    "@typescript-eslint/no-extra-semi": "error",
+    "no-loop-func": "off",
+    "@typescript-eslint/no-loop-func": "error",
+    "no-loss-of-precision": "off",
+    "@typescript-eslint/no-loss-of-precision": "error",
+    "no-redeclare": "off",
+    "@typescript-eslint/no-redeclare": "error",
+    "no-restricted-imports": "off",
+    "@typescript-eslint/no-restricted-imports": [
+      "error",
+      {
+        paths: ["error", "domain", "freelist", "smalloc", "punycode", "sys", "querystring", "colors"]
+      }
+    ],
+    "padding-line-between-statements": "off",
+    "@typescript-eslint/padding-line-between-statements": "off",
+    quotes: "off",
+    "@typescript-eslint/quotes": "off",
+    "space-before-function-paren": "off",
+    "@typescript-eslint/space-before-function-paren": "off",
+    "space-infix-ops": "off",
+    "@typescript-eslint/space-infix-ops": "error",
+    semi: "off",
+    "@typescript-eslint/semi": ["error", "always"],
+    "space-before-blocks": "off",
+    "@typescript-eslint/space-before-blocks": ["error", "always"],
+    "no-undef": "off",
+    "no-duplicate-imports": "off"
+  };
+}
+function typescriptRules({ typeAware }) {
+  return {
+    ...typescriptRulesTypeOblivious(),
+    ...typeAware ? typescriptRulesTypeAware() : {}
+  };
+}
+
+// src/configs/ts/typescript.ts
+function typescript(options) {
+  const { componentExts = [], overrides = {}, parserOptions = {}, tsconfigPath, react: react2, prefix } = options ?? {};
+  const tsPrefix = prefix?.from ?? "@typescript-eslint";
+  const tsPrefixTo = prefix?.to ?? "ts";
+  const tsrules = {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ...import_eslint_plugin2.default.configs["eslint-recommended"].overrides[0].rules,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ...import_eslint_plugin2.default.configs.strict.rules,
+    "no-invalid-this": "off",
+    ...typescriptRules(tsconfigPath ? { typeAware: true } : { typeAware: false }),
+    ...overrides
+  };
+  return [
+    {
+      // Install the plugins without globs, so they can be configured separately.
+      name: "jsse:typescript:setup",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        import: pluginImport,
+        [tsPrefixTo]: import_eslint_plugin2.default
+      }
+    },
+    {
+      name: "jsse:typescript:parser",
+      // use ts parser for js files as well!
+      files: [GLOB_SRC, ...componentExts.map((ext) => `**/*.${ext}`)],
+      languageOptions: typescriptLanguageOptions({
+        parserOptions,
+        react: react2,
+        tsconfigPath
+      })
+    },
+    {
+      name: "jsse:typescript:rules",
+      // only apply ts rules to ts files!
+      files: [GLOB_TS, GLOB_TSX, ...componentExts.map((ext) => `**/*.${ext}`)],
+      rules: renameRules(tsrules, tsPrefix, tsPrefixTo)
+    },
+    {
+      files: ["**/*.d.ts"],
+      name: "jsse:typescript:dts-overrides",
+      rules: {
+        "eslint-comments/no-unlimited-disable": "off",
+        "import/no-duplicates": "off",
+        "no-restricted-syntax": ["error", "[declare=true]"],
+        "unused-imports/no-unused-vars": "off"
+      }
+    },
+    {
+      files: ["**/*.{test,spec}.ts?(x)"],
+      name: "jsse:typescript:tests-overrides",
+      rules: {
+        "no-unused-expressions": "off"
+      }
+    },
+    {
+      files: ["**/*.js", "**/*.cjs"],
+      name: "jsse:typescript:javascript-overrides",
+      rules: {
+        "@typescript-eslint/no-require-imports": "off",
+        "@typescript-eslint/no-var-requires": "off"
+      }
+    }
+  ];
+}
+
+// src/configs/unicorn.ts
+function unicornOff() {
+  return {
+    "unicorn/catch-error-name": "off",
+    "unicorn/consistent-destructuring": "off",
+    "unicorn/no-array-for-each": "off",
+    "unicorn/no-array-reduce": "off",
+    "unicorn/no-nested-ternary": "off",
+    // conflicts with prettier
+    "unicorn/no-process-exit": "off",
+    "unicorn/prefer-module": "off",
+    "unicorn/prefer-optional-catch-binding": "off",
+    "unicorn/prefer-top-level-await": "off",
+    "unicorn/prevent-abbreviations": "off"
+    // Super insanely annoying rule
+  };
+}
+function unicorn() {
+  return [
+    {
+      name: "jsse:unicorn",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        unicorn: import_eslint_plugin_unicorn.default
+      },
+      rules: {
+        ...unicornOff(),
+        "unicorn/better-regex": "error",
+        "unicorn/custom-error-definition": "error",
+        // Pass error message when throwing errors
+        "unicorn/error-message": "error",
+        // Uppercase regex escapes
+        "unicorn/escape-case": "error",
+        "unicorn/explicit-length-check": "error",
+        "unicorn/filename-case": "error",
+        "unicorn/new-for-builtins": "error",
+        "unicorn/no-array-callback-reference": "error",
+        "unicorn/no-array-method-this-argument": "error",
+        "unicorn/no-array-push-push": "error",
+        "unicorn/no-console-spaces": "error",
+        "unicorn/no-for-loop": "error",
+        "unicorn/no-hex-escape": "error",
+        // Array.isArray instead of instanceof
+        "unicorn/no-instanceof-array": "error",
+        "unicorn/no-invalid-remove-event-listener": "error",
+        "unicorn/no-lonely-if": "error",
+        // conflicts with prettier
+        // Ban `new Array` as `Array` constructor's params are ambiguous
+        "unicorn/no-new-array": "error",
+        // Prevent deprecated `new Buffer()`
+        "unicorn/no-new-buffer": "error",
+        "unicorn/no-static-only-class": "error",
+        "unicorn/no-unnecessary-await": "error",
+        // Keep regex literals safe!
+        "unicorn/no-unsafe-regex": "error",
+        "unicorn/no-zero-fractions": `error`,
+        // Lowercase number formatting for octal, hex, binary (0x1ERROR instead of 0X1'error')
+        "unicorn/number-literal-case": "error",
+        "unicorn/prefer-add-event-listener": "error",
+        "unicorn/prefer-array-find": "error",
+        "unicorn/prefer-array-flat-map": "error",
+        "unicorn/prefer-array-index-of": "error",
+        "unicorn/prefer-array-some": "error",
+        "unicorn/prefer-at": "error",
+        "unicorn/prefer-blob-reading-methods": "error",
+        "unicorn/prefer-date-now": "error",
+        "unicorn/prefer-dom-node-append": "error",
+        "unicorn/prefer-dom-node-dataset": "error",
+        "unicorn/prefer-dom-node-remove": "error",
+        // textContent instead of innerText
+        "unicorn/prefer-dom-node-text-content": "error",
+        // includes over indexOf when checking for existence
+        "unicorn/prefer-includes": "error",
+        "unicorn/prefer-keyboard-event-key": "error",
+        "unicorn/prefer-math-trunc": "error",
+        "unicorn/prefer-modern-dom-apis": "error",
+        "unicorn/prefer-modern-math-apis": "error",
+        "unicorn/prefer-negative-index": "error",
+        // Prefer using the node: protocol
+        "unicorn/prefer-node-protocol": "error",
+        // Prefer using number properties like `Number.isNaN` rather than `isNaN`
+        "unicorn/prefer-number-properties": "error",
+        "unicorn/prefer-prototype-methods": "error",
+        "unicorn/prefer-query-selector": "error",
+        "unicorn/prefer-reflect-apply": "error",
+        "unicorn/prefer-regexp-test": "error",
+        "unicorn/prefer-string-replace-all": "error",
+        "unicorn/prefer-string-slice": "error",
+        // String methods startsWith/endsWith instead of more complicated stuff
+        "unicorn/prefer-string-starts-ends-with": "error",
+        "unicorn/prefer-string-trim-start-end": "error",
+        // Enforce throwing type error when throwing error while checking typeof
+        "unicorn/prefer-type-error": "error",
+        // Use new when throwing error
+        "unicorn/throw-new-error": "error"
+      }
+    }
+  ];
+}
+
+// src/factory.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_eslint_config_flat_gitignore = __toESM(require("eslint-config-flat-gitignore"), 1);
+var import_local_pkg = require("local-pkg");
+
+// src/configs/tailwind.ts
+function tailwind() {
+  return [
+    {
+      name: "jsse:tailwind",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        tailwindcss: import_eslint_plugin_tailwindcss.default
+      },
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      rules: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        ...import_eslint_plugin_tailwindcss.default.configs.recommended.rules
+      }
+    }
+  ];
+}
+
+// src/factory.ts
+var flatConfigProps = [
+  "files",
+  "ignores",
+  "languageOptions",
+  "linterOptions",
+  "processor",
+  "plugins",
+  "rules",
+  "settings"
+];
+function defaultOptions() {
+  return {
+    gitignore: import_eslint_config_flat_gitignore.default,
+    isInEditor: isInEditor(),
+    jsonc: true,
+    off: [],
+    reportUnusedDisableDirectives: true,
+    stylistic: true,
+    test: true,
+    tsPrefix: "@typescript-eslint",
+    typescript: (0, import_local_pkg.isPackageExists)("typescript")
+  };
+}
+function opts(options = {}) {
+  return {
+    ...defaultOptions(),
+    ...options
+  };
+}
+function jsse(options = {}, ...userConfigs) {
+  const {
+    isInEditor: isInEditor2,
+    typescript: enableTypeScript = (0, import_local_pkg.isPackageExists)("typescript"),
+    gitignore: enableGitignore = true,
+    overrides = {},
+    componentExts = [],
+    react: enableReact = (0, import_local_pkg.isPackageExists)("react"),
+    reportUnusedDisableDirectives,
+    tsPrefix,
+    off
+  } = opts(options);
+  const stylisticOptions = options.stylistic === false ? false : typeof options.stylistic === "object" ? options.stylistic : {};
+  if (stylisticOptions && !("jsx" in stylisticOptions))
+    stylisticOptions.jsx = options.jsx ?? true;
+  const configs = [];
+  if (enableGitignore && import_node_fs.default.existsSync(".gitignore")) {
+    configs.push([(0, import_eslint_config_flat_gitignore.default)()]);
+  }
+  configs.push(
+    ignores(),
+    javascript({
+      isInEditor: isInEditor2,
+      overrides: overrides.javascript,
+      reportUnusedDisableDirectives
+    }),
+    comments(),
+    node(),
+    jsdoc({
+      stylistic: stylisticOptions
+    }),
+    imports({
+      stylistic: stylisticOptions
+    }),
+    unicorn()
+  );
+  if (enableTypeScript) {
+    configs.push(
+      typescript({
+        ...typeof enableTypeScript === "boolean" ? {} : enableTypeScript,
+        componentExts,
+        overrides: overrides.typescript,
+        prefix: {
+          from: "@typescript-eslint",
+          to: tsPrefix
+        },
+        react: enableReact
+      })
+    );
+  }
+  if (options.react) {
+    configs.push(
+      react({
+        reactRefresh: options.reactRefresh
+      })
+    );
+  }
+  if (options.test) {
+    configs.push(
+      test({
+        isInEditor: isInEditor2,
+        overrides: overrides.test
+      })
+    );
+  }
+  if (options.jsonc ?? true) {
+    configs.push(
+      jsonc({
+        overrides: overrides.jsonc,
+        stylistic: stylisticOptions
+      }),
+      sortPackageJson(),
+      sortTsconfig()
+    );
+  }
+  if (options.tailwind) {
+    configs.push(tailwind());
+  }
+  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]);
+  }
+  if (off.length > 0) {
+    configs.push(
+      off.map((rule) => ({
+        files: ["**/*.{js,jsx,ts,tsx}"],
+        rules: {
+          [rule]: "off"
+        }
+      }))
+    );
+  }
+  return combine(...configs, ...userConfigs);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLOB_ALL_SRC,
+  GLOB_CSS,
+  GLOB_EXCLUDE,
+  GLOB_HTML,
+  GLOB_JS,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_JSONC,
+  GLOB_JSX,
+  GLOB_LESS,
+  GLOB_MARKDOWN,
+  GLOB_MARKDOWN_CODE,
+  GLOB_SCSS,
+  GLOB_SRC,
+  GLOB_SRC_EXT,
+  GLOB_STYLE,
+  GLOB_TESTS,
+  GLOB_TS,
+  GLOB_TSX,
+  GLOB_YAML,
+  combine,
+  comments,
+  ignores,
+  imports,
+  isCI,
+  isInEditor,
+  javascript,
+  jsdoc,
+  jsonc,
+  jsse,
+  node,
+  parserJsonc,
+  parserTs,
+  pluginEslintComments,
+  pluginImport,
+  pluginJsdoc,
+  pluginJsonc,
+  pluginNoOnlyTests,
+  pluginNode,
+  pluginReact,
+  pluginReactHooks,
+  pluginReactRefresh,
+  pluginSortKeys,
+  pluginStylistic,
+  pluginTailwind,
+  pluginTs,
+  pluginUnicorn,
+  pluginUnusedImports,
+  pluginVitest,
+  react,
+  reactHooks,
+  renameRules,
+  sortPackageJson,
+  sortTsconfig,
+  test,
+  typescript,
+  unicorn
+});
+/*! Bundled license information:
+
+natural-compare/index.js:
+  (*
+   * @version    1.4.0
+   * @date       2015-10-26
+   * @stability  3 - Stable
+   * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+   * @license    MIT License
+   *)
+*/