@exbotanical/eslint-config 1.1.3 → 2.0.0

package/dist/index.js

@@ -1,833 +1,31 @@
-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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-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
-));
-
-// node_modules/tsup/assets/esm_shims.js
-import { fileURLToPath } from "url";
-import path from "path";
-var getFilename, getDirname, __dirname;
-var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
-    getFilename = () => fileURLToPath(import.meta.url);
-    getDirname = () => path.dirname(getFilename());
-    __dirname = /* @__PURE__ */ getDirname();
-  }
-});
-
-// node_modules/eslint-plugin-cypress/package.json
-var require_package = __commonJS({
-  "node_modules/eslint-plugin-cypress/package.json"(exports, module) {
-    module.exports = {
-      name: "eslint-plugin-cypress",
-      version: "4.2.0",
-      description: "An ESLint plugin for projects using Cypress",
-      main: "legacy.js",
-      exports: {
-        ".": "./legacy.js",
-        "./flat": "./lib/flat.js"
-      },
-      author: "Cypress-io",
-      license: "MIT",
-      keywords: [
-        "eslint",
-        "eslintplugin",
-        "cypress"
-      ],
-      repository: {
-        type: "git",
-        url: "git+https://github.com/cypress-io/eslint-plugin-cypress.git"
-      },
-      bugs: {
-        url: "https://github.com/cypress-io/eslint-plugin-cypress/issues"
-      },
-      homepage: "https://github.com/cypress-io/eslint-plugin-cypress#readme",
-      peerDependencies: {
-        eslint: ">=9"
-      },
-      dependencies: {
-        globals: "^15.11.0"
-      },
-      devDependencies: {
-        eslint: "^9.13.0",
-        "eslint-plugin-eslint-plugin": "^6.3.1",
-        "eslint-plugin-mocha": "^10.5.0",
-        husky: "^9.1.6",
-        jest: "^29.7.0",
-        "semantic-release": "24.2.0"
-      },
-      scripts: {
-        lint: 'eslint "*.js" "**/**/*.js"',
-        "lint-fix": "npm run lint -- --fix",
-        "semantic-release": "semantic-release",
-        start: "npm run test-watch",
-        test: "jest",
-        "test:legacy": "jest --config jest.config-legacy.js",
-        "test-watch": "jest --watchAll",
-        prepare: "husky"
-      }
-    };
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/no-assigning-return-values.js
-var require_no_assigning_return_values = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-assigning-return-values.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    function get(obj, propertyString = "") {
-      const properties = propertyString.split(".");
-      for (let i = 0; i < properties.length; i++) {
-        const value = (obj || {})[properties[i]];
-        if (value == null) return value;
-        obj = value;
-      }
-      return obj;
-    }
-    module.exports = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "disallow assigning return values of `cy` calls",
-          category: "Possible Errors",
-          recommended: true,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-assigning-return-values.md"
-        },
-        schema: [],
-        messages: {
-          unexpected: "Do not assign the return value of a Cypress command"
-        }
-      },
-      create(context) {
-        return {
-          VariableDeclaration(node2) {
-            if (node2.declarations.some(isCypressCommandDeclaration)) {
-              context.report({ node: node2, messageId: "unexpected" });
-            }
-          }
-        };
-      }
-    };
-    var allowedCommands = {
-      now: true,
-      spy: true,
-      state: true,
-      stub: true
-    };
-    function isCypressCommandDeclaration(declarator) {
-      let object = get(declarator, "init.callee.object");
-      if (!object) return;
-      while (object.callee) {
-        object = object.callee.object;
-        if (!object) return;
-      }
-      const commandName = get(declarator, "init.callee.property.name");
-      const parent = get(object, "parent.property.name") || get(declarator, "id.name");
-      if (commandName && (allowedCommands[commandName] || allowedCommands[parent])) return;
-      return object.name === "cy";
-    }
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/unsafe-to-chain-command.js
-var require_unsafe_to_chain_command = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/unsafe-to-chain-command.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var { basename } = __require("path");
-    var NAME = basename(__dirname);
-    var DESCRIPTION = "disallow actions within chains";
-    var unsafeToChainActions = [
-      "blur",
-      "clear",
-      "click",
-      "check",
-      "dblclick",
-      "each",
-      "focus",
-      "rightclick",
-      "screenshot",
-      "scrollIntoView",
-      "scrollTo",
-      "select",
-      "selectFile",
-      "spread",
-      "submit",
-      "type",
-      "trigger",
-      "uncheck",
-      "within"
-    ];
-    var schema = {
-      title: NAME,
-      description: DESCRIPTION,
-      type: "object",
-      properties: {
-        methods: {
-          type: "array",
-          description: "An additional list of methods to check for unsafe chaining.",
-          default: []
-        }
-      }
-    };
-    var getDefaultOptions = (context) => {
-      return Object.entries(schema.properties).reduce((acc, [key, value]) => {
-        if (!(value.default in value)) return acc;
-        return {
-          ...acc,
-          [key]: value.default
-        };
-      }, context.options[0] || {});
-    };
-    module.exports = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: DESCRIPTION,
-          category: "Possible Errors",
-          recommended: true,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/unsafe-to-chain-command.md"
-        },
-        schema: [schema],
-        messages: {
-          unexpected: "It is unsafe to chain further commands that rely on the subject after this command. It is best to split the chain, chaining again from `cy.` in a next command line."
-        }
-      },
-      create(context) {
-        const { methods } = getDefaultOptions(context);
-        return {
-          CallExpression(node2) {
-            if (isRootCypress(node2) && isActionUnsafeToChain(node2, methods) && node2.parent.type === "MemberExpression") {
-              context.report({
-                node: node2,
-                messageId: "unexpected"
-              });
-            }
-          }
-        };
-      }
-    };
-    var isRootCypress = (node2) => {
-      if (node2.type !== "CallExpression" || node2.callee.type !== "MemberExpression") {
-        return false;
-      }
-      if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
-        return true;
-      }
-      return isRootCypress(node2.callee.object);
-    };
-    var isActionUnsafeToChain = (node2, additionalMethods = []) => {
-      const unsafeActionsRegex = new RegExp([
-        ...unsafeToChainActions.map((action) => `^${action}$`),
-        ...additionalMethods.map((method) => method instanceof RegExp ? method.source : method)
-      ].join("|"));
-      return node2.callee && node2.callee.property && node2.callee.property.type === "Identifier" && unsafeActionsRegex.test(node2.callee.property.name);
-    };
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/no-unnecessary-waiting.js
-var require_no_unnecessary_waiting = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-unnecessary-waiting.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "disallow waiting for arbitrary time periods",
-          category: "Possible Errors",
-          recommended: true,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-unnecessary-waiting.md"
-        },
-        schema: [],
-        messages: {
-          unexpected: "Do not wait for arbitrary time periods"
-        }
-      },
-      create(context) {
-        const sourceCode = context.sourceCode ?? context.getSourceCode();
-        return {
-          CallExpression(node2) {
-            if (isCallingCyWait(node2)) {
-              const scope = sourceCode.getScope ? sourceCode.getScope(node2) : context.getScope();
-              if (isIdentifierNumberConstArgument(node2, scope) || isNumberArgument(node2)) {
-                context.report({ node: node2, messageId: "unexpected" });
-              }
-            }
-          }
-        };
-      }
-    };
-    function nodeIsCalledByCy(node2) {
-      if (node2.type === "Identifier" && node2.name === "cy") return true;
-      if (typeof node2.callee === "undefined" || typeof node2.callee.object === "undefined") {
-        return false;
-      }
-      return nodeIsCalledByCy(node2.callee.object);
-    }
-    function isCallingCyWait(node2) {
-      return node2.callee.type === "MemberExpression" && nodeIsCalledByCy(node2) && node2.callee.property.type === "Identifier" && node2.callee.property.name === "wait";
-    }
-    function isNumberArgument(node2) {
-      return node2.arguments.length > 0 && node2.arguments[0].type === "Literal" && typeof node2.arguments[0].value === "number";
-    }
-    function isIdentifierNumberConstArgument(node2, scope) {
-      if (node2.arguments.length === 0) return false;
-      if (node2.arguments[0].type !== "Identifier") return false;
-      const identifier = node2.arguments[0];
-      const resolvedIdentifier = scope.references.find((ref) => ref.identifier === identifier).resolved;
-      const definition = resolvedIdentifier.defs[0];
-      const isVariable = definition.type === "Variable";
-      if (isVariable) {
-        if (!definition.node.init) return false;
-        return typeof definition.node.init.value === "number";
-      }
-      if (definition.type === "ImportBinding") return false;
-      const param = definition.node.params[definition.index];
-      if (!param || param.type !== "AssignmentPattern") return false;
-      return typeof param.right.value === "number";
-    }
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/no-async-before.js
-var require_no_async_before = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-async-before.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "disallow using `async`/`await` in Cypress `before` methods",
-          category: "Possible Errors",
-          recommended: true,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-before.md"
-        },
-        schema: [],
-        messages: {
-          unexpected: "Avoid using async functions with Cypress before / beforeEach functions"
-        }
-      },
-      create(context) {
-        function isBeforeBlock(callExpressionNode) {
-          const { type, name } = callExpressionNode.callee;
-          return type === "Identifier" && name === "before" || name === "beforeEach";
-        }
-        function isBeforeAsync(node2) {
-          return node2.arguments && node2.arguments.length >= 2 && node2.arguments[1].async === true;
-        }
-        const sourceCode = context.sourceCode ?? context.getSourceCode();
-        return {
-          Identifier(node2) {
-            if (node2.name === "cy" || node2.name === "Cypress") {
-              const ancestors = sourceCode.getAncestors ? sourceCode.getAncestors(node2) : context.getAncestors();
-              const asyncTestBlocks = ancestors.filter((n) => n.type === "CallExpression").filter(isBeforeBlock).filter(isBeforeAsync);
-              if (asyncTestBlocks.length >= 1) {
-                asyncTestBlocks.forEach((node3) => {
-                  context.report({ node: node3, messageId: "unexpected" });
-                });
-              }
-            }
-          }
-        };
-      }
-    };
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/no-async-tests.js
-var require_no_async_tests = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-async-tests.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "disallow using `async`/`await` in Cypress test cases",
-          category: "Possible Errors",
-          recommended: true,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-tests.md"
-        },
-        schema: [],
-        messages: {
-          unexpected: "Avoid using async functions with Cypress tests"
-        }
-      },
-      create(context) {
-        function isTestBlock(callExpressionNode) {
-          const { type, name } = callExpressionNode.callee;
-          return type === "Identifier" && name === "it" || name === "test";
-        }
-        function isTestAsync(node2) {
-          return node2.arguments && node2.arguments.length >= 2 && node2.arguments[1].async === true;
-        }
-        const sourceCode = context.sourceCode ?? context.getSourceCode();
-        return {
-          Identifier(node2) {
-            if (node2.name === "cy" || node2.name === "Cypress") {
-              const ancestors = sourceCode.getAncestors ? sourceCode.getAncestors(node2) : context.getAncestors();
-              const asyncTestBlocks = ancestors.filter((n) => n.type === "CallExpression").filter(isTestBlock).filter(isTestAsync);
-              if (asyncTestBlocks.length >= 1) {
-                asyncTestBlocks.forEach((node3) => {
-                  context.report({ node: node3, messageId: "unexpected" });
-                });
-              }
-            }
-          }
-        };
-      }
-    };
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/assertion-before-screenshot.js
-var require_assertion_before_screenshot = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/assertion-before-screenshot.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var assertionCommands = [
-      // assertions
-      "should",
-      "and",
-      "contains",
-      // retries until it gets something
-      "get",
-      // not an assertion, but unlikely to require waiting for render
-      "scrollIntoView",
-      "scrollTo"
-    ];
-    module.exports = {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "require screenshots to be preceded by an assertion",
-          category: "Possible Errors",
-          recommended: false,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/assertion-before-screenshot.md"
-        },
-        schema: [],
-        messages: {
-          unexpected: "Make an assertion on the page state before taking a screenshot"
-        }
-      },
-      create(context) {
-        return {
-          CallExpression(node2) {
-            if (isCallingCyScreenshot(node2) && !isPreviousAnAssertion(node2)) {
-              context.report({ node: node2, messageId: "unexpected" });
-            }
-          }
-        };
-      }
-    };
-    function isRootCypress(node2) {
-      while (node2.type === "CallExpression") {
-        if (node2.callee.type !== "MemberExpression") return false;
-        if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
-          return true;
-        }
-        node2 = node2.callee.object;
-      }
-      return false;
-    }
-    function getPreviousInChain(node2) {
-      return node2.type === "CallExpression" && node2.callee.type === "MemberExpression" && node2.callee.object.type === "CallExpression" && node2.callee.object.callee.type === "MemberExpression" && node2.callee.object.callee.property.type === "Identifier" && node2.callee.object.callee.property.name;
-    }
-    function getCallExpressionCypressCommand(node2) {
-      return isRootCypress(node2) && node2.callee.property.type === "Identifier" && node2.callee.property.name;
-    }
-    function isCallingCyScreenshot(node2) {
-      return getCallExpressionCypressCommand(node2) === "screenshot";
-    }
-    function getPreviousCypressCommand(node2) {
-      const previousInChain = getPreviousInChain(node2);
-      if (previousInChain) {
-        return previousInChain;
-      }
-      while (node2.parent && !node2.parent.body) {
-        node2 = node2.parent;
-      }
-      if (!node2.parent || !node2.parent.body) return null;
-      const body = node2.parent.body.type === "BlockStatement" ? node2.parent.body.body : node2.parent.body;
-      const index = body.indexOf(node2);
-      if (index < 0) return null;
-      if (index === 0) return getPreviousCypressCommand(node2.parent);
-      const previousStatement = body[index - 1];
-      if (previousStatement.type !== "ExpressionStatement" || previousStatement.expression.type !== "CallExpression") {
-        return null;
-      }
-      return getCallExpressionCypressCommand(previousStatement.expression);
-    }
-    function isPreviousAnAssertion(node2) {
-      const previousCypressCommand = getPreviousCypressCommand(node2);
-      return assertionCommands.indexOf(previousCypressCommand) >= 0;
-    }
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/require-data-selectors.js
-var require_require_data_selectors = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/require-data-selectors.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "require `data-*` attribute selectors",
-          category: "Possible Errors",
-          recommended: false,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/require-data-selectors.md"
-        },
-        schema: [],
-        messages: {
-          unexpected: "use data-* attribute selectors instead of classes or tag names"
-        }
-      },
-      create(context) {
-        return {
-          CallExpression(node2) {
-            if (isCallingCyGet(node2) && !isDataArgument(node2)) {
-              context.report({ node: node2, messageId: "unexpected" });
-            }
-          }
-        };
-      }
-    };
-    function isCallingCyGet(node2) {
-      return node2.callee.type === "MemberExpression" && node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy" && node2.callee.property.type === "Identifier" && node2.callee.property.name === "get";
-    }
-    function isDataArgument(node2) {
-      return node2.arguments.length > 0 && (node2.arguments[0].type === "Literal" && isAliasOrDataSelector(String(node2.arguments[0].value)) || node2.arguments[0].type === "TemplateLiteral" && isAliasOrDataSelector(String(node2.arguments[0].quasis[0].value.cooked)));
-    }
-    function isAliasOrDataSelector(selector) {
-      return ["[data-", "@"].some(function(validValue) {
-        return selector.startsWith(validValue);
-      });
-    }
-  }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/no-force.js
-var require_no_force = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-force.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "disallow using `force: true` with action commands",
-          category: "Possible Errors",
-          recommended: false,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-force.md"
-        },
-        fixable: null,
-        // or "code" or "whitespace"
-        schema: [],
-        messages: {
-          unexpected: "Do not use force on click and type calls"
-        }
-      },
-      create(context) {
-        function isCallingClickOrType(node2) {
-          const allowedMethods = ["click", "dblclick", "type", "trigger", "check", "rightclick", "focus", "select"];
-          return node2.property && node2.property.type === "Identifier" && allowedMethods.includes(node2.property.name);
-        }
-        function isCypressCall(node2) {
-          return node2.callee.type === "MemberExpression" && node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy";
-        }
-        function hasOptionForce(node2) {
-          return node2.arguments && node2.arguments.length && node2.arguments.some((arg) => {
-            return arg.type === "ObjectExpression" && arg.properties.some((propNode) => propNode.key && propNode.key.name === "force");
-          });
-        }
-        function deepCheck(node2, checkFunc) {
-          let currentNode = node2;
-          while (currentNode.parent) {
-            if (checkFunc(currentNode.parent)) {
-              return true;
-            }
-            currentNode = currentNode.parent;
-          }
-          return false;
-        }
-        return {
-          CallExpression(node2) {
-            if (isCypressCall(node2) && deepCheck(node2, isCallingClickOrType) && deepCheck(node2, hasOptionForce)) {
-              context.report({ node: node2, messageId: "unexpected" });
-            }
-          }
-        };
-      }
-    };
-  }
-});
+// src/factory.ts
+import { isPackageExists as isPackageExists3 } from "local-pkg";
 
-// node_modules/eslint-plugin-cypress/lib/rules/no-pause.js
-var require_no_pause = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-pause.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "disallow using `cy.pause()` calls",
-          category: "Possible Errors",
-          recommended: false,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-pause.md"
-        },
-        fixable: null,
-        // or "code" or "whitespace"
-        schema: [],
-        messages: {
-          unexpected: "Do not use cy.pause command"
-        }
-      },
-      create(context) {
-        function isCallingPause(node2) {
-          return node2.callee && node2.callee.property && node2.callee.property.type === "Identifier" && node2.callee.property.name === "pause";
-        }
-        function isCypressCall(node2) {
-          if (!node2.callee || node2.callee.type !== "MemberExpression") {
-            return false;
-          }
-          if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
-            return true;
-          }
-          return isCypressCall(node2.callee.object);
-        }
-        return {
-          CallExpression(node2) {
-            if (isCypressCall(node2) && isCallingPause(node2)) {
-              context.report({ node: node2, messageId: "unexpected" });
-            }
-          }
-        };
-      }
-    };
-  }
-});
+// src/configs/comments.ts
+import plugin from "@eslint-community/eslint-plugin-eslint-comments";
 
-// node_modules/eslint-plugin-cypress/lib/rules/no-debug.js
-var require_no_debug = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-debug.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "disallow using `cy.debug()` calls",
-          category: "Possible Errors",
-          recommended: false,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-debug.md"
-        },
-        fixable: null,
-        // or "code" or "whitespace"
-        schema: [],
-        messages: {
-          unexpected: "Do not use cy.debug command"
-        }
-      },
-      create(context) {
-        function isCallingDebug(node2) {
-          return node2.callee && node2.callee.property && node2.callee.property.type === "Identifier" && node2.callee.property.name === "debug";
-        }
-        function isCypressCall(node2) {
-          if (!node2.callee || node2.callee.type !== "MemberExpression") {
-            return false;
-          }
-          if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
-            return true;
-          }
-          return isCypressCall(node2.callee.object);
-        }
-        return {
-          CallExpression(node2) {
-            if (isCypressCall(node2) && isCallingDebug(node2)) {
-              context.report({ node: node2, messageId: "unexpected" });
-            }
-          }
-        };
-      }
+// src/base-config.ts
+var CustomConfig = class {
+  options;
+  constructor({ type = "app", overrides = {}, ...rest }) {
+    this.options = {
+      type,
+      overrides,
+      ...rest
     };
   }
-});
-
-// node_modules/eslint-plugin-cypress/lib/rules/no-xpath.js
-var require_no_xpath = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/rules/no-xpath.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "disallow using `cy.xpath()` calls",
-          recommended: false,
-          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-xpath.md"
-        },
-        fixable: null,
-        // Or `code` or `whitespace`
-        schema: [],
-        // Add a schema if the rule has options
-        messages: {
-          unexpected: "Avoid using cy.xpath command"
-        }
-      },
-      create(context) {
-        return {
-          CallExpression(node2) {
-            if (isCallingCyXpath(node2)) {
-              context.report({ node: node2, messageId: "unexpected" });
-            }
-          }
-        };
-      }
+  createRuleConfig(feature, config) {
+    return {
+      name: `exbotanical/${this.namespace}/${feature}`,
+      ...config
     };
-    function isCallingCyXpath(node2) {
-      return node2.callee.type === "MemberExpression" && node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy" && node2.callee.property.type === "Identifier" && node2.callee.property.name === "xpath";
-    }
   }
-});
-
-// node_modules/eslint-plugin-cypress/lib/flat.js
-var require_flat = __commonJS({
-  "node_modules/eslint-plugin-cypress/lib/flat.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var globals2 = __require("globals");
-    var { name, version } = require_package();
-    var plugin4 = {
-      meta: { name, version },
-      configs: {},
-      rules: {
-        "no-assigning-return-values": require_no_assigning_return_values(),
-        "unsafe-to-chain-command": require_unsafe_to_chain_command(),
-        "no-unnecessary-waiting": require_no_unnecessary_waiting(),
-        "no-async-before": require_no_async_before(),
-        "no-async-tests": require_no_async_tests(),
-        "assertion-before-screenshot": require_assertion_before_screenshot(),
-        "require-data-selectors": require_require_data_selectors(),
-        "no-force": require_no_force(),
-        "no-pause": require_no_pause(),
-        "no-debug": require_no_debug(),
-        "no-xpath": require_no_xpath()
-      }
-    };
-    var commonGlobals = Object.assign({
-      cy: false,
-      Cypress: false,
-      expect: false,
-      assert: false,
-      chai: false
-    }, globals2.browser, globals2.mocha);
-    Object.assign(plugin4.configs, {
-      globals: {
-        name: "cypress/globals",
-        plugins: {
-          cypress: plugin4
-        },
-        languageOptions: {
-          globals: commonGlobals
-        }
-      }
-    });
-    Object.assign(plugin4.configs, {
-      recommended: {
-        name: "cypress/recommended",
-        plugins: {
-          cypress: plugin4
-        },
-        rules: {
-          "cypress/no-assigning-return-values": "error",
-          "cypress/no-unnecessary-waiting": "error",
-          "cypress/no-async-tests": "error",
-          "cypress/unsafe-to-chain-command": "error"
-        },
-        languageOptions: {
-          globals: commonGlobals
-        }
-      }
-    });
-    module.exports = plugin4;
+  async rules() {
+    return [...await this._rules()];
   }
-});
-
-// src/index.ts
-init_esm_shims();
-
-// src/factory.ts
-init_esm_shims();
-import { isPackageExists as isPackageExists3 } from "local-pkg";
-
-// src/configs/index.ts
-init_esm_shims();
-
-// src/configs/comments.ts
-init_esm_shims();
-import plugin from "@eslint-community/eslint-plugin-eslint-comments";
-var NAMESPACE = "exbotanical/comments";
-async function comments() {
-  return [
-    {
-      name: `${NAMESPACE}/rules`,
-      plugins: {
-        comments: plugin
-      },
-      rules: {
-        "comments/no-aggregating-enable": ["error"],
-        "comments/no-duplicate-disable": ["error"],
-        "comments/no-unlimited-disable": ["error"],
-        "comments/no-unused-enable": ["error"],
-        "comments/no-unused-disable": ["error"],
-        "comments/require-description": ["warn"]
-      }
-    }
-  ];
-}
-
-// src/configs/disables.ts
-init_esm_shims();
+};
 
 // src/filepaths.ts
-init_esm_shims();
 var GLOB_JS = "**/*.?([cm])js";
 var GLOB_JSX = "**/*.?([cm])jsx";
 var GLOB_TS = "**/*.?([cm])ts";
@@ -841,8 +39,18 @@ var GLOB_MARKDOWN = "**/*.md";
 var GLOB_VUE = "**/*.vue";
 var GLOB_YAML = "**/*.y?(a)ml";
 var GLOB_TOML = "**/*.toml";
+var GLOB_XML = "**/*.xml";
+var GLOB_SVG = "**/*.svg";
+var GLOB_HTML = "**/*.htm?(l)";
 var GLOB_GRAPHQL = "**/*.{g,graph}ql";
+var GLOB_GITHUB_WORKFLOW = "**/.github/workflows/*.y?(a)ml";
+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_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
+var GLOB_SCRIPTS = [GLOB_SRC, GLOB_VUE, GLOB_MARKDOWN_CODE];
 var GLOB_TESTS = [
   `**/__tests__/**/*.${GLOB_SRC_EXT}`,
   `**/*.spec.${GLOB_SRC_EXT}`,
@@ -878,77 +86,38 @@ var GLOB_EXCLUDES = [
   "**/__snapshots__"
 ];
 
-// src/configs/disables.ts
-var NAMESPACE2 = "exbotanical/disables";
-async function disables() {
-  return [
-    {
-      name: `${NAMESPACE2}/scripts`,
-      files: [
-        `**/scripts/${GLOB_SRC}`,
-        "**/bin/**/*",
-        `**/bin.${GLOB_SRC_EXT}`
-      ],
-      rules: {
-        "no-console": "off",
-        "ts/explicit-function-return-type": "off"
-      }
-    },
-    {
-      name: `${NAMESPACE2}/dts`,
-      files: ["**/*.d.?([cm])ts"],
-      rules: {
-        "eslint-comments/no-unlimited-disable": "off",
-        "import/no-duplicates": "off",
-        "no-restricted-syntax": "off",
-        "unused-imports/no-unused-vars": "off"
-      }
-    },
-    {
-      name: `${NAMESPACE2}/cjs`,
-      files: ["**/*.js", "**/*.cjs"],
-      rules: {
-        "ts/no-require-imports": "off"
-      }
-    },
-    {
-      name: `${NAMESPACE2}/config-files`,
-      files: [`**/*.config.${GLOB_SRC_EXT}`, `**/*.config.*.${GLOB_SRC_EXT}`],
-      rules: {
-        "no-console": "off",
-        "ts/explicit-function-return-type": "off"
-      }
-    }
-  ];
-}
-
-// src/configs/graphql.ts
-init_esm_shims();
+// src/configs/comments.ts
+var COMMENTS_RULES = {
+  "comments/no-aggregating-enable": ["error"],
+  "comments/no-duplicate-disable": ["error"],
+  "comments/no-unlimited-disable": ["error"],
+  "comments/no-unused-enable": ["error"],
+  "comments/no-unused-disable": ["error"],
+  "comments/require-description": ["warn"]
+};
+var CommentsConfig = class extends CustomConfig {
+  namespace = "comments";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        files: GLOB_SCRIPTS,
+        plugins: {
+          comments: plugin
+        },
+        rules: {
+          ...COMMENTS_RULES
+        }
+      })
+    ];
+  }
+};
 
 // src/utils.ts
-init_esm_shims();
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath } from "node:url";
 import { isPackageExists } from "local-pkg";
-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 interopDefault(module) {
   const resolved = await module;
   return resolved.default || resolved;
@@ -957,8 +126,7 @@ function renameRules(rules, map) {
   return Object.fromEntries(
     Object.entries(rules).map(([key, value]) => {
       for (const [from, to] of Object.entries(map)) {
-        if (key.startsWith(`${from}/`))
-          return [to + key.slice(from.length), value];
+        if (key.startsWith(`${from}/`)) return [to + key.slice(from.length), value];
       }
       return [key, value];
     })
@@ -1003,429 +171,606 @@ var processorPassThrough = {
     return messages[0];
   }
 };
-var scopeUrl = fileURLToPath2(new URL(".", import.meta.url));
+var scopeUrl = fileURLToPath(new URL(".", import.meta.url));
 
-// src/configs/graphql.ts
-async function graphql() {
-  const graphqlPlugin = await interopDefault(import("@graphql-eslint/eslint-plugin"));
-  const rules = {
-    ...graphqlPlugin.configs["flat/operations-recommended"].rules,
-    ...graphqlPlugin.configs["flat/schema-recommended"].rules
-  };
-  return [
-    {
-      files: [GLOB_JS, GLOB_JSX, GLOB_TS, GLOB_TSX],
-      processor: graphqlPlugin.processor
-    },
-    {
-      files: [GLOB_GRAPHQL],
-      languageOptions: {
-        parser: graphqlPlugin.parser
-      },
-      plugins: {
-        "@graphql-eslint": graphqlPlugin
-      },
-      // @ts-expect-error weird rule types in gql plugin
-      rules
-    }
-  ];
-}
+// src/configs/css.ts
+var CssConfig = class extends CustomConfig {
+  namespace = "css";
+  constructor({ files = [GLOB_CSS], ...rest } = {}) {
+    super({
+      files,
+      ...rest
+    });
+  }
+  async _rules() {
+    const { files, overrides = {} } = this.options;
+    const plugin4 = await interopDefault(import("@eslint/css"));
+    return [
+      this.createRuleConfig("rules", {
+        files,
+        language: "css/css",
+        plugins: {
+          css: plugin4
+        },
+        rules: {
+          ...plugin4.configs.recommended.rules,
+          ...overrides
+        }
+      })
+    ];
+  }
+};
 
-// src/configs/ignores.ts
-init_esm_shims();
-var NAMESPACE3 = "exbotanical/ignores";
-async function ignores(files = []) {
-  return [
-    {
-      name: NAMESPACE3,
-      ignores: [...GLOB_EXCLUDES, ...files]
-    }
-  ];
-}
+// src/configs/data-files.ts
+import pluginComments from "@eslint-community/eslint-plugin-eslint-comments";
+import pluginUnicorn from "eslint-plugin-unicorn";
+var DataFilesConfig = class extends CustomConfig {
+  namespace = "data-files";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    const { files = [] } = this.options;
+    if (files.length === 0) return [];
+    return [
+      this.createRuleConfig("rules", {
+        files,
+        linterOptions: {
+          reportUnusedDisableDirectives: "error",
+          reportUnusedInlineConfigs: "error"
+        },
+        plugins: {
+          comments: pluginComments,
+          unicorn: pluginUnicorn
+        },
+        rules: {
+          ...COMMENTS_RULES,
+          "unicode-bom": ["error", "never"],
+          "unicorn/no-abusive-eslint-disable": "error"
+        }
+      })
+    ];
+  }
+};
 
-// src/configs/imports.ts
-init_esm_shims();
-import plugin2 from "eslint-plugin-import";
-var NAMESPACE4 = "exbotanical/imports";
-async function imports() {
-  return [
-    {
-      name: `${NAMESPACE4}/rules`,
-      plugins: {
-        import: plugin2
-      },
-      rules: {
-        "import/consistent-type-specifier-style": ["error", "prefer-top-level"],
-        "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/newline-after-import": ["error", { count: 1 }],
-        "import/no-unresolved": "off",
-        "import/order": [
-          "error",
-          {
-            "alphabetize": {
-              caseInsensitive: true,
-              order: "asc"
-            },
-            "groups": [
-              "builtin",
-              "external",
-              "internal",
-              "parent",
-              "sibling",
-              "index",
-              "object",
-              "type"
-            ],
-            "newlines-between": "always",
-            "pathGroups": [
-              {
-                group: "external",
-                pattern: "{vue,@vue/**}",
-                position: "before"
-              },
-              {
-                group: "external",
-                pattern: "{react,@react/**}",
-                position: "before"
-              },
-              {
-                group: "internal",
-                pattern: "@/**",
-                position: "before"
+// src/configs/disables.ts
+var DisablesConfig = class extends CustomConfig {
+  namespace = "disables";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("scripts", {
+        files: [`**/scripts/${GLOB_SRC}`, "**/bin/**/*", `**/bin.${GLOB_SRC_EXT}`],
+        rules: {
+          "no-console": "off",
+          "ts/explicit-function-return-type": "off"
+        }
+      }),
+      this.createRuleConfig("dts", {
+        files: ["**/*.d.?([cm])ts"],
+        rules: {
+          "eslint-comments/no-unlimited-disable": "off",
+          "import/no-duplicates": "off",
+          "no-restricted-syntax": "off",
+          "unused-imports/no-unused-vars": "off"
+        }
+      }),
+      this.createRuleConfig("cjs", {
+        files: ["**/*.js", "**/*.cjs"],
+        rules: {
+          "ts/no-require-imports": "off"
+        }
+      }),
+      this.createRuleConfig("config-files", {
+        files: [`**/*.config.${GLOB_SRC_EXT}`, `**/*.config.*.${GLOB_SRC_EXT}`],
+        rules: {
+          "no-console": "off",
+          "ts/explicit-function-return-type": "off"
+        }
+      })
+    ];
+  }
+};
+
+// src/configs/github-action.ts
+var GithubActionConfig = class extends CustomConfig {
+  namespace = "github-action";
+  constructor({ files = [GLOB_GITHUB_WORKFLOW], ...rest } = {}) {
+    super({
+      files,
+      ...rest
+    });
+  }
+  async _rules() {
+    const { files, overrides = {} } = this.options;
+    const plugin4 = await interopDefault(import("eslint-plugin-github-action"));
+    const [recommended] = plugin4.configs.recommended;
+    return [
+      this.createRuleConfig("rules", {
+        ...recommended,
+        files,
+        rules: {
+          ...recommended.rules,
+          ...overrides
+        }
+      })
+    ];
+  }
+};
+
+// src/configs/graphql.ts
+var GraphqlConfig = class extends CustomConfig {
+  namespace = "graphql";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    const graphqlPlugin = await interopDefault(import("@graphql-eslint/eslint-plugin"));
+    const rules = {
+      ...graphqlPlugin.configs["flat/operations-recommended"].rules,
+      ...graphqlPlugin.configs["flat/schema-recommended"].rules
+    };
+    return [
+      this.createRuleConfig("setup", {
+        files: [GLOB_JS, GLOB_JSX, GLOB_TS, GLOB_TSX],
+        processor: graphqlPlugin.processor
+      }),
+      this.createRuleConfig("rules", {
+        files: [GLOB_GRAPHQL],
+        languageOptions: {
+          parser: graphqlPlugin.parser
+        },
+        plugins: {
+          "@graphql-eslint": graphqlPlugin
+        },
+        // @ts-expect-error weird rule types in gql plugin
+        rules
+      })
+    ];
+  }
+};
+
+// src/configs/ignores.ts
+var IgnoresConfig = class extends CustomConfig {
+  namespace = "ignores";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("setup", {
+        ignores: [...GLOB_EXCLUDES, ...this.options.files ?? []]
+      })
+    ];
+  }
+};
+
+// src/configs/imports.ts
+import plugin2 from "eslint-plugin-import";
+var ImportsConfig = class extends CustomConfig {
+  namespace = "imports";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        files: GLOB_SCRIPTS,
+        plugins: {
+          import: plugin2
+        },
+        rules: {
+          "import/consistent-type-specifier-style": ["error", "prefer-top-level"],
+          "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/no-absolute-path": "error",
+          "import/no-empty-named-blocks": "error",
+          "import/no-useless-path-segments": "error",
+          "import/newline-after-import": ["error", { count: 1 }],
+          "import/no-unresolved": "off",
+          "import/order": [
+            "error",
+            {
+              "alphabetize": {
+                caseInsensitive: true,
+                order: "asc"
               },
-              {
-                group: "internal",
-                pattern: "@@/**",
-                position: "before"
-              }
-            ]
-          }
-        ]
-      }
-    }
-  ];
-}
+              "groups": [
+                "builtin",
+                "external",
+                "internal",
+                "parent",
+                "sibling",
+                "index",
+                "object",
+                "type"
+              ],
+              "newlines-between": "always",
+              "pathGroups": [
+                {
+                  group: "external",
+                  pattern: "{vue,@vue/**}",
+                  position: "before"
+                },
+                {
+                  group: "external",
+                  pattern: "{react,@react/**}",
+                  position: "before"
+                },
+                {
+                  group: "internal",
+                  pattern: "@/**",
+                  position: "before"
+                },
+                {
+                  group: "internal",
+                  pattern: "@@/**",
+                  position: "before"
+                }
+              ]
+            }
+          ]
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/javascript.ts
-init_esm_shims();
 import pluginUnusedImports from "eslint-plugin-unused-imports";
 import globals from "globals";
 
 // src/common.ts
-init_esm_shims();
 var VAR_IGNORE_PATTERN = "^_";
 
 // src/configs/javascript.ts
-var NAMESPACE5 = "exbotanical/javascript";
-async function javascript({ overrides = {} } = {}) {
-  return [
-    {
-      name: `${NAMESPACE5}/setup`,
-      languageOptions: {
-        ecmaVersion: "latest",
-        globals: {
-          ...globals.browser,
-          ...globals.node,
-          ...globals.es2021,
-          document: "readonly",
-          navigator: "readonly",
-          window: "readonly"
-        },
-        parserOptions: {
-          ecmaFeatures: { jsx: true, impliedStrict: true },
+var JavascriptConfig = class extends CustomConfig {
+  namespace = "javascript";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    const { files = GLOB_SCRIPTS } = this.options;
+    return [
+      this.createRuleConfig("setup", {
+        files,
+        languageOptions: {
           ecmaVersion: "latest",
-          sourceType: "module"
-        },
-        sourceType: "module"
-      },
-      linterOptions: {
-        reportUnusedDisableDirectives: "error",
-        reportUnusedInlineConfigs: "error"
-      }
-    },
-    {
-      name: `${NAMESPACE5}/rules`,
-      plugins: {
-        "unused-imports": pluginUnusedImports
-      },
-      rules: {
-        "array-callback-return": ["error"],
-        "constructor-super": ["error"],
-        "for-direction": ["error"],
-        "getter-return": ["error"],
-        "no-async-promise-executor": ["error"],
-        "no-class-assign": ["error"],
-        "no-compare-neg-zero": ["error"],
-        "no-cond-assign": ["error", "except-parens"],
-        "no-const-assign": ["error"],
-        "no-constant-binary-expression": ["error"],
-        "no-constant-condition": ["error"],
-        "no-constructor-return": ["error"],
-        "no-control-regex": ["error"],
-        "no-debugger": ["error"],
-        "no-dupe-args": ["error"],
-        "no-dupe-class-members": ["error"],
-        "no-dupe-else-if": ["error"],
-        "no-dupe-keys": ["error"],
-        "no-duplicate-case": ["error"],
-        // See `import` ruleset
-        "no-duplicate-imports": ["off"],
-        "no-empty-character-class": ["error"],
-        "no-empty-pattern": ["error"],
-        "no-unsafe-finally": ["error"],
-        "no-unreachable-loop": ["error"],
-        "no-unreachable": ["error"],
-        "no-unmodified-loop-condition": ["error"],
-        "no-unexpected-multiline": ["error"],
-        "no-undef": ["error"],
-        "no-this-before-super": ["error"],
-        "no-template-curly-in-string": ["error"],
-        "no-sparse-arrays": ["error"],
-        "no-setter-return": ["error"],
-        "no-self-compare": ["error"],
-        "no-self-assign": ["error", { props: true }],
-        "no-prototype-builtins": ["error"],
-        "no-promise-executor-return": ["error"],
-        "no-obj-calls": ["error"],
-        "no-new-native-nonconstructor": ["error"],
-        "no-misleading-character-class": ["error"],
-        "no-loss-of-precision": ["error"],
-        "no-irregular-whitespace": ["error"],
-        "no-invalid-regexp": ["error"],
-        "no-import-assign": ["error"],
-        "no-func-assign": ["error"],
-        "no-fallthrough": ["warn"],
-        "no-ex-assign": ["error"],
-        "no-unsafe-negation": ["error"],
-        "no-unsafe-optional-chaining": ["error"],
-        "no-unused-private-class-members": ["error"],
-        "no-unused-vars": [
-          "error",
-          {
-            vars: "all",
-            args: "all",
-            argsIgnorePattern: VAR_IGNORE_PATTERN,
-            caughtErrorsIgnorePattern: VAR_IGNORE_PATTERN,
-            destructuredArrayIgnorePattern: VAR_IGNORE_PATTERN,
-            reportUsedIgnorePattern: true
-          }
-        ],
-        "no-use-before-define": [
-          "error",
-          { classes: false, functions: false, variables: true }
-        ],
-        "no-useless-assignment": ["error"],
-        "no-useless-backreference": ["error"],
-        "require-atomic-updates": ["error"],
-        "use-isnan": [
-          "error",
-          { enforceForIndexOf: true, enforceForSwitchCase: true }
-        ],
-        "valid-typeof": ["error", { requireStringLiterals: true }],
-        "class-methods-use-this": ["warn"],
-        "consistent-return": ["error"],
-        "curly": ["error", "multi-line"],
-        "default-case": [
-          "error",
-          {
-            commentPattern: String.raw`^skip\sdefault`
-          }
-        ],
-        "default-case-last": ["error"],
-        "dot-notation": ["error", { allowKeywords: true }],
-        "eqeqeq": ["error", "smart"],
-        "func-names": ["error", "as-needed"],
-        "accessor-pairs": [
-          "error",
-          { enforceForClassMembers: true, setWithoutGet: true }
-        ],
-        "arrow-body-style": ["error", "as-needed"],
-        "block-scoped-var": ["error"],
-        "camelcase": [
-          "error",
-          {
-            ignoreImports: true
-          }
-        ],
-        "capitalized-comments": [
-          "error",
-          "always",
-          {
-            ignoreInlineComments: true,
-            ignoreConsecutiveComments: true
-          }
-        ],
-        "grouped-accessor-pairs": ["error", "getBeforeSet"],
-        "max-params": ["warn", { max: 5 }],
-        "new-cap": [
-          "error",
-          { capIsNew: false, newIsCap: true, properties: true }
-        ],
-        "no-alert": ["error"],
-        "no-array-constructor": ["error"],
-        "no-caller": ["error"],
-        "no-case-declarations": ["warn"],
-        "no-console": ["error", { allow: ["warn", "error"] }],
-        "no-delete-var": ["error"],
-        "no-else-return": ["error"],
-        "no-empty": ["error", { allowEmptyCatch: true }],
-        "no-eval": ["error"],
-        "no-extra-bind": ["error"],
-        "no-extend-native": ["error"],
-        "no-extra-boolean-cast": ["error"],
-        "no-global-assign": ["error"],
-        "no-implied-eval": ["error"],
-        "no-invalid-this": ["error"],
-        "no-iterator": ["error"],
-        "no-labels": ["error", { allowLoop: false, allowSwitch: false }],
-        "no-lone-blocks": ["error"],
-        "no-multi-str": ["error"],
-        "no-new": ["error"],
-        "no-new-func": ["error"],
-        "no-new-wrappers": ["error"],
-        "no-octal": ["error"],
-        "no-octal-escape": ["error"],
-        "no-param-reassign": ["error"],
-        "no-proto": ["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__"
+          globals: {
+            ...globals.browser,
+            ...globals.node,
+            ...globals.es2021,
+            document: "readonly",
+            navigator: "readonly",
+            window: "readonly"
           },
-          {
-            message: "Use `Object.getOwnPropertyDescriptor` instead.",
-            property: "__lookupGetter__"
+          parserOptions: {
+            ecmaFeatures: { jsx: true, impliedStrict: true },
+            ecmaVersion: "latest",
+            sourceType: "module"
           },
-          {
-            message: "Use `Object.getOwnPropertyDescriptor` instead.",
-            property: "__lookupSetter__"
-          }
-        ],
-        "no-restricted-syntax": [
-          "error",
-          "TSEnumDeclaration[const=true]",
-          "TSExportAssignment"
-        ],
-        "no-sequences": ["error"],
-        "no-shadow-restricted-names": ["error"],
-        "no-throw-literal": ["warn"],
-        "no-undef-init": ["error"],
-        "no-unneeded-ternary": ["error", { defaultAssignment: false }],
-        "no-unused-expressions": [
-          "error",
-          {
-            allowShortCircuit: true,
-            allowTaggedTemplates: true,
-            allowTernary: true
-          }
-        ],
-        "no-useless-call": ["error"],
-        "no-useless-catch": ["error"],
-        "no-useless-computed-key": ["error"],
-        "no-useless-constructor": ["error"],
-        "no-useless-return": ["error"],
-        "no-var": ["error"],
-        "no-with": ["error"],
-        "no-useless-escape": ["error"],
-        "object-shorthand": [
-          "error",
-          "always",
-          {
-            avoidQuotes: true,
-            ignoreConstructors: false
-          }
-        ],
-        "one-var": ["error", { initialized: "never", uninitialized: "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"],
-        "radix": ["error"],
-        "symbol-description": ["error"],
-        "vars-on-top": ["error"],
-        "yoda": ["error", "never"],
-        "unicode-bom": ["error", "never"]
-      },
-      ...overrides
-    }
-  ];
-}
+          sourceType: "module"
+        },
+        linterOptions: {
+          reportUnusedDisableDirectives: "error",
+          reportUnusedInlineConfigs: "error"
+        }
+      }),
+      this.createRuleConfig("rules", {
+        files,
+        plugins: {
+          "unused-imports": pluginUnusedImports
+        },
+        rules: {
+          "array-callback-return": ["error"],
+          "constructor-super": ["error"],
+          "for-direction": ["error"],
+          "getter-return": ["error"],
+          "no-async-promise-executor": ["error"],
+          "no-class-assign": ["error"],
+          "no-compare-neg-zero": ["error"],
+          "no-cond-assign": ["error", "except-parens"],
+          "no-const-assign": ["error"],
+          "no-constant-binary-expression": ["error"],
+          "no-constant-condition": ["error"],
+          "no-constructor-return": ["error"],
+          "no-control-regex": ["error"],
+          "no-debugger": ["error"],
+          "no-dupe-args": ["error"],
+          "no-dupe-class-members": ["error"],
+          "no-dupe-else-if": ["error"],
+          "no-dupe-keys": ["error"],
+          "no-duplicate-case": ["error"],
+          // See `import` ruleset
+          "no-duplicate-imports": ["off"],
+          "no-empty-character-class": ["error"],
+          "no-empty-pattern": ["error"],
+          "no-unsafe-finally": ["error"],
+          "no-unreachable-loop": ["error"],
+          "no-unreachable": ["error"],
+          "no-unmodified-loop-condition": ["error"],
+          "no-unexpected-multiline": ["error"],
+          "no-undef": ["error"],
+          "no-this-before-super": ["error"],
+          "no-template-curly-in-string": ["error"],
+          "no-sparse-arrays": ["error"],
+          "no-setter-return": ["error"],
+          "no-self-compare": ["error"],
+          "no-self-assign": ["error", { props: true }],
+          "no-prototype-builtins": ["error"],
+          "no-promise-executor-return": ["error"],
+          "no-obj-calls": ["error"],
+          "no-new-native-nonconstructor": ["error"],
+          "no-misleading-character-class": ["error"],
+          "no-loss-of-precision": ["error"],
+          "no-irregular-whitespace": ["error"],
+          "no-invalid-regexp": ["error"],
+          "no-import-assign": ["error"],
+          "no-func-assign": ["error"],
+          "no-fallthrough": ["warn"],
+          "no-ex-assign": ["error"],
+          "no-unsafe-negation": ["error"],
+          "no-unsafe-optional-chaining": ["error"],
+          "no-unused-private-class-members": ["error"],
+          "no-unused-vars": "off",
+          "unused-imports/no-unused-imports": "error",
+          "unused-imports/no-unused-vars": [
+            "error",
+            {
+              vars: "all",
+              args: "all",
+              argsIgnorePattern: VAR_IGNORE_PATTERN,
+              caughtErrorsIgnorePattern: VAR_IGNORE_PATTERN,
+              destructuredArrayIgnorePattern: VAR_IGNORE_PATTERN,
+              reportUsedIgnorePattern: true
+            }
+          ],
+          "no-use-before-define": [
+            "error",
+            { classes: false, functions: false, variables: true }
+          ],
+          "no-useless-assignment": ["error"],
+          "no-useless-backreference": ["error"],
+          "require-atomic-updates": ["error"],
+          "use-isnan": ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }],
+          "valid-typeof": ["error", { requireStringLiterals: true }],
+          "class-methods-use-this": ["warn"],
+          "consistent-return": ["error"],
+          "curly": ["error", "multi-line"],
+          "default-case": [
+            "error",
+            {
+              commentPattern: String.raw`^skip\sdefault`
+            }
+          ],
+          "default-case-last": ["error"],
+          "dot-notation": ["error", { allowKeywords: true }],
+          "eqeqeq": ["error", "smart"],
+          "func-names": ["error", "as-needed"],
+          "accessor-pairs": [
+            "error",
+            { enforceForClassMembers: true, setWithoutGet: true }
+          ],
+          "arrow-body-style": ["error", "as-needed"],
+          "block-scoped-var": ["error"],
+          "camelcase": [
+            "error",
+            {
+              ignoreImports: true
+            }
+          ],
+          "capitalized-comments": [
+            "error",
+            "always",
+            {
+              ignoreInlineComments: true,
+              ignoreConsecutiveComments: true
+            }
+          ],
+          "grouped-accessor-pairs": ["error", "getBeforeSet"],
+          "max-params": ["warn", { max: 5 }],
+          "new-cap": ["error", { capIsNew: false, newIsCap: true, properties: true }],
+          "no-alert": ["error"],
+          "no-array-constructor": ["error"],
+          "no-caller": ["error"],
+          "no-case-declarations": ["warn"],
+          "no-console": ["error", { allow: ["warn", "error"] }],
+          "no-delete-var": ["error"],
+          "no-else-return": ["error"],
+          "no-empty": ["error", { allowEmptyCatch: true }],
+          "no-eval": ["error"],
+          "no-extra-bind": ["error"],
+          "no-extend-native": ["error"],
+          "no-extra-boolean-cast": ["error"],
+          "no-global-assign": ["error"],
+          "no-implied-eval": ["error"],
+          "no-invalid-this": ["error"],
+          "no-iterator": ["error"],
+          "no-labels": ["error", { allowLoop: false, allowSwitch: false }],
+          "no-lone-blocks": ["error"],
+          "no-multi-str": ["error"],
+          "no-new": ["error"],
+          "no-new-func": ["error"],
+          "no-new-wrappers": ["error"],
+          "no-octal": ["error"],
+          "no-octal-escape": ["error"],
+          "no-param-reassign": ["error"],
+          "no-proto": ["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-sequences": ["error"],
+          "no-shadow-restricted-names": ["error"],
+          "no-throw-literal": ["warn"],
+          "no-undef-init": ["error"],
+          "no-unneeded-ternary": ["error", { defaultAssignment: false }],
+          "no-unused-expressions": [
+            "error",
+            {
+              allowShortCircuit: true,
+              allowTaggedTemplates: true,
+              allowTernary: true
+            }
+          ],
+          "no-useless-call": ["error"],
+          "no-useless-catch": ["error"],
+          "no-useless-computed-key": ["error"],
+          "no-useless-constructor": ["error"],
+          "no-useless-return": ["error"],
+          "no-var": ["error"],
+          "no-with": ["error"],
+          "no-useless-escape": ["error"],
+          "object-shorthand": [
+            "error",
+            "always",
+            {
+              avoidQuotes: true,
+              ignoreConstructors: false
+            }
+          ],
+          "one-var": ["error", { initialized: "never", uninitialized: "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"],
+          "radix": ["error"],
+          "symbol-description": ["error"],
+          "vars-on-top": ["error"],
+          "yoda": ["error", "never"],
+          "unicode-bom": ["error", "never"]
+        },
+        ...this.options.overrides
+      })
+    ];
+  }
+};
 
 // src/configs/jsdoc.ts
-init_esm_shims();
-var NAMESPACE6 = "exbotanical/jsdoc";
-async function jsdoc() {
-  return [
-    {
-      name: `${NAMESPACE6}/rules`,
-      plugins: {
-        jsdoc: await interopDefault(import("eslint-plugin-jsdoc"))
-      },
-      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"],
-        "jsdoc/check-alignment": ["warn"],
-        "jsdoc/multiline-blocks": ["warn"]
-      }
-    }
-  ];
-}
+var JsdocConfig = class extends CustomConfig {
+  namespace = "jsdoc";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        files: GLOB_SCRIPTS,
+        plugins: {
+          jsdoc: await interopDefault(import("eslint-plugin-jsdoc"))
+        },
+        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"],
+          "jsdoc/check-alignment": ["warn"],
+          "jsdoc/multiline-blocks": ["warn"],
+          "jsdoc/check-line-alignment": ["warn"],
+          "jsdoc/no-blank-block-descriptions": ["warn"],
+          "jsdoc/no-blank-blocks": ["warn"],
+          "jsdoc/sort-tags": ["warn"]
+        }
+      })
+    ];
+  }
+};
 
-// src/configs/jsonc.ts
-init_esm_shims();
+// src/configs/json-schema.ts
+var JsonSchemaConfig = class extends CustomConfig {
+  namespace = "json-schema";
+  constructor({
+    files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC, GLOB_YAML, GLOB_TOML],
+    ...rest
+  } = {}) {
+    super({
+      files,
+      ...rest
+    });
+  }
+  async _rules() {
+    const { files, overrides = {} } = this.options;
+    const plugin4 = await interopDefault(import("eslint-plugin-json-schema-validator"));
+    return [
+      this.createRuleConfig("rules", {
+        files,
+        plugins: {
+          "json-schema-validator": plugin4
+        },
+        rules: {
+          "json-schema-validator/no-invalid": "error",
+          ...overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/defaults.ts
-init_esm_shims();
 var STYLE_DEFAULTS = {
   indent: 2,
   jsx: true,
@@ -1434,376 +779,428 @@ var STYLE_DEFAULTS = {
 };
 
 // src/configs/jsonc.ts
-var NAMESPACE7 = "exbotanical/jsonc";
-async function jsonc({
-  files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
-  overrides = {}
-} = {}, { indent } = STYLE_DEFAULTS) {
-  const [plugin4, parser] = await Promise.all([
-    interopDefault(import("eslint-plugin-jsonc")),
-    interopDefault(import("jsonc-eslint-parser"))
-  ]);
-  return [
-    {
-      name: `${NAMESPACE7}/setup`,
-      plugins: {
-        jsonc: plugin4
-      }
-    },
-    {
+var JsoncConfig = class extends CustomConfig {
+  namespace = "jsonc";
+  constructor({
+    files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
+    indent = STYLE_DEFAULTS.indent,
+    ...rest
+  } = {}) {
+    super({
       files,
-      languageOptions: {
-        parser
-      },
-      name: `${NAMESPACE7}/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",
-        "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
-      }
-    }
-  ];
-}
+      indent,
+      ...rest
+    });
+  }
+  async _rules() {
+    const {
+      files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
+      overrides = {},
+      indent = STYLE_DEFAULTS.indent,
+      sortKeys = []
+    } = this.options;
+    const [plugin4, parser] = await Promise.all([
+      interopDefault(import("eslint-plugin-jsonc")),
+      interopDefault(import("jsonc-eslint-parser"))
+    ]);
+    return [
+      this.createRuleConfig("setup", {
+        plugins: {
+          jsonc: plugin4
+        }
+      }),
+      this.createRuleConfig("rules", {
+        files,
+        languageOptions: {
+          parser
+        },
+        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-irregular-whitespace": "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",
+          "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
+        }
+      }),
+      ...sortKeys.length > 0 ? [
+        this.createRuleConfig("sort-keys", {
+          files: sortKeys,
+          ignores: ["**/package.json", "**/tsconfig.json", "**/tsconfig.*.json"],
+          languageOptions: {
+            parser
+          },
+          rules: {
+            "jsonc/sort-keys": [
+              "error",
+              "asc",
+              { allowLineSeparatedGroups: true, natural: true }
+            ]
+          }
+        })
+      ] : []
+    ];
+  }
+};
 
 // src/configs/jsx.ts
-init_esm_shims();
-var NAMESPACE8 = "exbotanical/jsx";
-async function jsx() {
-  return [
-    {
-      name: `${NAMESPACE8}/setup`,
-      files: [GLOB_JSX, GLOB_TSX],
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true
+var JsxConfig = class extends CustomConfig {
+  namespace = "jsx";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("setup", {
+        files: [GLOB_JSX, GLOB_TSX],
+        languageOptions: {
+          parserOptions: {
+            ecmaFeatures: {
+              jsx: true
+            }
           }
         }
-      }
-    }
-  ];
-}
+      })
+    ];
+  }
+};
 
 // src/configs/markdown.ts
-init_esm_shims();
-var NAMESPACE9 = "exbotanical/markdown";
-async function markdown({
-  files = [GLOB_MARKDOWN],
-  overrides = {}
-} = {}) {
-  const markdown2 = await interopDefault(import("@eslint/markdown"));
-  return [
-    {
-      name: `${NAMESPACE9}/setup`,
-      plugins: { markdown: markdown2 }
-    },
-    {
-      name: `${NAMESPACE9}/processor`,
-      files,
-      ignores: ["**/*.md/*.md"],
-      // `eslint-plugin-markdown` only creates virtual files for code blocks,
-      // but not the markdown file itself (we use passthrough for this).
-      processor: mergeProcessors([
-        markdown2.processors.markdown,
-        processorPassThrough
-      ])
-    },
-    {
-      name: `${NAMESPACE9}/parser`,
+var MarkdownConfig = class extends CustomConfig {
+  namespace = "markdown";
+  constructor({ files = [GLOB_MARKDOWN], ...rest } = {}) {
+    super({
       files,
-      languageOptions: {
-        parser: parserPlain
-      }
-    },
-    {
-      name: `${NAMESPACE9}/disables`,
-      files: [GLOB_MARKDOWN_CODE],
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: { impliedStrict: true }
+      ...rest
+    });
+  }
+  async _rules() {
+    const { files = [GLOB_MARKDOWN], overrides = {} } = this.options;
+    const markdown = await interopDefault(import("@eslint/markdown"));
+    return [
+      this.createRuleConfig("setup", {
+        plugins: { markdown }
+      }),
+      this.createRuleConfig("processor", {
+        files,
+        ignores: ["**/*.md/*.md"],
+        // `eslint-plugin-markdown` only creates virtual files for code blocks,
+        // but not the markdown file itself (we use passthrough for this).
+        processor: mergeProcessors([markdown.processors.markdown, processorPassThrough])
+      }),
+      this.createRuleConfig("rules", {
+        files,
+        language: "markdown/gfm",
+        rules: {
+          ...markdown.configs.recommended[0].rules
         }
-      },
-      rules: {
-        "import/newline-after-import": "off",
-        "no-alert": "off",
-        "no-console": "off",
-        "no-labels": "off",
-        "no-lone-blocks": "off",
-        "no-restricted-syntax": "off",
-        "no-undef": "off",
-        "no-unused-expressions": "off",
-        "no-unused-labels": "off",
-        "no-unused-vars": "off",
-        "node/prefer-global/process": "off",
-        "style/comma-dangle": "off",
-        "style/eol-last": "off",
-        "ts/consistent-type-imports": "off",
-        "ts/explicit-function-return-type": "off",
-        "ts/no-namespace": "off",
-        "ts/no-redeclare": "off",
-        "ts/no-require-imports": "off",
-        "ts/no-unused-expressions": "off",
-        "ts/no-unused-vars": "off",
-        "ts/no-use-before-define": "off",
-        "unicode-bom": "off",
-        "unused-imports/no-unused-imports": "off",
-        "unused-imports/no-unused-vars": "off",
-        ...overrides
-      }
-    }
-  ];
-}
-
-// src/configs/misc/index.ts
-init_esm_shims();
+      }),
+      this.createRuleConfig("disables", {
+        files: [GLOB_MARKDOWN_CODE],
+        languageOptions: {
+          parserOptions: {
+            ecmaFeatures: { impliedStrict: true }
+          }
+        },
+        rules: {
+          "import/newline-after-import": "off",
+          "no-alert": "off",
+          "no-console": "off",
+          "no-labels": "off",
+          "no-lone-blocks": "off",
+          "no-restricted-syntax": "off",
+          "no-undef": "off",
+          "no-unused-expressions": "off",
+          "no-unused-labels": "off",
+          "no-unused-vars": "off",
+          "node/prefer-global/process": "off",
+          "style/comma-dangle": "off",
+          "style/eol-last": "off",
+          "ts/consistent-type-imports": "off",
+          "ts/explicit-function-return-type": "off",
+          "ts/no-namespace": "off",
+          "ts/no-redeclare": "off",
+          "ts/no-require-imports": "off",
+          "ts/no-unused-expressions": "off",
+          "ts/no-unused-vars": "off",
+          "ts/no-use-before-define": "off",
+          "unicode-bom": "off",
+          "unused-imports/no-unused-imports": "off",
+          "unused-imports/no-unused-vars": "off",
+          ...overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/misc/perfectionist.ts
-init_esm_shims();
 import pluginPerfectionist from "eslint-plugin-perfectionist";
-var NAMESPACE10 = "exbotanical/misc/perfectionist";
-async function perfectionist() {
-  return [
-    {
-      name: `${NAMESPACE10}/setup`,
-      plugins: {
-        perfectionist: pluginPerfectionist
-      },
-      rules: {
-        "perfectionist/sort-exports": [
-          "error",
-          { order: "asc", type: "natural" }
-        ],
-        // 'perfectionist/sort-imports': [
-        //   'error',
-        //   {
-        //     groups: [
-        //       'type',
-        //       ['parent-type', 'sibling-type', 'index-type', 'internal-type'],
-        //       'builtin',
-        //       'external',
-        //       'internal',
-        //       ['parent', 'sibling', 'index'],
-        //       'side-effect',
-        //       'object',
-        //       'unknown',
-        //     ],
-        //     newlinesBetween: 'ignore',
-        //     order: 'asc',
-        //     type: 'natural',
-        //   },
-        // ],
-        "perfectionist/sort-named-exports": [
-          "error",
-          { order: "asc", type: "natural" }
-        ]
-        // 'perfectionist/sort-named-imports': [
-        //   'error',
-        //   { order: 'asc', type: 'natural' },
-        // ],
-      }
-    }
-  ];
-}
+var SORT_OPTIONS = { order: "asc", type: "natural" };
+var PerfectionistConfig = class extends CustomConfig {
+  namespace = "misc/perfectionist";
+  constructor({ sortDeclarations = false, ...rest } = {}) {
+    super({
+      sortDeclarations,
+      ...rest
+    });
+  }
+  async _rules() {
+    const { sortDeclarations = false } = this.options;
+    return [
+      this.createRuleConfig("setup", {
+        files: GLOB_SCRIPTS,
+        plugins: {
+          perfectionist: pluginPerfectionist
+        },
+        rules: {
+          "perfectionist/sort-array-includes": ["error", SORT_OPTIONS],
+          "perfectionist/sort-exports": ["error", SORT_OPTIONS],
+          "perfectionist/sort-heritage-clauses": ["error", SORT_OPTIONS],
+          "perfectionist/sort-named-exports": ["error", SORT_OPTIONS],
+          "perfectionist/sort-named-imports": ["error", SORT_OPTIONS],
+          "perfectionist/sort-union-types": ["error", SORT_OPTIONS]
+        }
+      }),
+      ...sortDeclarations ? [
+        this.createRuleConfig("declarations", {
+          files: GLOB_SCRIPTS,
+          rules: {
+            "perfectionist/sort-classes": ["error", SORT_OPTIONS],
+            "perfectionist/sort-enums": ["error", SORT_OPTIONS],
+            "perfectionist/sort-interfaces": ["error", SORT_OPTIONS],
+            "perfectionist/sort-intersection-types": ["error", SORT_OPTIONS],
+            "perfectionist/sort-modules": ["error", SORT_OPTIONS],
+            "perfectionist/sort-object-types": ["error", SORT_OPTIONS],
+            "perfectionist/sort-sets": ["error", SORT_OPTIONS]
+          }
+        })
+      ] : []
+    ];
+  }
+};
 
 // src/configs/misc/unicorn.ts
-init_esm_shims();
-import pluginUnicorn from "eslint-plugin-unicorn";
-var NAMESPACE11 = "exbotanical/misc/unicorn";
-async function unicorn() {
-  return [
-    {
-      name: `${NAMESPACE11}/rules`,
-      plugins: {
-        unicorn: pluginUnicorn
-      },
-      rules: {
-        ...pluginUnicorn.configs.recommended.rules,
-        "unicorn/prevent-abbreviations": "off",
-        "unicorn/no-null": "off",
-        "unicorn/prefer-top-level-await": "off",
-        "unicorn/filename-case": "off",
-        "unicorn/no-await-expression-member": "off",
-        "unicorn/throw-new-error": "off",
-        "unicorn/no-array-callback-reference": "off",
-        "unicorn/no-new-array": "off"
-      }
-    }
-  ];
-}
+import pluginUnicorn2 from "eslint-plugin-unicorn";
+var UnicornConfig = class extends CustomConfig {
+  namespace = "misc/unicorn";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        files: GLOB_SCRIPTS,
+        plugins: {
+          unicorn: pluginUnicorn2
+        },
+        rules: {
+          ...pluginUnicorn2.configs.recommended.rules,
+          "unicorn/prevent-abbreviations": "off",
+          "unicorn/no-null": "off",
+          "unicorn/prefer-top-level-await": "off",
+          "unicorn/filename-case": "off",
+          "unicorn/no-await-expression-member": "off",
+          "unicorn/throw-new-error": "off",
+          "unicorn/no-array-callback-reference": "off",
+          "unicorn/no-new-array": "off"
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/node.ts
-init_esm_shims();
 import plugin3 from "eslint-plugin-n";
-var NAMESPACE12 = "exbotanical/node";
-async function node() {
-  return [
-    {
-      name: `${NAMESPACE12}/rules`,
-      plugins: {
-        node: plugin3
-      },
-      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/process-exit-as-throw": "error"
-      }
-    }
-  ];
-}
+var NodeConfig = class extends CustomConfig {
+  namespace = "node";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        files: GLOB_SCRIPTS,
+        plugins: {
+          node: plugin3
+        },
+        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/process-exit-as-throw": "error",
+          "node/hashbang": "error",
+          ...this.options.overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/package.json.ts
-init_esm_shims();
-var NAMESPACE13 = "exbotanical/package.json";
-async function packageJson() {
-  return [
-    {
-      name: `${NAMESPACE13}/rules`,
-      files: ["**/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"
-            ],
-            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)$"
-          }
-        ]
-      }
-    }
-  ];
-}
-
-// src/configs/prettier.ts
-init_esm_shims();
+var PackageJsonConfig = class extends CustomConfig {
+  namespace = "package.json";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        files: ["**/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"
+              ],
+              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)$"
+            }
+          ],
+          ...this.options.overrides
+        }
+      })
+    ];
+  }
+};
+var PackageJsonPluginConfig = class extends CustomConfig {
+  namespace = "package.json/plugin";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    const plugin4 = await interopDefault(import("eslint-plugin-package-json"));
+    const { recommended, stylistic } = plugin4.configs;
+    return [
+      this.createRuleConfig("rules", {
+        ...recommended,
+        rules: {
+          ...recommended.rules,
+          ...stylistic.rules,
+          ...this.options.overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/vendor/plugins/eslint-config-prettier.ts
-init_esm_shims();
 var specialRule = 0;
 var eslint_config_prettier_default = {
   rules: {
@@ -2094,12 +1491,25 @@ var eslint_config_prettier_default = {
 };
 
 // src/configs/prettier.ts
-async function prettier() {
-  return [eslint_config_prettier_default];
-}
+var PrettierConfig = class extends CustomConfig {
+  namespace = "prettier";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        ...eslint_config_prettier_default,
+        rules: {
+          ...eslint_config_prettier_default.rules,
+          ...this.options.overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/react.ts
-init_esm_shims();
 import { isPackageExists as isPackageExists2 } from "local-pkg";
 var REACT_REFRESH_ALLOW_CONSTANT_EXPORT_PACKAGES = ["vite"];
 var REACT_ROUTER_PACKAGES = [
@@ -2108,172 +1518,195 @@ var REACT_ROUTER_PACKAGES = [
   "@react-router/serve",
   "@react-router/dev"
 ];
-var NAMESPACE14 = "exbotanical/react";
-async function react({
-  files = [GLOB_SRC],
-  filesTypeAware = [GLOB_TS, GLOB_TSX],
-  ignoresTypeAware = [],
-  overrides = {},
-  tsconfigPath
-}) {
-  const isTypeAware = !!tsconfigPath;
-  const typeAwareRules = {
-    "react/no-leaked-conditional-rendering": "warn"
-  };
-  const [pluginReact, pluginReactHooks, pluginReactRefresh] = await Promise.all(
-    [
+var ReactConfig = class extends CustomConfig {
+  namespace = "react";
+  constructor({
+    files = [GLOB_SRC],
+    filesTypeAware = [GLOB_TS, GLOB_TSX],
+    ignoresTypeAware = [],
+    tsconfigPath,
+    ...rest
+  } = {}) {
+    super({
+      files,
+      filesTypeAware,
+      ignoresTypeAware,
+      tsconfigPath,
+      ...rest
+    });
+  }
+  async _rules() {
+    const {
+      files = [GLOB_SRC],
+      filesTypeAware = [GLOB_TS, GLOB_TSX],
+      ignoresTypeAware = [],
+      tsconfigPath,
+      overrides = {}
+    } = this.options;
+    const isTypeAware = !!tsconfigPath;
+    const typeAwareRules = {
+      "react/no-leaked-conditional-rendering": "warn"
+    };
+    const [pluginReact, pluginReactHooks, pluginReactRefresh] = await Promise.all([
       interopDefault(import("@eslint-react/eslint-plugin")),
       interopDefault(import("eslint-plugin-react-hooks")),
       interopDefault(import("eslint-plugin-react-refresh"))
-    ]
-  );
-  const isAllowConstantExport = REACT_REFRESH_ALLOW_CONSTANT_EXPORT_PACKAGES.some((index) => isPackageExists2(index));
-  const isUsingReactRouter = REACT_ROUTER_PACKAGES.some((index) => isPackageExists2(index));
-  const plugins = pluginReact.configs.all.plugins;
-  return [
-    {
-      name: `${NAMESPACE14}/setup`,
-      plugins: {
-        "react": plugins["@eslint-react"],
-        "react-dom": plugins["@eslint-react/dom"],
-        "react-hooks": pluginReactHooks,
-        "react-hooks-extra": plugins["@eslint-react/hooks-extra"],
-        "react-naming-convention": plugins["@eslint-react/naming-convention"],
-        "react-refresh": pluginReactRefresh,
-        "react-web-api": plugins["@eslint-react/web-api"]
-      }
-    },
-    {
-      name: `${NAMESPACE14}/rules`,
-      files,
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true
-          }
+    ]);
+    const isAllowConstantExport = REACT_REFRESH_ALLOW_CONSTANT_EXPORT_PACKAGES.some(
+      (index) => isPackageExists2(index)
+    );
+    const isUsingReactRouter = REACT_ROUTER_PACKAGES.some((index) => isPackageExists2(index));
+    const plugins = pluginReact.configs.all.plugins;
+    return [
+      this.createRuleConfig("setup", {
+        plugins: {
+          "react": plugins["@eslint-react"],
+          "react-dom": plugins["@eslint-react/dom"],
+          "react-hooks": pluginReactHooks,
+          "react-hooks-extra": plugins["@eslint-react/hooks-extra"],
+          "react-naming-convention": plugins["@eslint-react/naming-convention"],
+          "react-refresh": pluginReactRefresh,
+          "react-web-api": plugins["@eslint-react/web-api"]
+        }
+      }),
+      this.createRuleConfig("rules", {
+        files,
+        languageOptions: {
+          parserOptions: {
+            ecmaFeatures: {
+              jsx: true
+            }
+          },
+          sourceType: "module"
         },
-        sourceType: "module"
-      },
-      rules: {
-        // Recommended rules from @eslint-react/dom
-        "react-dom/no-children-in-void-dom-elements": "warn",
-        "react-dom/no-dangerously-set-innerhtml": "warn",
-        "react-dom/no-dangerously-set-innerhtml-with-children": "error",
-        "react-dom/no-find-dom-node": "error",
-        "react-dom/no-missing-button-type": "warn",
-        "react-dom/no-missing-iframe-sandbox": "warn",
-        "react-dom/no-namespace": "error",
-        "react-dom/no-render-return-value": "error",
-        "react-dom/no-script-url": "warn",
-        "react-dom/no-unsafe-iframe-sandbox": "warn",
-        "react-dom/no-unsafe-target-blank": "warn",
-        // Recommended rules react-hooks
-        "react-hooks/exhaustive-deps": "warn",
-        "react-hooks/rules-of-hooks": "error",
-        // React refresh
-        "react-refresh/only-export-components": [
-          "warn",
-          {
-            allowConstantExport: isAllowConstantExport,
-            allowExportNames: [
-              ...isUsingReactRouter ? ["meta", "links", "headers", "loader", "action"] : []
-            ]
-          }
-        ],
-        // Recommended rules from @eslint-react/web-api
-        "react-web-api/no-leaked-event-listener": "warn",
-        "react-web-api/no-leaked-interval": "warn",
-        "react-web-api/no-leaked-resize-observer": "warn",
-        "react-web-api/no-leaked-timeout": "warn",
-        // Recommended rules from @eslint-react
-        "react/ensure-forward-ref-using-ref": "warn",
-        "react/jsx-no-duplicate-props": "warn",
-        "react/jsx-uses-vars": "warn",
-        "react/no-access-state-in-setstate": "error",
-        "react/no-array-index-key": "warn",
-        "react/no-children-count": "warn",
-        "react/no-children-for-each": "warn",
-        "react/no-children-map": "warn",
-        "react/no-children-only": "warn",
-        "react/no-children-to-array": "warn",
-        "react/no-clone-element": "warn",
-        "react/no-comment-textnodes": "warn",
-        "react/no-component-will-mount": "error",
-        "react/no-component-will-receive-props": "error",
-        "react/no-component-will-update": "error",
-        "react/no-context-provider": "warn",
-        "react/no-create-ref": "error",
-        "react/no-default-props": "error",
-        "react/no-direct-mutation-state": "error",
-        "react/no-duplicate-key": "error",
-        "react/no-forward-ref": "warn",
-        "react/no-implicit-key": "warn",
-        "react/no-missing-key": "error",
-        "react/no-nested-components": "error",
-        "react/no-prop-types": "error",
-        "react/no-redundant-should-component-update": "error",
-        "react/no-set-state-in-component-did-mount": "warn",
-        "react/no-set-state-in-component-did-update": "warn",
-        "react/no-set-state-in-component-will-update": "warn",
-        "react/no-string-refs": "error",
-        "react/no-unsafe-component-will-mount": "warn",
-        "react/no-unsafe-component-will-receive-props": "warn",
-        "react/no-unsafe-component-will-update": "warn",
-        "react/no-unstable-context-value": "warn",
-        "react/no-unstable-default-props": "warn",
-        "react/no-unused-class-component-members": "warn",
-        "react/no-unused-state": "warn",
-        "react/prefer-destructuring-assignment": "warn",
-        "react/prefer-shorthand-boolean": "warn",
-        "react/prefer-shorthand-fragment": "warn",
-        ...overrides
-      }
-    },
-    ...isTypeAware ? [
-      {
-        name: `${NAMESPACE14}/type-aware-rules`,
-        files: filesTypeAware,
-        ignores: ignoresTypeAware,
         rules: {
-          ...typeAwareRules
+          // Recommended rules from @eslint-react/dom
+          "react-dom/no-children-in-void-dom-elements": "warn",
+          "react-dom/no-dangerously-set-innerhtml": "warn",
+          "react-dom/no-dangerously-set-innerhtml-with-children": "error",
+          "react-dom/no-find-dom-node": "error",
+          "react-dom/no-missing-button-type": "warn",
+          "react-dom/no-missing-iframe-sandbox": "warn",
+          "react-dom/no-namespace": "error",
+          "react-dom/no-render-return-value": "error",
+          "react-dom/no-script-url": "warn",
+          "react-dom/no-unsafe-iframe-sandbox": "warn",
+          "react-dom/no-unsafe-target-blank": "warn",
+          // Recommended rules react-hooks
+          "react-hooks/exhaustive-deps": "warn",
+          "react-hooks/rules-of-hooks": "error",
+          // React refresh
+          "react-refresh/only-export-components": [
+            "warn",
+            {
+              allowConstantExport: isAllowConstantExport,
+              allowExportNames: [
+                ...isUsingReactRouter ? ["meta", "links", "headers", "loader", "action"] : []
+              ]
+            }
+          ],
+          // Recommended rules from @eslint-react/web-api
+          "react-web-api/no-leaked-event-listener": "warn",
+          "react-web-api/no-leaked-interval": "warn",
+          "react-web-api/no-leaked-resize-observer": "warn",
+          "react-web-api/no-leaked-timeout": "warn",
+          // Recommended rules from @eslint-react
+          "react/ensure-forward-ref-using-ref": "warn",
+          "react/jsx-no-duplicate-props": "warn",
+          "react/jsx-uses-vars": "warn",
+          "react/no-access-state-in-setstate": "error",
+          "react/no-array-index-key": "warn",
+          "react/no-children-count": "warn",
+          "react/no-children-for-each": "warn",
+          "react/no-children-map": "warn",
+          "react/no-children-only": "warn",
+          "react/no-children-to-array": "warn",
+          "react/no-clone-element": "warn",
+          "react/no-comment-textnodes": "warn",
+          "react/no-component-will-mount": "error",
+          "react/no-component-will-receive-props": "error",
+          "react/no-component-will-update": "error",
+          "react/no-context-provider": "warn",
+          "react/no-create-ref": "error",
+          "react/no-default-props": "error",
+          "react/no-direct-mutation-state": "error",
+          "react/no-duplicate-key": "error",
+          "react/no-forward-ref": "warn",
+          "react/no-implicit-key": "warn",
+          "react/no-missing-key": "error",
+          "react/no-nested-components": "error",
+          "react/no-prop-types": "error",
+          "react/no-redundant-should-component-update": "error",
+          "react/no-set-state-in-component-did-mount": "warn",
+          "react/no-set-state-in-component-did-update": "warn",
+          "react/no-set-state-in-component-will-update": "warn",
+          "react/no-string-refs": "error",
+          "react/no-unsafe-component-will-mount": "warn",
+          "react/no-unsafe-component-will-receive-props": "warn",
+          "react/no-unsafe-component-will-update": "warn",
+          "react/no-unstable-context-value": "warn",
+          "react/no-unstable-default-props": "warn",
+          "react/no-unused-class-component-members": "warn",
+          "react/no-unused-state": "warn",
+          "react/prefer-destructuring-assignment": "warn",
+          "react/prefer-shorthand-boolean": "warn",
+          "react/prefer-shorthand-fragment": "warn",
+          ...overrides
         }
-      }
-    ] : []
-  ];
-}
+      }),
+      ...isTypeAware ? [
+        this.createRuleConfig("type-aware-rules", {
+          files: filesTypeAware,
+          ignores: ignoresTypeAware,
+          rules: {
+            ...typeAwareRules
+          }
+        })
+      ] : []
+    ];
+  }
+};
 
 // src/configs/regexpr.ts
-init_esm_shims();
 import { configs } from "eslint-plugin-regexp";
-var NAMESPACE15 = "exbotanical/regexpr";
-async function regexpr({
-  level = "error",
-  overrides = {}
-} = {}) {
-  const config = configs["flat/recommended"];
-  const rules = {
-    ...config.rules
-  };
-  if (level === "warn") {
-    for (const key in rules) {
-      if (rules[key] === "error") rules[key] = "warn";
-    }
+var RegexprConfig = class extends CustomConfig {
+  namespace = "regexpr";
+  constructor({ level = "error", ...rest } = {}) {
+    super({
+      level,
+      ...rest
+    });
   }
-  return [
-    {
-      ...config,
-      name: `${NAMESPACE15}/rules`,
-      rules: {
-        ...rules,
-        ...overrides
+  async _rules() {
+    const { level = "error", overrides = {} } = this.options;
+    const config = configs["flat/recommended"];
+    const rules = {
+      ...config.rules
+    };
+    if (level === "warn") {
+      for (const key in rules) {
+        if (rules[key] === "error") rules[key] = "warn";
       }
     }
-  ];
-}
+    return [
+      this.createRuleConfig("rules", {
+        ...config,
+        files: GLOB_SCRIPTS,
+        rules: {
+          ...rules,
+          "regexp/prefer-quantifier": level,
+          "regexp/prefer-regexp-test": level,
+          "regexp/sort-alternatives": level,
+          "regexp/sort-character-class-elements": level,
+          "regexp/unicode-property": level,
+          ...overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/test.ts
-init_esm_shims();
-var import_flat = __toESM(require_flat(), 1);
 var PLUGIN_RUNNER_MAP = {
   tap: [
     "eslint-plugin-tap",
@@ -2308,633 +1741,714 @@ var PLUGIN_RUNNER_MAP = {
     })
   ]
 };
-var NAMESPACE16 = "exbotanical/test";
-async function test({
-  runner = "vitest",
-  cypress = false,
-  files = GLOB_TESTS,
-  overrides = {}
-}) {
-  const [plugin4, rules] = PLUGIN_RUNNER_MAP[runner];
-  const [pluginRunner, pluginNoOnlyTests] = await Promise.all([
-    interopDefault(import(plugin4)),
-    // @ts-expect-error no types
-    interopDefault(import("eslint-plugin-no-only-tests"))
-  ]);
-  const extraConfigs = [];
-  if (cypress) {
-    extraConfigs.push({
-      name: `${NAMESPACE16}/cypress/rules`,
-      ...import_flat.default.configs.recommended,
-      ...typeof cypress === "boolean" ? {} : cypress
+var TestConfig = class extends CustomConfig {
+  namespace = "test";
+  constructor({
+    runner = "vitest",
+    cypress = false,
+    files = GLOB_TESTS,
+    ...rest
+  } = {}) {
+    super({
+      runner,
+      cypress,
+      files,
+      ...rest
     });
   }
-  return [
-    {
-      name: `${NAMESPACE16}/setup`,
-      plugins: {
-        test: {
-          ...pluginRunner,
+  async _rules() {
+    const {
+      runner = "vitest",
+      cypress = false,
+      files = GLOB_TESTS,
+      overrides = {}
+    } = this.options;
+    const [plugin4, rules] = PLUGIN_RUNNER_MAP[runner];
+    const [pluginRunner, pluginNoOnlyTests] = await Promise.all([
+      interopDefault(import(plugin4)),
+      // @ts-expect-error no types
+      interopDefault(import("eslint-plugin-no-only-tests"))
+    ]);
+    const extraConfigs = [];
+    if (cypress) {
+      const pluginCypress = await interopDefault(import("eslint-plugin-cypress/flat"));
+      extraConfigs.push(
+        this.createRuleConfig("cypress/rules", {
+          ...pluginCypress.configs.recommended,
+          ...typeof cypress === "boolean" ? {} : cypress
+        })
+      );
+    }
+    return [
+      this.createRuleConfig("setup", {
+        plugins: {
+          test: {
+            ...pluginRunner,
+            rules: {
+              ...pluginNoOnlyTests.rules,
+              ...rules(pluginRunner)
+            }
+          }
+        }
+      }),
+      ...runner === "jest" ? [
+        this.createRuleConfig("jest", {
+          ...cypress && typeof cypress !== "boolean" ? { ignores: [...cypress.files ?? []] } : {},
+          ...pluginRunner.configs["flat/recommended"],
           rules: {
-            ...pluginNoOnlyTests.rules,
-            ...rules(pluginRunner)
+            ...pluginRunner.configs["flat/recommended"].rules
           }
+        })
+      ] : [],
+      this.createRuleConfig("rules", {
+        files,
+        rules: {
+          "test/no-only-tests": "error",
+          ...overrides
         }
-      }
-    },
-    runner === "jest" ? {
-      name: `${NAMESPACE16}/jest`,
-      ...pluginRunner.configs["flat/recommended"],
-      rules: {
-        ...pluginRunner.configs["flat/recommended"].rules
-      }
-    } : {},
-    {
-      name: `${NAMESPACE16}/rules`,
-      files,
-      rules: {
-        ...overrides
-      }
-    },
-    ...extraConfigs
-  ];
-}
+      }),
+      ...extraConfigs
+    ];
+  }
+};
 
 // src/configs/toml.ts
-init_esm_shims();
-var NAMESPACE17 = "exbotanical/toml";
-async function toml({ files = [GLOB_TOML], overrides = {} } = {}, { indent } = STYLE_DEFAULTS) {
-  const [plugin4, parser] = await Promise.all([
-    interopDefault(import("eslint-plugin-toml")),
-    interopDefault(import("toml-eslint-parser"))
-  ]);
-  return [
-    {
-      name: `${NAMESPACE17}/setup`,
-      plugins: {
-        toml: plugin4
-      }
-    },
-    {
-      name: `${NAMESPACE17}/rules`,
+var TomlConfig = class extends CustomConfig {
+  namespace = "toml";
+  constructor({
+    files = [GLOB_TOML],
+    indent = STYLE_DEFAULTS.indent,
+    ...rest
+  } = {}) {
+    super({
       files,
-      languageOptions: {
-        parser
-      },
-      rules: {
-        "style/spaced-comment": "off",
-        "toml/comma-style": "error",
-        "toml/keys-order": "error",
-        "toml/no-space-dots": "error",
-        "toml/no-unreadable-number-separator": "error",
-        "toml/precision-of-fractional-seconds": "error",
-        "toml/precision-of-integer": "error",
-        "toml/tables-order": "error",
-        "toml/vue-custom-block/no-parsing-error": "error",
-        "toml/array-bracket-newline": "error",
-        "toml/array-bracket-spacing": "error",
-        "toml/array-element-newline": "error",
-        "toml/indent": ["error", indent === "tab" ? 2 : indent],
-        "toml/inline-table-curly-spacing": "error",
-        "toml/key-spacing": "error",
-        "toml/padding-line-between-pairs": "error",
-        "toml/padding-line-between-tables": "error",
-        "toml/quoted-keys": "error",
-        "toml/spaced-comment": "error",
-        "toml/table-bracket-spacing": "error",
-        ...overrides
-      }
-    }
-  ];
-}
+      indent,
+      ...rest
+    });
+  }
+  async _rules() {
+    const {
+      files = [GLOB_TOML],
+      overrides = {},
+      indent = STYLE_DEFAULTS.indent
+    } = this.options;
+    const [plugin4, parser] = await Promise.all([
+      interopDefault(import("eslint-plugin-toml")),
+      interopDefault(import("toml-eslint-parser"))
+    ]);
+    return [
+      this.createRuleConfig("setup", {
+        plugins: {
+          toml: plugin4
+        }
+      }),
+      this.createRuleConfig("rules", {
+        files,
+        languageOptions: {
+          parser
+        },
+        rules: {
+          "style/spaced-comment": "off",
+          "toml/comma-style": "error",
+          "toml/keys-order": "error",
+          "toml/no-space-dots": "error",
+          "toml/no-unreadable-number-separator": "error",
+          "toml/precision-of-fractional-seconds": "error",
+          "toml/precision-of-integer": "error",
+          "toml/tables-order": "error",
+          "toml/vue-custom-block/no-parsing-error": "error",
+          "toml/array-bracket-newline": "error",
+          "toml/array-bracket-spacing": "error",
+          "toml/array-element-newline": "error",
+          "toml/indent": ["error", indent === "tab" ? 2 : indent],
+          "toml/inline-table-curly-spacing": "error",
+          "toml/key-spacing": "error",
+          "toml/padding-line-between-pairs": "error",
+          "toml/padding-line-between-tables": "error",
+          "toml/quoted-keys": "error",
+          "toml/spaced-comment": "error",
+          "toml/table-bracket-spacing": "error",
+          ...overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/tsconfig.ts
-init_esm_shims();
-var NAMESPACE18 = "exbotanical/tsconfig";
-async function tsconfig() {
-  return [
-    {
-      name: `${NAMESPACE18}/rules`,
-      files: ["**/tsconfig.json", "**/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$"
-          }
-        ]
-      }
-    }
-  ];
-}
+var TsconfigConfig = class extends CustomConfig {
+  namespace = "tsconfig";
+  constructor(options = {}) {
+    super(options);
+  }
+  async _rules() {
+    return [
+      this.createRuleConfig("rules", {
+        files: ["**/tsconfig.json", "**/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$"
+            }
+          ],
+          ...this.options.overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/typescript.ts
-init_esm_shims();
-var NAMESPACE19 = "exbotanical/typescript";
-async function typescript(options = {}) {
-  const {
-    type = "app",
+var TypescriptConfig = class extends CustomConfig {
+  namespace = "typescript";
+  constructor({
     parserOptions = {},
-    overrides = {},
     typeAwareOverrides = {},
-    ignoresTypeAware = []
-  } = options;
-  const files = options.files ?? [GLOB_TS, GLOB_TSX];
-  const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
-  const tsconfigPath = options?.tsconfigPath;
-  const isTypeAware = !!tsconfigPath;
-  const typeAwareRules = {
-    "dot-notation": ["off"],
-    "no-implied-eval": ["off"],
-    "ts/await-thenable": ["error"],
-    "ts/dot-notation": ["error", { allowKeywords: true }],
-    "ts/no-floating-promises": ["error"],
-    "ts/no-for-in-array": ["error"],
-    "ts/no-implied-eval": ["error"],
-    "ts/no-misused-promises": ["error"],
-    "ts/no-unnecessary-type-assertion": ["error"],
-    "ts/no-unsafe-argument": ["error"],
-    "ts/no-unsafe-assignment": ["error"],
-    "ts/no-unsafe-call": ["error"],
-    "ts/no-unsafe-member-access": ["error"],
-    "ts/no-unsafe-return": ["error"],
-    "ts/promise-function-async": ["error"],
-    "ts/restrict-plus-operands": ["error"],
-    "ts/restrict-template-expressions": ["error"],
-    "ts/return-await": ["error", "in-try-catch"],
-    "ts/strict-boolean-expressions": [
-      "error",
-      { allowNullableBoolean: true, allowNullableObject: true }
-    ],
-    "ts/switch-exhaustiveness-check": ["error"],
-    "ts/unbound-method": ["error"]
-  };
-  const [plugin4, parser] = await Promise.all([
-    interopDefault(import("@typescript-eslint/eslint-plugin")),
-    interopDefault(import("@typescript-eslint/parser"))
-  ]);
-  function makeParser(typeAware, files2, ignores2 = []) {
-    return {
-      name: `${NAMESPACE19}/${typeAware ? "type-aware-parser" : "parser"}`,
-      files: files2,
-      ignores: ignores2,
-      languageOptions: {
-        parser,
-        parserOptions: {
-          sourceType: "module",
-          ...typeAware ? {
-            projectService: {
-              allowDefaultProject: ["./*.js"],
-              defaultProject: tsconfigPath
-            },
-            tsconfigRootDir: process.cwd()
-          } : {},
-          ...parserOptions
-        }
-      }
-    };
+    ignoresTypeAware = [],
+    ...rest
+  } = {}) {
+    super({
+      parserOptions,
+      typeAwareOverrides,
+      ignoresTypeAware,
+      ...rest
+    });
   }
-  return [
-    {
-      name: `${NAMESPACE19}/setup`,
-      plugins: {
-        ts: plugin4
-      }
-    },
-    makeParser(false, files),
-    ...isTypeAware ? [makeParser(true, filesTypeAware, ignoresTypeAware)] : [],
-    {
-      name: `${NAMESPACE19}/rules`,
-      files,
-      rules: {
-        ...renameRules(
-          plugin4.configs["eslint-recommended"].overrides[0].rules,
-          { "@typescript-eslint": "ts" }
-        ),
-        ...renameRules(plugin4.configs.strict.rules, {
-          "@typescript-eslint": "ts"
-        }),
-        "no-dupe-class-members": ["off"],
-        "no-redeclare": ["off"],
-        "no-use-before-define": ["off"],
-        "no-useless-constructor": ["off"],
-        "ts/ban-ts-comment": [
-          "error",
-          { "ts-expect-error": "allow-with-description" }
-        ],
-        "ts/consistent-type-definitions": ["error", "interface"],
-        "ts/consistent-type-imports": [
-          "error",
-          {
-            disallowTypeAnnotations: false,
-            fixStyle: "separate-type-imports",
-            prefer: "type-imports"
-          }
-        ],
-        // See: https://www.totaltypescript.com/method-shorthand-syntax-considered-harmful
-        "ts/method-signature-style": ["error", "property"],
-        "ts/no-dupe-class-members": ["error"],
-        "ts/no-dynamic-delete": ["off"],
-        "ts/no-empty-object-type": ["error", { allowInterfaces: "always" }],
-        "ts/no-explicit-any": ["warn"],
-        "ts/no-extraneous-class": ["off"],
-        "ts/no-import-type-side-effects": ["error"],
-        "ts/no-invalid-void-type": ["error"],
-        "ts/no-non-null-assertion": ["error"],
-        "ts/no-redeclare": ["error", { builtinGlobals: false }],
-        "ts/no-require-imports": ["error"],
-        "ts/no-unused-expressions": [
-          "error",
-          {
-            allowShortCircuit: true,
-            allowTaggedTemplates: true,
-            allowTernary: true
-          }
-        ],
-        "ts/no-unused-vars": [
-          "error",
-          {
-            vars: "all",
-            args: "all",
-            argsIgnorePattern: VAR_IGNORE_PATTERN,
-            caughtErrorsIgnorePattern: VAR_IGNORE_PATTERN,
-            destructuredArrayIgnorePattern: VAR_IGNORE_PATTERN,
-            reportUsedIgnorePattern: true
+  async _rules() {
+    const files = this.options.files ?? [GLOB_TS, GLOB_TSX];
+    const filesTypeAware = this.options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
+    const tsconfigPath = this.options?.tsconfigPath;
+    const isTypeAware = !!tsconfigPath;
+    const typeAwareRules = {
+      "dot-notation": ["off"],
+      "no-implied-eval": ["off"],
+      "ts/await-thenable": ["error"],
+      "ts/dot-notation": ["error", { allowKeywords: true }],
+      "ts/no-floating-promises": ["error"],
+      "ts/no-for-in-array": ["error"],
+      "ts/no-implied-eval": ["error"],
+      "ts/no-misused-promises": ["error"],
+      "ts/no-unnecessary-type-assertion": ["error"],
+      "ts/no-unsafe-argument": ["error"],
+      "ts/no-unsafe-assignment": ["error"],
+      "ts/no-unsafe-call": ["error"],
+      "ts/no-unsafe-member-access": ["error"],
+      "ts/no-unsafe-return": ["error"],
+      "ts/promise-function-async": ["error"],
+      "ts/restrict-plus-operands": ["error"],
+      "ts/restrict-template-expressions": ["error"],
+      "ts/return-await": ["error", "in-try-catch"],
+      "ts/strict-boolean-expressions": [
+        "error",
+        { allowNullableBoolean: true, allowNullableObject: true }
+      ],
+      "ts/switch-exhaustiveness-check": ["error"],
+      "ts/unbound-method": ["error"]
+    };
+    const [plugin4, parser] = await Promise.all([
+      interopDefault(import("@typescript-eslint/eslint-plugin")),
+      interopDefault(import("@typescript-eslint/parser"))
+    ]);
+    const { parserOptions } = this.options;
+    const boundCreateRuleConfig = this.createRuleConfig.bind(this);
+    function makeParser(typeAware, files2, ignores = []) {
+      return boundCreateRuleConfig(typeAware ? "parser-type-aware" : "parser", {
+        files: files2,
+        ignores,
+        languageOptions: {
+          parser,
+          parserOptions: {
+            sourceType: "module",
+            ...typeAware ? {
+              projectService: {
+                allowDefaultProject: ["./*.js"],
+                defaultProject: tsconfigPath
+              },
+              tsconfigRootDir: process.cwd()
+            } : {},
+            ...parserOptions
           }
-        ],
-        "ts/no-use-before-define": [
-          "error",
-          { classes: false, functions: false, variables: true }
-        ],
-        "ts/no-useless-constructor": ["error"],
-        "ts/no-wrapper-object-types": ["error"],
-        "ts/triple-slash-reference": ["off"],
-        "ts/unified-signatures": ["off"],
-        ...type === "lib" ? {
-          "ts/explicit-function-return-type": [
+        }
+      });
+    }
+    return [
+      this.createRuleConfig("setup", {
+        plugins: {
+          ts: plugin4
+        }
+      }),
+      makeParser(false, files),
+      ...isTypeAware ? [makeParser(true, filesTypeAware, this.options.ignoresTypeAware)] : [],
+      this.createRuleConfig("rules", {
+        files,
+        rules: {
+          ...renameRules(plugin4.configs["eslint-recommended"].overrides[0].rules, {
+            "@typescript-eslint": "ts"
+          }),
+          ...renameRules(plugin4.configs.strict.rules, {
+            "@typescript-eslint": "ts"
+          }),
+          "no-dupe-class-members": ["off"],
+          "no-redeclare": ["off"],
+          "no-use-before-define": ["off"],
+          "no-useless-constructor": ["off"],
+          "ts/ban-ts-comment": ["error", { "ts-expect-error": "allow-with-description" }],
+          "ts/consistent-type-definitions": ["error", "interface"],
+          "ts/consistent-type-imports": [
             "error",
             {
-              allowExpressions: true,
-              allowHigherOrderFunctions: true,
-              allowIIFEs: true
+              disallowTypeAnnotations: false,
+              fixStyle: "separate-type-imports",
+              prefer: "type-imports"
             }
-          ]
-        } : {},
-        ...overrides
-      }
-    },
-    ...isTypeAware ? [
-      {
-        name: `${NAMESPACE19}/rules-type-aware`,
-        files: filesTypeAware,
-        ignores: ignoresTypeAware,
-        rules: {
-          ...typeAwareRules,
-          ...typeAwareOverrides
+          ],
+          // See: https://www.totaltypescript.com/method-shorthand-syntax-considered-harmful
+          "ts/method-signature-style": ["error", "property"],
+          "ts/no-dupe-class-members": ["error"],
+          "ts/no-dynamic-delete": ["off"],
+          "ts/no-empty-object-type": ["error", { allowInterfaces: "always" }],
+          "ts/no-explicit-any": ["warn"],
+          "ts/no-extraneous-class": ["off"],
+          "ts/no-import-type-side-effects": ["error"],
+          "ts/no-invalid-void-type": ["error"],
+          "ts/no-non-null-assertion": ["error"],
+          "ts/no-redeclare": ["error", { builtinGlobals: false }],
+          "ts/no-require-imports": ["error"],
+          "ts/no-unused-expressions": [
+            "error",
+            {
+              allowShortCircuit: true,
+              allowTaggedTemplates: true,
+              allowTernary: true
+            }
+          ],
+          "ts/no-unused-vars": "off",
+          "ts/no-use-before-define": [
+            "error",
+            { classes: false, functions: false, variables: true }
+          ],
+          "ts/no-useless-constructor": ["error"],
+          "ts/no-wrapper-object-types": ["error"],
+          "ts/triple-slash-reference": ["off"],
+          "ts/unified-signatures": ["off"],
+          ...this.options.type === "lib" ? {
+            "ts/explicit-function-return-type": [
+              "error",
+              {
+                allowExpressions: true,
+                allowHigherOrderFunctions: true,
+                allowIIFEs: true
+              }
+            ]
+          } : {},
+          ...this.options.overrides
         }
-      }
-    ] : []
-  ];
-}
+      }),
+      ...isTypeAware ? [
+        this.createRuleConfig("rules-type-aware", {
+          files: filesTypeAware,
+          ignores: this.options.ignoresTypeAware,
+          rules: {
+            ...typeAwareRules,
+            ...this.options.typeAwareOverrides
+          }
+        })
+      ] : []
+    ];
+  }
+};
 
 // src/configs/vue.ts
-init_esm_shims();
-var NAMESPACE20 = "exbotanical/vue";
-async function vue({
-  files = [GLOB_VUE],
-  overrides = {},
-  typescript: typescript2 = true,
-  vueVersion = 3,
-  graphql: graphql2 = false
-}, { indent } = STYLE_DEFAULTS) {
-  const [pluginVue, parserVue, processorVueBlocks] = await Promise.all([
-    interopDefault(import("eslint-plugin-vue")),
-    interopDefault(import("vue-eslint-parser")),
-    interopDefault(import("eslint-processor-vue-blocks"))
-  ]);
-  return [
-    {
-      name: `${NAMESPACE20}/setup`,
-      plugins: {
-        vue: pluginVue
-      },
-      languageOptions: {
-        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"
-        }
-      }
-    },
-    {
-      name: `${NAMESPACE20}/rules`,
+var VueConfig = class extends CustomConfig {
+  namespace = "vue";
+  constructor({
+    files = [GLOB_VUE],
+    typescript = true,
+    vueVersion = 3,
+    graphql = false,
+    indent = STYLE_DEFAULTS.indent,
+    ...rest
+  } = {}) {
+    super({
       files,
-      languageOptions: {
-        parser: parserVue,
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true
-          },
-          extraFileExtensions: [".vue"],
-          parser: typescript2 ? await interopDefault(import("@typescript-eslint/parser")) : null,
-          sourceType: "module"
-        }
-      },
-      processor: graphql2 === false ? pluginVue.processors[".vue"] : mergeProcessors([
-        pluginVue.processors[".vue"],
-        processorVueBlocks({
-          blocks: {
-            script: true,
-            scriptSetup: true,
-            customBlocks: true
-          }
-        })
-      ]),
-      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
+      typescript,
+      vueVersion,
+      graphql,
+      indent,
+      ...rest
+    });
+  }
+  async _rules() {
+    const {
+      files = [GLOB_VUE],
+      overrides = {},
+      typescript = true,
+      vueVersion = 3,
+      graphql = false,
+      indent = STYLE_DEFAULTS.indent
+    } = this.options;
+    const [pluginVue, parserVue, processorVueBlocks] = await Promise.all([
+      interopDefault(import("eslint-plugin-vue")),
+      interopDefault(import("vue-eslint-parser")),
+      interopDefault(import("eslint-processor-vue-blocks"))
+    ]);
+    return [
+      this.createRuleConfig("setup", {
+        plugins: {
+          vue: pluginVue
         },
-        "node/prefer-global/process": "off",
-        "ts/explicit-function-return-type": "off",
-        "vue/block-order": [
-          "error",
-          {
-            order: ["script", "template", "style"]
-          }
-        ],
-        "vue/component-name-in-template-casing": ["error", "PascalCase"],
-        "vue/component-options-name-casing": ["error", "PascalCase"],
-        "vue/component-tags-order": "off",
-        "vue/custom-event-name-casing": ["error", "camelCase"],
-        "vue/define-macros-order": [
-          "error",
-          {
-            order: ["defineOptions", "defineProps", "defineEmits", "defineSlots"]
-          }
-        ],
-        "vue/dot-location": ["error", "property"],
-        "vue/dot-notation": ["error", { allowKeywords: true }],
-        "vue/eqeqeq": ["error", "smart"],
-        "vue/html-indent": ["error", indent],
-        "vue/html-quotes": ["error", "double"],
-        "vue/max-attributes-per-line": "off",
-        "vue/multi-word-component-names": "off",
-        "vue/no-dupe-keys": "off",
-        "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-setup-props-reactivity-loss": "off",
-        "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/prop-name-casing": ["error", "camelCase"],
-        "vue/require-default-prop": "off",
-        "vue/require-prop-types": "off",
-        "vue/space-infix-ops": "error",
-        "vue/space-unary-ops": ["error", { nonwords: false, words: true }],
-        "vue/array-bracket-spacing": ["error", "never"],
-        "vue/arrow-spacing": ["error", { after: true, before: true }],
-        "vue/block-spacing": ["error", "always"],
-        "vue/block-tag-newline": [
-          "error",
-          {
-            multiline: "always",
-            singleline: "always"
+        languageOptions: {
+          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"
           }
-        ],
-        "vue/brace-style": ["error", "stroustrup", { allowSingleLine: true }],
-        "vue/comma-dangle": ["error", "always-multiline"],
-        "vue/comma-spacing": ["error", { after: true, before: false }],
-        "vue/comma-style": ["error", "last"],
-        "vue/html-comment-content-spacing": [
-          "error",
-          "always",
-          {
-            exceptions: ["-"]
+        }
+      }),
+      this.createRuleConfig("rules", {
+        files,
+        languageOptions: {
+          parser: parserVue,
+          parserOptions: {
+            ecmaFeatures: {
+              jsx: true
+            },
+            extraFileExtensions: [".vue"],
+            parser: typescript ? await interopDefault(import("@typescript-eslint/parser")) : null,
+            sourceType: "module"
           }
-        ],
-        "vue/key-spacing": ["error", { afterColon: true, beforeColon: false }],
-        "vue/keyword-spacing": ["error", { after: true, before: true }],
-        "vue/object-curly-newline": "off",
-        "vue/object-curly-spacing": ["error", "always"],
-        "vue/object-property-newline": [
-          "error",
-          { allowMultiplePropertiesPerLine: true }
-        ],
-        "vue/operator-linebreak": ["error", "before"],
-        "vue/padding-line-between-blocks": ["error", "always"],
-        "vue/quote-props": ["error", "consistent-as-needed"],
-        "vue/space-in-parens": ["error", "never"],
-        "vue/template-curly-spacing": "error",
-        ...overrides
-      }
-    }
-  ];
-}
+        },
+        processor: graphql === false ? pluginVue.processors[".vue"] : mergeProcessors([
+          pluginVue.processors[".vue"],
+          processorVueBlocks({
+            blocks: {
+              script: true,
+              scriptSetup: true,
+              customBlocks: true
+            }
+          })
+        ]),
+        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
+          },
+          "node/prefer-global/process": "off",
+          "ts/explicit-function-return-type": "off",
+          "vue/block-order": [
+            "error",
+            {
+              order: ["script", "template", "style"]
+            }
+          ],
+          "vue/component-name-in-template-casing": ["error", "PascalCase"],
+          "vue/component-options-name-casing": ["error", "PascalCase"],
+          "vue/component-tags-order": "off",
+          "vue/custom-event-name-casing": ["error", "camelCase"],
+          "vue/define-macros-order": [
+            "error",
+            {
+              order: ["defineOptions", "defineProps", "defineEmits", "defineSlots"]
+            }
+          ],
+          "vue/dot-location": ["error", "property"],
+          "vue/dot-notation": ["error", { allowKeywords: true }],
+          "vue/eqeqeq": ["error", "smart"],
+          "vue/html-indent": ["error", indent],
+          "vue/html-quotes": ["error", "double"],
+          "vue/max-attributes-per-line": "off",
+          "vue/multi-word-component-names": "off",
+          "vue/no-dupe-keys": "off",
+          "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-setup-props-reactivity-loss": "off",
+          "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/prop-name-casing": ["error", "camelCase"],
+          "vue/require-default-prop": "off",
+          "vue/require-prop-types": "off",
+          "vue/space-infix-ops": "error",
+          "vue/space-unary-ops": ["error", { nonwords: false, words: true }],
+          "vue/array-bracket-spacing": ["error", "never"],
+          "vue/arrow-spacing": ["error", { after: true, before: true }],
+          "vue/block-spacing": ["error", "always"],
+          "vue/block-tag-newline": [
+            "error",
+            {
+              multiline: "always",
+              singleline: "always"
+            }
+          ],
+          "vue/brace-style": ["error", "stroustrup", { allowSingleLine: true }],
+          "vue/comma-dangle": ["error", "always-multiline"],
+          "vue/comma-spacing": ["error", { after: true, before: false }],
+          "vue/comma-style": ["error", "last"],
+          "vue/html-comment-content-spacing": [
+            "error",
+            "always",
+            {
+              exceptions: ["-"]
+            }
+          ],
+          "vue/key-spacing": ["error", { afterColon: true, beforeColon: false }],
+          "vue/keyword-spacing": ["error", { after: true, before: true }],
+          "vue/object-curly-newline": "off",
+          "vue/object-curly-spacing": ["error", "always"],
+          "vue/object-property-newline": [
+            "error",
+            { allowMultiplePropertiesPerLine: true }
+          ],
+          "vue/operator-linebreak": ["error", "before"],
+          "vue/padding-line-between-blocks": ["error", "always"],
+          "vue/quote-props": ["error", "consistent-as-needed"],
+          "vue/space-in-parens": ["error", "never"],
+          "vue/template-curly-spacing": "error",
+          ...overrides
+        }
+      })
+    ];
+  }
+};
 
 // src/configs/yaml.ts
-init_esm_shims();
-var NAMESPACE21 = "exbotanical/yaml";
-async function yaml({ files = [GLOB_YAML], overrides = {} } = {}, { indent, quotes } = STYLE_DEFAULTS) {
-  const [plugin4, parser] = await Promise.all([
-    interopDefault(import("eslint-plugin-yml")),
-    interopDefault(import("yaml-eslint-parser"))
-  ]);
-  return [
-    {
-      name: `${NAMESPACE21}/setup`,
-      plugins: {
-        yaml: plugin4
-      }
-    },
-    {
-      name: `${NAMESPACE21}/rules`,
+var YamlConfig = class extends CustomConfig {
+  namespace = "yaml";
+  constructor({
+    files = [GLOB_YAML],
+    indent = STYLE_DEFAULTS.indent,
+    quotes = STYLE_DEFAULTS.quotes,
+    ...rest
+  } = {}) {
+    super({
       files,
-      languageOptions: {
-        parser
-      },
-      rules: {
-        "style/spaced-comment": "off",
-        "yaml/block-mapping-colon-indicator-newline": "error",
-        "yaml/block-mapping-question-indicator-newline": "error",
-        "yaml/block-mapping": "error",
-        "yaml/block-sequence": "error",
-        "yaml/no-empty-key": "error",
-        "yaml/no-empty-sequence-entry": "error",
-        "yaml/no-irregular-whitespace": "error",
-        "yaml/plain-scalar": "error",
-        "yaml/vue-custom-block/no-parsing-error": "error",
-        "yaml/block-sequence-hyphen-indicator-newline": "error",
-        "yaml/flow-mapping-curly-newline": "error",
-        "yaml/flow-mapping-curly-spacing": "error",
-        "yaml/flow-sequence-bracket-newline": "error",
-        "yaml/flow-sequence-bracket-spacing": "error",
-        "yaml/indent": ["error", indent === "tab" ? 2 : indent],
-        "yaml/key-spacing": "error",
-        "yaml/no-tab-indent": "error",
-        "yaml/quotes": [
-          "error",
-          {
-            avoidEscape: true,
-            prefer: quotes === "backtick" ? "single" : quotes
+      indent,
+      quotes,
+      ...rest
+    });
+  }
+  async _rules() {
+    const {
+      files = [GLOB_YAML],
+      overrides = {},
+      indent = STYLE_DEFAULTS.indent,
+      quotes = STYLE_DEFAULTS.quotes,
+      sortKeys = []
+    } = this.options;
+    const [plugin4, parser] = await Promise.all([
+      interopDefault(import("eslint-plugin-yml")),
+      interopDefault(import("yaml-eslint-parser"))
+    ]);
+    return [
+      this.createRuleConfig("setup", {
+        plugins: {
+          yaml: plugin4
+        }
+      }),
+      this.createRuleConfig("rules", {
+        files,
+        languageOptions: {
+          parser
+        },
+        rules: {
+          "style/spaced-comment": "off",
+          "yaml/block-mapping-colon-indicator-newline": "error",
+          "yaml/block-mapping-question-indicator-newline": "error",
+          "yaml/block-mapping": "error",
+          "yaml/block-sequence": "error",
+          "yaml/no-empty-key": "error",
+          "yaml/no-empty-sequence-entry": "error",
+          "yaml/no-irregular-whitespace": "error",
+          "yaml/plain-scalar": "error",
+          "yaml/vue-custom-block/no-parsing-error": "error",
+          "yaml/block-sequence-hyphen-indicator-newline": "error",
+          "yaml/flow-mapping-curly-newline": "error",
+          "yaml/flow-mapping-curly-spacing": "error",
+          "yaml/flow-sequence-bracket-newline": "error",
+          "yaml/flow-sequence-bracket-spacing": "error",
+          "yaml/indent": ["error", indent === "tab" ? 2 : indent],
+          "yaml/key-spacing": "error",
+          "yaml/no-tab-indent": "error",
+          "yaml/quotes": [
+            "error",
+            {
+              avoidEscape: true,
+              prefer: quotes === "backtick" ? "single" : quotes
+            }
+          ],
+          "yaml/spaced-comment": "error",
+          "yaml/no-empty-document": "error",
+          "yaml/no-empty-mapping-value": "error",
+          "yaml/no-trailing-zeros": "error",
+          "yaml/no-multiple-empty-lines": "error",
+          ...overrides
+        }
+      }),
+      ...sortKeys.length > 0 ? [
+        this.createRuleConfig("sort-keys", {
+          files: sortKeys,
+          languageOptions: {
+            parser
+          },
+          rules: {
+            "yaml/sort-keys": [
+              "error",
+              "asc",
+              { allowLineSeparatedGroups: true, natural: true }
+            ]
           }
-        ],
-        "yaml/spaced-comment": "error",
-        "yaml/no-empty-document": "error",
-        "yaml/no-empty-mapping-value": "error",
-        "yaml/no-trailing-zeros": "error",
-        "yaml/no-multiple-empty-lines": "error",
-        ...overrides
-      }
-    }
-  ];
-}
+        })
+      ] : []
+    ];
+  }
+};
 
 // src/factory.ts
 async function exbotanical({
@@ -2951,55 +2465,96 @@ async function exbotanical({
   react: optionsReact,
   vue: optionsVue,
   graphql: optionsGraphql,
+  packageJson: optionsPackageJson = false,
+  jsonSchema: optionsJsonSchema = false,
+  githubAction: optionsGithubAction = false,
+  css: optionsCss = false,
+  perfectionist: optionsPerfectionist,
   type
-}, ...userConfigs) {
+} = {}, ...userConfigs) {
   const configs2 = [
-    perfectionist(),
-    unicorn(),
-    comments(),
-    imports(),
-    javascript({ ...optionsJavascript, type }),
-    jsdoc(),
-    jsx(),
-    node(),
-    regexpr(),
-    test({ ...factoryConfig(optionsTest) })
+    new PerfectionistConfig({ ...optionsPerfectionist }).rules(),
+    new UnicornConfig().rules(),
+    new CommentsConfig().rules(),
+    new ImportsConfig().rules(),
+    new JavascriptConfig({ ...optionsJavascript, type }).rules(),
+    new JsdocConfig().rules(),
+    new JsxConfig().rules(),
+    new NodeConfig().rules(),
+    new RegexprConfig().rules(),
+    new TestConfig({ ...factoryConfig(optionsTest) }).rules()
   ];
   if (optionsJsonc) {
     configs2.push(
-      packageJson(),
-      tsconfig(),
-      jsonc({
+      ...optionsPackageJson ? [] : [new PackageJsonConfig().rules()],
+      new TsconfigConfig().rules(),
+      new JsoncConfig({
         ...factoryConfig(optionsJsonc),
         ...optionsStyle
-      })
+      }).rules()
+    );
+  }
+  if (optionsPackageJson) {
+    configs2.push(
+      new PackageJsonPluginConfig({ ...factoryConfig(optionsPackageJson) }).rules()
+    );
+  }
+  if (optionsJsonSchema) {
+    configs2.push(new JsonSchemaConfig({ ...factoryConfig(optionsJsonSchema) }).rules());
+  }
+  if (optionsGithubAction) {
+    configs2.push(
+      new GithubActionConfig({ ...factoryConfig(optionsGithubAction) }).rules()
     );
   }
+  if (optionsCss) {
+    configs2.push(new CssConfig({ ...factoryConfig(optionsCss) }).rules());
+  }
   if (optionsMarkdown) {
-    configs2.push(markdown({ ...factoryConfig(optionsMarkdown) }));
+    configs2.push(new MarkdownConfig({ ...factoryConfig(optionsMarkdown) }).rules());
   }
   if (optionsGraphql) {
-    configs2.push(graphql());
+    configs2.push(new GraphqlConfig().rules());
   }
   if (optionsReact) {
-    configs2.push(react({ ...factoryConfig(optionsReact) }));
+    configs2.push(new ReactConfig({ ...factoryConfig(optionsReact) }).rules());
   }
   if (optionsToml) {
-    configs2.push(toml({ ...factoryConfig(optionsToml), ...optionsStyle }));
+    configs2.push(
+      new TomlConfig({ ...factoryConfig(optionsToml), ...optionsStyle }).rules()
+    );
   }
   if (optionsTypescript) {
-    configs2.push(typescript({ ...factoryConfig(optionsTypescript), type }));
+    configs2.push(
+      new TypescriptConfig({ ...factoryConfig(optionsTypescript), type }).rules()
+    );
   }
   if (optionsVue) {
-    configs2.push(vue({ ...factoryConfig(optionsVue), graphql: !!optionsGraphql }));
+    configs2.push(
+      new VueConfig({ ...factoryConfig(optionsVue), graphql: !!optionsGraphql }).rules()
+    );
   }
   if (optionsYaml) {
-    configs2.push(yaml({ ...factoryConfig(optionsYaml), ...optionsStyle }));
+    configs2.push(
+      new YamlConfig({ ...factoryConfig(optionsYaml), ...optionsStyle }).rules()
+    );
   }
+  configs2.push(
+    new DataFilesConfig({
+      files: [
+        ...optionsJsonc ? [GLOB_JSON, GLOB_JSON5, GLOB_JSONC] : [],
+        ...optionsYaml ? [GLOB_YAML] : [],
+        ...optionsToml ? [GLOB_TOML] : []
+      ]
+    }).rules()
+  );
   if (formatter) {
-    configs2.push(prettier());
+    configs2.push(new PrettierConfig().rules());
   }
-  configs2.push(disables(), ignores(optionsIgnore));
+  configs2.push(
+    new DisablesConfig().rules(),
+    new IgnoresConfig({ files: optionsIgnore }).rules()
+  );
   if (userConfigs.length > 0) {
     const resolved2 = await Promise.all(userConfigs);
     configs2.push(...resolved2.map((r) => Promise.resolve(Array.isArray(r) ? r : [r])));
@@ -3011,12 +2566,33 @@ function factoryConfig(options) {
   if (!options) return {};
   return typeof options === "boolean" ? {} : options;
 }
-
-// src/options.ts
-init_esm_shims();
-
-// src/types.ts
-init_esm_shims();
 export {
+  GLOB_CSS,
+  GLOB_EXCLUDES,
+  GLOB_GITHUB_WORKFLOW,
+  GLOB_GRAPHQL,
+  GLOB_HTML,
+  GLOB_JS,
+  GLOB_JSON,
+  GLOB_JSON5,
+  GLOB_JSONC,
+  GLOB_JSX,
+  GLOB_LESS,
+  GLOB_MARKDOWN,
+  GLOB_MARKDOWN_CODE,
+  GLOB_POSTCSS,
+  GLOB_SCRIPTS,
+  GLOB_SCSS,
+  GLOB_SRC,
+  GLOB_SRC_EXT,
+  GLOB_STYLE,
+  GLOB_SVG,
+  GLOB_TESTS,
+  GLOB_TOML,
+  GLOB_TS,
+  GLOB_TSX,
+  GLOB_VUE,
+  GLOB_XML,
+  GLOB_YAML,
   exbotanical as default
 };