@hexadrop/eslint-config 0.1.18 → 0.1.19

package/dist/index.cjs

@@ -0,0 +1,2019 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  combine: () => combine,
+  default: () => hexadrop
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/factory.ts
+var import_eslint_flat_config_utils = require("eslint-flat-config-utils");
+
+// src/config/astro/astro.config.ts
+var import_globals = __toESM(require("globals"), 1);
+
+// src/utils/combine.ts
+async function combine(...configs) {
+  const resolved = await Promise.all(configs.map((config) => Promise.resolve(config)));
+  return resolved.flat();
+}
+
+// src/utils/extract-typed-flat-config-item.ts
+var flatConfigProperties = [
+  "name",
+  "files",
+  "ignores",
+  "languageOptions",
+  "linterOptions",
+  "processor",
+  "plugins",
+  "rules",
+  "settings"
+];
+function extractTypedFlatConfigItem(config) {
+  if (!config) {
+    return void 0;
+  }
+  const result = {};
+  for (const key of flatConfigProperties) {
+    if (key in config) {
+      result[key] = config[key];
+    }
+  }
+  if (Object.keys(result).length === 0) {
+    return void 0;
+  }
+  return result;
+}
+
+// src/utils/interop-default.ts
+async function interopDefault(m) {
+  const resolved = await m;
+  return resolved.default ?? resolved;
+}
+
+// src/utils/plugin-config-override-rules.ts
+var import_eslint = require("eslint");
+
+// src/utils/rename-rules.ts
+function renameRules(rules, map) {
+  if (Object.keys(map).length === 0) {
+    return rules;
+  }
+  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];
+        }
+      }
+      return [key, value];
+    })
+  );
+}
+
+// src/utils/plugin-config-override-rules.ts
+function pluginConfigOverrideRules(plugin, configName, indexOrMap, map2) {
+  let index = 0;
+  let map = {};
+  if (typeof indexOrMap === "number") {
+    index = indexOrMap;
+  }
+  if (typeof indexOrMap === "object") {
+    map = indexOrMap;
+  } else if (typeof map2 === "object") {
+    map = map2;
+  }
+  let rules = {};
+  if (plugin.configs && configName in plugin.configs) {
+    const config = plugin.configs[configName];
+    if (config && "overrides" in config) {
+      const overrides = config.overrides;
+      const indexOverride = overrides ? overrides[index] : void 0;
+      if (indexOverride?.rules) {
+        rules = indexOverride.rules;
+      }
+    }
+  }
+  return renameRules(rules, map);
+}
+var plugin_config_override_rules_default = pluginConfigOverrideRules;
+
+// src/utils/plugin-config-rules.ts
+var import_eslint2 = require("eslint");
+function pluginConfigRules(plugin, configName, map = {}) {
+  let rules = {};
+  if (plugin.configs && configName in plugin.configs) {
+    const config = plugin.configs[configName];
+    if (config && "rules" in config && config.rules) {
+      rules = config.rules;
+    }
+  }
+  return renameRules(rules, map);
+}
+
+// src/utils/to-array.ts
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/const/plugin-prefix.ts
+var PLUGIN_PREFIX = "hexadrop";
+var plugin_prefix_default = PLUGIN_PREFIX;
+
+// src/const/plugin-rename-typescript.ts
+var PLUGIN_RENAME_TYPESCRIPT = {
+  "@typescript-eslint": "typescript"
+};
+var plugin_rename_typescript_default = PLUGIN_RENAME_TYPESCRIPT;
+
+// src/const/plugin-rename.ts
+var PLUGIN_RENAME = {
+  ...plugin_rename_typescript_default,
+  "@stylistic": "style",
+  "import-x": "import",
+  jsonc: "json",
+  n: "node",
+  "simple-import-sort": "import-sort",
+  "unused-imports": "import-unused",
+  vitest: "test",
+  yml: "yaml"
+};
+var plugin_rename_default = PLUGIN_RENAME;
+
+// src/config/astro/astro.config-name.ts
+var ASTRO_CONFIG_NAME = `${plugin_prefix_default}/astro`;
+var ASTRO_CONFIG_NAME_SETUP = `${ASTRO_CONFIG_NAME}/setup`;
+var ASTRO_CONFIG_NAME_SETUP_PARSER = `${ASTRO_CONFIG_NAME_SETUP}/parser`;
+var ASTRO_CONFIG_NAME_SETUP_PARSER_JAVASCRIPT = `${ASTRO_CONFIG_NAME_SETUP_PARSER}/javascript`;
+var ASTRO_CONFIG_NAME_SETUP_PARSER_TYPESCRIPT = `${ASTRO_CONFIG_NAME_SETUP_PARSER}/typescript`;
+var ASTRO_CONFIG_NAME_RULES = `${ASTRO_CONFIG_NAME}/rules`;
+
+// src/config/astro/astro.globs.ts
+var GLOB_ASTRO = ["*.astro", "**/*.astro"];
+var GLOB_ASTRO_JAVASCRIPT = ["**/*.astro/*.js", "*.astro/*.js"];
+var GLOB_ASTRO_TYPESCRIPT = ["**/*.astro/*.ts", "*.astro/*.ts"];
+
+// src/config/astro/astro.config.ts
+async function astro(options) {
+  const { astro: astro2, typescript: typescript2 } = options;
+  if (!astro2) {
+    return [];
+  }
+  const [plugin, parser, parserTypescript] = await Promise.all([
+    interopDefault(import("eslint-plugin-astro")),
+    interopDefault(import("astro-eslint-parser")),
+    interopDefault(import("@typescript-eslint/parser"))
+  ]);
+  const configs = [
+    {
+      name: ASTRO_CONFIG_NAME_SETUP,
+      plugins: {
+        astro: plugin
+      }
+    },
+    {
+      files: GLOB_ASTRO,
+      languageOptions: {
+        globals: {
+          ...import_globals.default.node,
+          Astro: false,
+          Fragment: false
+        },
+        parser,
+        parserOptions: {
+          extraFileExtensions: [".astro"],
+          parser: typescript2 ? parserTypescript : void 0
+        },
+        sourceType: "module"
+      },
+      name: ASTRO_CONFIG_NAME_SETUP_PARSER,
+      processor: typescript2 ? "astro/client-side-ts" : "astro/astro"
+    },
+    {
+      files: GLOB_ASTRO_JAVASCRIPT,
+      languageOptions: {
+        globals: {
+          ...import_globals.default.browser
+        },
+        sourceType: "module"
+      },
+      name: ASTRO_CONFIG_NAME_SETUP_PARSER_JAVASCRIPT
+    }
+  ];
+  if (typescript2) {
+    configs.push({
+      files: GLOB_ASTRO_TYPESCRIPT,
+      languageOptions: {
+        globals: {
+          ...import_globals.default.browser
+        },
+        parser: parserTypescript,
+        parserOptions: {
+          project: typescript2 === true ? void 0 : toArray(typescript2)
+        },
+        sourceType: "module"
+      },
+      name: ASTRO_CONFIG_NAME_SETUP_PARSER_JAVASCRIPT
+    });
+  }
+  configs.push({
+    files: GLOB_ASTRO,
+    name: ASTRO_CONFIG_NAME_RULES,
+    rules: {
+      "astro/missing-client-only-directive-value": "error",
+      "astro/no-conflict-set-directives": "error",
+      "astro/no-deprecated-astro-canonicalurl": "error",
+      "astro/no-deprecated-astro-fetchcontent": "error",
+      "astro/no-deprecated-astro-resolve": "error",
+      "astro/no-deprecated-getentrybyslug": "error",
+      "astro/no-unused-define-vars-in-style": "error",
+      "astro/valid-compile": "error",
+      "no-useless-assignment": "off"
+    }
+  });
+  return configs;
+}
+
+// src/config/core/core.config.ts
+var import_globals2 = __toESM(require("globals"), 1);
+
+// src/config/markdown/markdown.config.ts
+var import_eslint_merge_processors = require("eslint-merge-processors");
+var import_eslint_parser_plain = require("eslint-parser-plain");
+
+// src/config/markdown/markdown.config-name.ts
+var MARKDOWN_CONFIG_NAME = `${plugin_prefix_default}/markdown`;
+var MARKDOWN_CONFIG_NAME_SETUP = `${MARKDOWN_CONFIG_NAME}/setup`;
+var MARKDOWN_CONFIG_NAME_SETUP_PROCESSOR = `${MARKDOWN_CONFIG_NAME_SETUP}/processor`;
+var MARKDOWN_CONFIG_NAME_SETUP_PARSER = `${MARKDOWN_CONFIG_NAME_SETUP}/parser`;
+
+// src/config/core/core.globs.ts
+var SOURCE_GLOBS = ["**/*.?([cm])[jt]s?(x)"];
+var JAVASCRIPT_GLOBS = ["**/*.?([cm])js?(x)"];
+var ESLINT_CONFIG_GLOBS = ["**/eslint.config.js"];
+
+// src/config/json/json.config-name.ts
+var JSON_CONFIG_NAME = `${plugin_prefix_default}/json`;
+var JSON_CONFIG_NAME_SETUP = `${JSON_CONFIG_NAME}/setup`;
+var JSON_CONFIG_NAME_SETUP_PARSER = `${JSON_CONFIG_NAME_SETUP}/parser`;
+var JSON_CONFIG_NAME_RULES = `${JSON_CONFIG_NAME}/rules`;
+
+// src/config/json/json.globs.ts
+var GLOB_JSON = ["**/*.json", "**/*.json5", "**/*.jsonc"];
+var GLOB_JSON_PACKAGE = ["**/package.json"];
+var GLOB_JSON_TSCONFIG = ["**/tsconfig.json", "**/tsconfig.*.json"];
+
+// src/config/json/json.config.ts
+async function json(options) {
+  const { json: json2 } = options;
+  if (!json2) {
+    return [];
+  }
+  const [pluginJsonc, parserJsonc] = await Promise.all([
+    interopDefault(import("eslint-plugin-jsonc")),
+    interopDefault(import("jsonc-eslint-parser"))
+  ]);
+  const jsonPluginRename = plugin_rename_default.jsonc;
+  return [
+    {
+      name: JSON_CONFIG_NAME_SETUP,
+      plugins: {
+        [jsonPluginRename]: pluginJsonc
+      }
+    },
+    {
+      files: GLOB_JSON,
+      languageOptions: {
+        parser: parserJsonc
+      },
+      name: JSON_CONFIG_NAME_SETUP_PARSER
+    },
+    {
+      files: GLOB_JSON,
+      name: JSON_CONFIG_NAME_RULES,
+      rules: {
+        [`${jsonPluginRename}/no-bigint-literals`]: "error",
+        [`${jsonPluginRename}/no-binary-expression`]: "error",
+        [`${jsonPluginRename}/no-binary-numeric-literals`]: "error",
+        [`${jsonPluginRename}/no-dupe-keys`]: "error",
+        [`${jsonPluginRename}/no-escape-sequence-in-identifier`]: "error",
+        [`${jsonPluginRename}/no-floating-decimal`]: "error",
+        [`${jsonPluginRename}/no-hexadecimal-numeric-literals`]: "error",
+        [`${jsonPluginRename}/no-infinity`]: "error",
+        [`${jsonPluginRename}/no-multi-str`]: "error",
+        [`${jsonPluginRename}/no-nan`]: "error",
+        [`${jsonPluginRename}/no-number-props`]: "error",
+        [`${jsonPluginRename}/no-numeric-separators`]: "error",
+        [`${jsonPluginRename}/no-octal-escape`]: "error",
+        [`${jsonPluginRename}/no-octal-numeric-literals`]: "error",
+        [`${jsonPluginRename}/no-octal`]: "error",
+        [`${jsonPluginRename}/no-parenthesized`]: "error",
+        [`${jsonPluginRename}/no-plus-sign`]: "error",
+        [`${jsonPluginRename}/no-regexp-literals`]: "error",
+        [`${jsonPluginRename}/no-sparse-arrays`]: "error",
+        [`${jsonPluginRename}/no-template-literals`]: "error",
+        [`${jsonPluginRename}/no-undefined-value`]: "error",
+        [`${jsonPluginRename}/no-unicode-codepoint-escapes`]: "error",
+        [`${jsonPluginRename}/no-useless-escape`]: "error",
+        [`${jsonPluginRename}/space-unary-ops`]: "error",
+        [`${jsonPluginRename}/valid-json-number`]: "error",
+        [`${jsonPluginRename}/vue-custom-block/no-parsing-error`]: "error"
+      }
+    }
+  ];
+}
+
+// src/config/markdown/markdown.globs.ts
+var GLOB_MARKDOWN = ["**/*.md"];
+var GLOB_MARKDOWN_IN_MARKDOWN = ["**/*.md/*.md"];
+var GLOB_MARKDOWN_SOURCE = SOURCE_GLOBS.flatMap((source) => GLOB_MARKDOWN.map((markdown2) => `${markdown2}/${source}`));
+var GLOB_MARKDOWN_JSON = GLOB_JSON.flatMap((json2) => GLOB_MARKDOWN.map((markdown2) => `${markdown2}/${json2}`));
+var GLOB_MARKDOWN_ASTRO = GLOB_ASTRO.flatMap((json2) => GLOB_MARKDOWN.map((markdown2) => `${markdown2}/${json2}`));
+
+// src/config/markdown/markdown.config.ts
+async function markdown(options) {
+  const { markdown: markdown2 } = options;
+  if (!markdown2) {
+    return [];
+  }
+  const pluginMarkdown = await interopDefault(import("@eslint/markdown"));
+  const processors = pluginMarkdown.processors;
+  const processor = processors?.["markdown"];
+  return [
+    {
+      name: MARKDOWN_CONFIG_NAME_SETUP,
+      plugins: {
+        markdown: pluginMarkdown
+      }
+    },
+    {
+      files: GLOB_MARKDOWN,
+      ignores: GLOB_MARKDOWN_IN_MARKDOWN,
+      name: MARKDOWN_CONFIG_NAME_SETUP_PROCESSOR,
+      /*
+       * `eslint-plugin-markdown` only creates virtual files for code blocks,
+       * but not the markdown file itself. We use `eslint-merge-processors` to
+       * add a pass-through processor for the markdown file itself.
+       */
+      processor: (0, import_eslint_merge_processors.mergeProcessors)([processor, import_eslint_merge_processors.processorPassThrough])
+    },
+    {
+      files: GLOB_MARKDOWN,
+      languageOptions: {
+        parser: {
+          meta: import_eslint_parser_plain.meta,
+          parseForESLint: import_eslint_parser_plain.parseForESLint
+        }
+      },
+      name: MARKDOWN_CONFIG_NAME_SETUP_PARSER
+    }
+  ];
+}
+
+// src/config/core/core.config-name.ts
+var CORE_CONFIG_NAME = `${plugin_prefix_default}/core`;
+var CORE_CONFIG_NAME_SETUP = `${CORE_CONFIG_NAME}/setup`;
+var CORE_CONFIG_NAME_RULES = `${CORE_CONFIG_NAME}/rules`;
+var CORE_CONFIG_NAME_RULES_MARKDOWN_SOURCE = `${CORE_CONFIG_NAME_RULES}/markdown/source`;
+var CORE_CONFIG_NAME_RULES_NODE = `${CORE_CONFIG_NAME_RULES}/node`;
+
+// src/config/core/core.config.ts
+async function core(options) {
+  const {
+    markdown: markdown2,
+    module: { node: useNodeModules },
+    node
+  } = options;
+  const nodePluginName = plugin_rename_default.n;
+  const configs = [
+    {
+      languageOptions: {
+        ecmaVersion: "latest",
+        globals: {
+          ...import_globals2.default.browser,
+          ...import_globals2.default.es2021,
+          ...import_globals2.default.node,
+          document: "readonly",
+          navigator: "readonly",
+          window: "readonly"
+        },
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          ecmaVersion: "latest",
+          sourceType: "module"
+        },
+        sourceType: "module"
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: true
+      },
+      name: CORE_CONFIG_NAME_SETUP,
+      plugins: {
+        ...node && {
+          [nodePluginName]: await interopDefault(import("eslint-plugin-n"))
+        }
+      }
+    },
+    {
+      name: CORE_CONFIG_NAME_RULES,
+      rules: {
+        "accessor-pairs": ["error", { enforceForClassMembers: true, setWithoutGet: true }],
+        "array-callback-return": ["error", { checkForEach: true }],
+        "block-scoped-var": "error",
+        camelcase: ["error", { properties: "never" }],
+        "consistent-this": ["error", "self"],
+        "constructor-super": "error",
+        "default-case-last": "error",
+        "dot-notation": "error",
+        eqeqeq: "error",
+        "for-direction": "error",
+        "func-name-matching": "error",
+        "func-names": ["error", "as-needed"],
+        "getter-return": "error",
+        "grouped-accessor-pairs": "error",
+        "guard-for-in": "error",
+        "max-depth": ["error", 4],
+        "max-params": "off",
+        "new-cap": ["error", { capIsNew: false }],
+        "no-alert": "error",
+        "no-array-constructor": "error",
+        "no-async-promise-executor": "error",
+        "no-await-in-loop": "error",
+        "no-bitwise": "error",
+        "no-caller": "error",
+        "no-case-declarations": "error",
+        "no-class-assign": "error",
+        "no-compare-neg-zero": "error",
+        "no-cond-assign": ["error", "always"],
+        "no-console": ["error", { allow: ["error"] }],
+        "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-delete-var": "error",
+        "no-dupe-args": "error",
+        "no-dupe-class-members": "error",
+        "no-dupe-else-if": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "error",
+        "no-duplicate-imports": "off",
+        "no-else-return": ["error", { allowElseIf: false }],
+        "no-empty": "error",
+        "no-empty-character-class": "error",
+        "no-empty-pattern": "error",
+        "no-empty-static-block": "error",
+        "no-eq-null": "error",
+        "no-eval": "error",
+        "no-ex-assign": "error",
+        "no-extend-native": "error",
+        "no-extra-bind": "error",
+        "no-extra-boolean-cast": "error",
+        "no-extra-label": "error",
+        "no-fallthrough": "error",
+        "no-func-assign": "error",
+        "no-global-assign": "error",
+        "no-implicit-coercion": "error",
+        "no-implicit-globals": "error",
+        "no-implied-eval": "error",
+        "no-import-assign": "error",
+        "no-inline-comments": "error",
+        "no-inner-declarations": "error",
+        "no-invalid-regexp": "error",
+        "no-invalid-this": "error",
+        "no-irregular-whitespace": "error",
+        "no-iterator": "error",
+        "no-label-var": "error",
+        "no-labels": ["error", { allowLoop: false, allowSwitch: false }],
+        "no-lone-blocks": "error",
+        "no-lonely-if": "error",
+        "no-loop-func": "error",
+        "no-loss-of-precision": "error",
+        "no-misleading-character-class": "error",
+        "no-multi-assign": "error",
+        "no-multi-str": "error",
+        "no-negated-condition": "error",
+        "no-new": "error",
+        "no-new-func": "error",
+        "no-new-native-nonconstructor": "error",
+        "no-new-wrappers": "error",
+        "no-nonoctal-decimal-escape": "error",
+        "no-obj-calls": "error",
+        "no-octal": "error",
+        "no-octal-escape": "error",
+        "no-param-reassign": "error",
+        "no-promise-executor-return": "error",
+        "no-proto": "error",
+        "no-prototype-builtins": "error",
+        "no-redeclare": "error",
+        "no-regex-spaces": "error",
+        "no-restricted-globals": [
+          "error",
+          { message: "Use `globalThis` instead.", name: "global" },
+          { message: "Use `globalThis` instead.", name: "self" }
+        ],
+        "no-restricted-properties": [
+          "error",
+          {
+            message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
+            property: "__proto__"
+          },
+          { message: "Use `Object.defineProperty` instead.", property: "__defineGetter__" },
+          { message: "Use `Object.defineProperty` instead.", property: "__defineSetter__" },
+          { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupGetter__" },
+          { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupSetter__" }
+        ],
+        "no-restricted-syntax": [
+          "error",
+          "DebuggerStatement",
+          "LabeledStatement",
+          "WithStatement",
+          "TSEnumDeclaration[const=true]",
+          "TSExportAssignment"
+        ],
+        "no-return-assign": "error",
+        "no-self-assign": "error",
+        "no-self-compare": "error",
+        "no-sequences": "error",
+        "no-setter-return": "error",
+        "no-shadow-restricted-names": "error",
+        "no-sparse-arrays": "error",
+        "no-template-curly-in-string": "error",
+        "no-this-before-super": "error",
+        "no-throw-literal": "error",
+        "no-undef": "error",
+        "no-undef-init": "error",
+        "no-underscore-dangle": "error",
+        "no-unexpected-multiline": "error",
+        "no-unmodified-loop-condition": "error",
+        "no-unneeded-ternary": "error",
+        "no-unreachable": "error",
+        "no-unreachable-loop": "error",
+        "no-unsafe-finally": "error",
+        "no-unsafe-negation": "error",
+        "no-unsafe-optional-chaining": "error",
+        "no-unused-expressions": "error",
+        "no-unused-labels": "error",
+        "no-unused-private-class-members": "error",
+        "no-use-before-define": [
+          "error",
+          {
+            allowNamedExports: false,
+            classes: true,
+            functions: false,
+            variables: true
+          }
+        ],
+        "no-useless-assignment": "error",
+        "no-useless-backreference": "error",
+        "no-useless-call": "error",
+        "no-useless-catch": "error",
+        "no-useless-computed-key": "error",
+        "no-useless-constructor": "error",
+        "no-useless-escape": "error",
+        "no-useless-rename": "error",
+        "no-useless-return": "error",
+        "no-var": "error",
+        "no-with": "error",
+        "object-shorthand": "error",
+        "one-var": "off",
+        "operator-assignment": ["error", "always"],
+        "prefer-arrow-callback": [
+          "error",
+          {
+            allowNamedFunctions: false,
+            allowUnboundThis: true
+          }
+        ],
+        "prefer-const": "error",
+        "prefer-exponentiation-operator": "error",
+        "prefer-named-capture-group": "error",
+        "prefer-numeric-literals": "error",
+        "prefer-object-has-own": "error",
+        "prefer-promise-reject-errors": "error",
+        "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        radix: "error",
+        "require-atomic-updates": "error",
+        "require-await": "error",
+        "require-yield": "error",
+        "symbol-description": "error",
+        "unicode-bom": ["error", "never"],
+        "use-isnan": ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }],
+        "valid-typeof": ["error", { requireStringLiterals: true }],
+        "vars-on-top": "error",
+        yoda: "error"
+      }
+    }
+  ];
+  if (node) {
+    configs.push({
+      name: CORE_CONFIG_NAME_RULES_NODE,
+      rules: {
+        [`${nodePluginName}/handle-callback-err`]: ["error", "^(err|error)$"],
+        [`${nodePluginName}/no-exports-assign`]: "error",
+        [`${nodePluginName}/no-new-require`]: "error",
+        ...useNodeModules && {
+          [`${nodePluginName}/no-deprecated-api`]: "error",
+          [`${nodePluginName}/no-path-concat`]: "error",
+          [`${nodePluginName}/prefer-global/buffer`]: ["error", "never"],
+          [`${nodePluginName}/prefer-global/process`]: ["error", "never"],
+          [`${nodePluginName}/process-exit-as-throw`]: "error"
+        }
+      }
+    });
+  }
+  if (markdown2) {
+    configs.push({
+      files: GLOB_MARKDOWN_SOURCE,
+      name: CORE_CONFIG_NAME_RULES_MARKDOWN_SOURCE,
+      rules: {
+        "no-console": "off",
+        "no-inline-comments": "off"
+      }
+    });
+  }
+  return configs;
+}
+
+// src/config/ignore/ignore.config.ts
+var import_node_fs = __toESM(require("fs"), 1);
+
+// src/config/ignore/ignore.config-name.ts
+var IGNORE_CONFIG_NAME = `${plugin_prefix_default}/ignore`;
+var IGNORE_CONFIG_NAME_DEFAULT = IGNORE_CONFIG_NAME;
+var IGNORE_CONFIG_NAME_ADDITIONAL = `${IGNORE_CONFIG_NAME}/additional`;
+var IGNORE_CONFIG_NAME_GITIGNORE = `${IGNORE_CONFIG_NAME}/gitignore`;
+
+// src/config/ignore/ignore.globs.ts
+var IGNORE_GLOB = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/output",
+  "**/coverage",
+  "**/temp",
+  "**/.temp",
+  "**/tmp",
+  "**/.tmp",
+  "**/.history",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.next",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/.yarn",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__"
+];
+var ignore_globs_default = IGNORE_GLOB;
+
+// src/config/ignore/ignore.config.ts
+async function ignore({ ignore: ignore2 }) {
+  if (ignore2 === false) {
+    return [];
+  }
+  const config = [
+    {
+      ignores: ignore_globs_default,
+      name: IGNORE_CONFIG_NAME_DEFAULT
+    }
+  ];
+  if (typeof ignore2 === "object" && ignore2.globs) {
+    config.push({
+      ignores: ignore2.globs,
+      name: IGNORE_CONFIG_NAME_ADDITIONAL
+    });
+  }
+  if (typeof ignore2 === "boolean") {
+    if (import_node_fs.default.existsSync(".gitignore")) {
+      const gitignore2 = await interopDefault(import("eslint-config-flat-gitignore"));
+      return [...config, { ...gitignore2(), name: IGNORE_CONFIG_NAME_GITIGNORE }];
+    }
+    return [];
+  }
+  const gitignore = await interopDefault(import("eslint-config-flat-gitignore"));
+  return [...config, { ...gitignore(ignore2), name: IGNORE_CONFIG_NAME_GITIGNORE }];
+}
+
+// src/config/typescript/typescript.config-name.ts
+var TYPESCRIPT_CONFIG_NAME = `${plugin_prefix_default}/typescript`;
+var TYPESCRIPT_CONFIG_NAME_SETUP = `${TYPESCRIPT_CONFIG_NAME}/setup`;
+var TYPESCRIPT_CONFIG_NAME_SETUP_PARSER = `${TYPESCRIPT_CONFIG_NAME_SETUP}/parser`;
+var TYPESCRIPT_CONFIG_NAME_SETUP_PARSER_TYPEAWARE = `${TYPESCRIPT_CONFIG_NAME_SETUP_PARSER}/type-aware`;
+var TYPESCRIPT_CONFIG_NAME_RULES = `${TYPESCRIPT_CONFIG_NAME}/rules`;
+var TYPESCRIPT_CONFIG_NAME_RULES_DTS = `${TYPESCRIPT_CONFIG_NAME_RULES}/dts`;
+var TYPESCRIPT_CONFIG_NAME_RULES_TEST = `${TYPESCRIPT_CONFIG_NAME_RULES}/test`;
+var TYPESCRIPT_CONFIG_NAME_RULES_TYPEAWARE = `${TYPESCRIPT_CONFIG_NAME_RULES}/type-aware`;
+
+// src/config/typescript/typescript.globs.ts
+var TYPESCRIPT_GLOBS = ["**/*.?([cm])ts?(x)"];
+var DTS_GLOBS = ["**/*.d.ts"];
+var TEST_GLOBS = ["**/*.spec.[jt]s?(x)", "**/*.test.[jt]s?(x)"];
+
+// src/config/typescript/typescript.parser.ts
+var import_node_process = require("process");
+function typescriptParser({
+  files,
+  ignores,
+  parser,
+  parserOptions,
+  tsconfigPath
+}) {
+  const config = {
+    files,
+    languageOptions: {
+      parser,
+      parserOptions: {
+        sourceType: "module",
+        ...tsconfigPath ? {
+          project: tsconfigPath,
+          tsconfigRootDir: (0, import_node_process.cwd)()
+        } : {},
+        ...parserOptions
+      }
+    },
+    name: tsconfigPath ? TYPESCRIPT_CONFIG_NAME_SETUP_PARSER_TYPEAWARE : TYPESCRIPT_CONFIG_NAME_SETUP_PARSER
+  };
+  if (ignores) {
+    config.ignores = ignores;
+  }
+  return config;
+}
+
+// src/config/typescript/typescript.config.ts
+async function typescript(options) {
+  const { typescript: typescript2 } = options;
+  if (typescript2 === false) {
+    return [];
+  }
+  const [plugin, parser] = await Promise.all([
+    interopDefault(import("@typescript-eslint/eslint-plugin")),
+    interopDefault(import("@typescript-eslint/parser"))
+  ]);
+  const typescriptPluginRename = plugin_rename_default["@typescript-eslint"];
+  const config = [];
+  const isTypeAware = typeof typescript2 !== "boolean";
+  config.push({
+    name: TYPESCRIPT_CONFIG_NAME_SETUP,
+    plugins: {
+      typescript: plugin
+    }
+  });
+  if (typescript2 === true) {
+    config.push(
+      typescriptParser({
+        files: SOURCE_GLOBS,
+        parser
+      })
+    );
+  } else {
+    config.push(
+      typescriptParser({
+        files: [...JAVASCRIPT_GLOBS, ...GLOB_MARKDOWN_SOURCE],
+        parser
+      }),
+      typescriptParser({
+        files: TYPESCRIPT_GLOBS,
+        ignores: GLOB_MARKDOWN_SOURCE,
+        parser,
+        tsconfigPath: toArray(typescript2)
+      })
+    );
+  }
+  config.push(
+    {
+      files: SOURCE_GLOBS,
+      name: TYPESCRIPT_CONFIG_NAME_RULES,
+      rules: {
+        ...plugin_config_override_rules_default(plugin, "eslint-recommended", plugin_rename_typescript_default),
+        ...pluginConfigRules(plugin, "strict", plugin_rename_typescript_default),
+        [`${typescriptPluginRename}/explicit-module-boundary-types`]: ["error"],
+        [`${typescriptPluginRename}/no-extraneous-class`]: "off",
+        // Disable the following rules, as they are covered by the eslint-plugin-unused-imports
+        [`${typescriptPluginRename}/no-unused-vars`]: "off"
+      }
+    },
+    {
+      files: DTS_GLOBS,
+      name: TYPESCRIPT_CONFIG_NAME_RULES_DTS,
+      rules: {
+        [`${typescriptPluginRename}/triple-slash-reference`]: "off"
+      }
+    }
+  );
+  if (isTypeAware) {
+    config.push({
+      files: TYPESCRIPT_GLOBS,
+      ignores: GLOB_MARKDOWN_SOURCE,
+      name: TYPESCRIPT_CONFIG_NAME_RULES_TYPEAWARE,
+      rules: {
+        ...pluginConfigRules(plugin, "strict-type-checked-only", plugin_rename_typescript_default),
+        [`${typescriptPluginRename}/no-confusing-void-expression`]: ["error", { ignoreArrowShorthand: true }],
+        [`${typescriptPluginRename}/no-deprecated`]: "warn",
+        [`${typescriptPluginRename}/no-unused-vars`]: "off",
+        [`${typescriptPluginRename}/prefer-readonly`]: ["error"],
+        [`${typescriptPluginRename}/promise-function-async`]: ["error", { checkArrowFunctions: false }],
+        [`${typescriptPluginRename}/switch-exhaustiveness-check`]: ["error"]
+      }
+    });
+  }
+  config.push({
+    files: TEST_GLOBS,
+    name: TYPESCRIPT_CONFIG_NAME_RULES_TEST,
+    rules: {
+      [`${typescriptPluginRename}/no-confusing-void-expression`]: "off"
+    }
+  });
+  return config;
+}
+
+// src/config/imports/imports.config-name.ts
+var IMPORTS_CONFIG_NAME = `${plugin_prefix_default}/imports`;
+var IMPORTS_CONFIG_NAME_SETUP = `${IMPORTS_CONFIG_NAME}/setup`;
+var IMPORTS_CONFIG_NAME_SETUP_TYPESCRIPT = `${IMPORTS_CONFIG_NAME_SETUP}/typescript`;
+var IMPORTS_CONFIG_NAME_RULES = `${IMPORTS_CONFIG_NAME}/rules`;
+var IMPORTS_CONFIG_NAME_RULES_WARNINGS = `${IMPORTS_CONFIG_NAME_RULES}/warnings`;
+var IMPORTS_CONFIG_NAME_RULES_WARNINGS_ESLINT_CONFIG = `${IMPORTS_CONFIG_NAME_RULES_WARNINGS}/eslint-config`;
+var IMPORTS_CONFIG_NAME_RULES_ASTRO = `${IMPORTS_CONFIG_NAME_RULES}/astro`;
+var IMPORTS_CONFIG_NAME_RULES_TYPESCRIPT = `${IMPORTS_CONFIG_NAME_RULES}/typescript`;
+var IMPORTS_CONFIG_NAME_RULES_STATIC = `${IMPORTS_CONFIG_NAME_RULES}/static`;
+var IMPORTS_CONFIG_NAME_RULES_STATIC_MARKDOWN_SOURCE = `${IMPORTS_CONFIG_NAME_RULES_STATIC}/markdown/source`;
+var IMPORTS_CONFIG_NAME_RULES_STYLISTIC = `${IMPORTS_CONFIG_NAME_RULES}/stylistic`;
+var IMPORTS_CONFIG_NAME_RULES_STYLISTIC_ASTRO = `${IMPORTS_CONFIG_NAME_RULES_STYLISTIC}/astro`;
+var IMPORTS_CONFIG_NAME_RULES_STYLISTIC_TYPESCRIPT_DTS = `${IMPORTS_CONFIG_NAME_RULES_STYLISTIC}/typescript/dts`;
+var IMPORTS_CONFIG_NAME_RULES_STYLISTIC_MARKDOWN_SOURCE = `${IMPORTS_CONFIG_NAME_RULES_STYLISTIC}/markdown/source`;
+
+// src/config/imports/imports.config.ts
+async function imports(options) {
+  const {
+    astro: astro2,
+    imports: imports2,
+    json: json2,
+    markdown: markdown2,
+    module: { amd, commonjs, ignore: ignoreModules, node: useNodeModules, webpack },
+    stylistic: stylistic2,
+    typescript: typescript2
+  } = options;
+  if (!imports2) {
+    return [];
+  }
+  const importXPlugin = "import-x";
+  const importXPluginRename = plugin_rename_default[importXPlugin];
+  const unusedImportsPrefix = plugin_rename_default["unused-imports"];
+  const importSortPrefix = plugin_rename_default["simple-import-sort"];
+  const { createNodeResolver, importX } = await import("eslint-plugin-import-x");
+  const { createTypeScriptImportResolver } = await import("eslint-import-resolver-typescript");
+  const configs = [
+    {
+      name: IMPORTS_CONFIG_NAME_SETUP,
+      plugins: {
+        // @ts-expect-error TS2352: Conversion error
+        [importXPluginRename]: importX,
+        ...stylistic2 && {
+          [importSortPrefix]: await interopDefault(import("eslint-plugin-simple-import-sort")),
+          [unusedImportsPrefix]: await interopDefault(import("eslint-plugin-unused-imports"))
+        }
+      },
+      settings: {
+        [`${importXPlugin}/resolver-next`]: [createNodeResolver({})]
+      }
+    }
+  ];
+  if (typescript2) {
+    const typeScriptExtensions = [".ts", ".tsx"];
+    configs.push({
+      files: TYPESCRIPT_GLOBS,
+      name: IMPORTS_CONFIG_NAME_SETUP_TYPESCRIPT,
+      settings: {
+        [`${importXPlugin}/extensions`]: typeScriptExtensions,
+        [`${importXPlugin}/external-module-folders`]: ["node_modules", "node_modules/@types"],
+        [`${importXPlugin}/parsers`]: {
+          "@typescript-eslint/parser": [...typeScriptExtensions, ".cts", ".mts"]
+        },
+        [`${importXPlugin}/resolver-next`]: [createNodeResolver(), createTypeScriptImportResolver()]
+      }
+    });
+  }
+  configs.push(
+    {
+      name: IMPORTS_CONFIG_NAME_RULES_WARNINGS,
+      rules: {
+        // Warnings rules https://github.com/un-ts/eslint-plugin-import-x?tab=readme-ov-file#helpful-warnings
+        [`${importXPluginRename}/export`]: "error",
+        [`${importXPluginRename}/no-deprecated`]: "off",
+        [`${importXPluginRename}/no-empty-named-blocks`]: "error",
+        [`${importXPluginRename}/no-extraneous-dependencies`]: "error",
+        [`${importXPluginRename}/no-mutable-exports`]: "error",
+        [`${importXPluginRename}/no-named-as-default-member`]: "warn",
+        [`${importXPluginRename}/no-named-as-default`]: "warn",
+        // Module system rules
+        ...!amd && {
+          [`${importXPluginRename}/no-amd`]: "error"
+        },
+        ...!commonjs && {
+          [`${importXPluginRename}/no-commonjs`]: "error"
+        },
+        ...!useNodeModules && {
+          [`${importXPluginRename}/no-nodejs-modules`]: "error"
+        },
+        [`${importXPluginRename}/default`]: "error"
+      }
+    },
+    {
+      name: IMPORTS_CONFIG_NAME_RULES_STATIC,
+      rules: {
+        // Static analysis rules https://github.com/un-ts/eslint-plugin-import-x?tab=readme-ov-file#static-analysis
+        [`${importXPluginRename}/named`]: "error",
+        [`${importXPluginRename}/no-absolute-path`]: "error",
+        [`${importXPluginRename}/no-cycle`]: [
+          "error",
+          {
+            ignoreExternal: true
+          }
+        ],
+        [`${importXPluginRename}/no-import-module-exports`]: "error",
+        [`${importXPluginRename}/no-relative-packages`]: "error",
+        [`${importXPluginRename}/no-restricted-paths`]: "off",
+        [`${importXPluginRename}/no-self-import`]: "error",
+        [`${importXPluginRename}/no-unresolved`]: ["error", { amd, commonjs, ignore: ignoreModules }],
+        [`${importXPluginRename}/no-useless-path-segments`]: [
+          "error",
+          {
+            commonjs,
+            noUselessIndex: true
+          }
+        ],
+        ...!webpack && {
+          [`${importXPluginRename}/no-webpack-loader-syntax`]: "error"
+        },
+        ...commonjs && {
+          [`${importXPluginRename}/no-dynamic-require`]: "error"
+        }
+      }
+    },
+    {
+      files: ESLINT_CONFIG_GLOBS,
+      name: IMPORTS_CONFIG_NAME_RULES_WARNINGS_ESLINT_CONFIG,
+      rules: {
+        [`${importXPluginRename}/default`]: "off",
+        [`${importXPluginRename}/no-deprecated`]: "off",
+        [`${importXPluginRename}/no-named-as-default-member`]: "off",
+        [`${importXPluginRename}/no-named-as-default`]: "off"
+      }
+    }
+  );
+  if (markdown2) {
+    configs.push({
+      files: [
+        ...GLOB_MARKDOWN_SOURCE,
+        ...json2 ? GLOB_MARKDOWN_JSON : [],
+        ...astro2 ? GLOB_MARKDOWN_ASTRO : []
+      ],
+      name: IMPORTS_CONFIG_NAME_RULES_STATIC_MARKDOWN_SOURCE,
+      rules: {
+        [`${importXPluginRename}/no-unresolved`]: "off"
+      }
+    });
+  }
+  if (typescript2) {
+    configs.push({
+      files: TYPESCRIPT_GLOBS,
+      name: IMPORTS_CONFIG_NAME_RULES_TYPESCRIPT,
+      rules: {
+        [`${importXPluginRename}/named`]: "off"
+      }
+    });
+  }
+  if (astro2) {
+    configs.push({
+      files: GLOB_ASTRO,
+      name: IMPORTS_CONFIG_NAME_RULES_ASTRO,
+      rules: {
+        [`${importXPluginRename}/named`]: "off"
+      }
+    });
+  }
+  if (stylistic2) {
+    configs.push({
+      name: IMPORTS_CONFIG_NAME_RULES_STYLISTIC,
+      rules: {
+        [`${importXPluginRename}/consistent-type-specifier-style`]: ["error", "prefer-top-level"],
+        [`${importXPluginRename}/exports-last`]: "error",
+        [`${importXPluginRename}/first`]: "error",
+        [`${importXPluginRename}/group-exports`]: "error",
+        [`${importXPluginRename}/newline-after-import`]: ["error", { count: 1 }],
+        [`${importXPluginRename}/no-anonymous-default-export`]: "error",
+        [`${importXPluginRename}/no-duplicates`]: "error",
+        [`${importXPluginRename}/no-namespace`]: "error",
+        [`${importXPluginRename}/prefer-default-export`]: "error",
+        ...webpack && {
+          [`${importXPluginRename}/dynamic-import-chunkname`]: "error"
+        },
+        // Sorting rules
+        [`${importSortPrefix}/exports`]: "error",
+        [`${importSortPrefix}/imports`]: "error",
+        // Unused imports rules
+        [`${unusedImportsPrefix}/no-unused-imports`]: "error",
+        [`${unusedImportsPrefix}/no-unused-vars`]: [
+          "warn",
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            ignoreRestSiblings: true,
+            vars: "all",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        "sort-imports": [
+          "error",
+          {
+            allowSeparatedGroups: false,
+            ignoreCase: false,
+            ignoreDeclarationSort: true,
+            ignoreMemberSort: true,
+            memberSyntaxSortOrder: ["none", "all", "multiple", "single"]
+          }
+        ]
+      }
+    });
+    if (typescript2) {
+      configs.push({
+        files: DTS_GLOBS,
+        name: IMPORTS_CONFIG_NAME_RULES_STYLISTIC_TYPESCRIPT_DTS,
+        rules: {
+          [`${importXPluginRename}/prefer-default-export`]: "off"
+        }
+      });
+    }
+    if (markdown2) {
+      configs.push({
+        files: GLOB_MARKDOWN_SOURCE,
+        name: IMPORTS_CONFIG_NAME_RULES_STYLISTIC_MARKDOWN_SOURCE,
+        rules: {
+          [`${unusedImportsPrefix}/no-unused-vars`]: ["off"]
+        }
+      });
+    }
+    if (astro2) {
+      configs.push({
+        files: GLOB_ASTRO,
+        name: IMPORTS_CONFIG_NAME_RULES_STYLISTIC_ASTRO,
+        rules: {
+          [`${importXPluginRename}/exports-last`]: ["off"],
+          [`${importXPluginRename}/prefer-default-export`]: ["off"]
+        }
+      });
+    }
+  }
+  return configs;
+}
+
+// src/config/react/react.config.ts
+var import_local_pkg = require("local-pkg");
+
+// src/config/react/react.config-name.ts
+var REACT_CONFIG_NAME = `${plugin_prefix_default}/react`;
+var REACT_CONFIG_NAME_SETUP = `${REACT_CONFIG_NAME}/setup`;
+var REACT_CONFIG_NAME_RULES = `${REACT_CONFIG_NAME}/rules`;
+var REACT_CONFIG_NAME_RULES_HOOKS = `${REACT_CONFIG_NAME_RULES}/hooks`;
+var REACT_CONFIG_NAME_RULES_REFRESH = `${REACT_CONFIG_NAME_RULES}/refresh`;
+
+// src/config/react/react.globs.ts
+var GLOB_REACT_JSX = ["**/*.?([cm])jsx"];
+var GLOB_REACT_TSX = ["**/*.?([cm])tsx"];
+
+// src/config/react/react.config.ts
+var REACT_REFRESH_ALLOW_CONSTANT_EXPORT_PACKAGES = ["vite"];
+async function react(options) {
+  const { react: react2, typescript: typescript2 } = options;
+  if (!react2) {
+    return [];
+  }
+  const [pluginReact, pluginReactHooks, pluginReactRefresh] = await Promise.all([
+    interopDefault(import("eslint-plugin-react")),
+    interopDefault(import("eslint-plugin-react-hooks")),
+    interopDefault(import("eslint-plugin-react-refresh"))
+  ]);
+  const isAllowConstantExport = REACT_REFRESH_ALLOW_CONSTANT_EXPORT_PACKAGES.some((index) => (0, import_local_pkg.isPackageExists)(index));
+  const files = [...GLOB_REACT_JSX, ...typescript2 ? GLOB_REACT_TSX : []];
+  return [
+    {
+      name: REACT_CONFIG_NAME_SETUP,
+      plugins: {
+        react: pluginReact,
+        "react-hooks": pluginReactHooks,
+        "react-refresh": pluginReactRefresh
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
+      }
+    },
+    {
+      files,
+      name: REACT_CONFIG_NAME_RULES,
+      rules: {
+        "react/display-name": "error",
+        "react/jsx-key": "error",
+        "react/jsx-no-comment-textnodes": "error",
+        "react/jsx-no-duplicate-props": "error",
+        "react/jsx-no-target-blank": "error",
+        "react/jsx-uses-react": "error",
+        "react/jsx-uses-vars": "error",
+        "react/no-children-prop": "error",
+        "react/no-danger-with-children": "error",
+        "react/no-deprecated": "error",
+        "react/no-direct-mutation-state": "error",
+        "react/no-find-dom-node": "error",
+        "react/no-is-mounted": "error",
+        "react/no-render-return-value": "error",
+        "react/no-string-refs": "error",
+        "react/no-unescaped-entities": "error",
+        "react/no-unknown-property": "error",
+        "react/no-unsafe": "off",
+        "react/react-in-jsx-scope": "off",
+        "react/require-render-return": "error",
+        ...!typescript2 && {
+          "react/jsx-no-undef": "error",
+          "react/prop-types": "error"
+        }
+      }
+    },
+    {
+      files,
+      name: REACT_CONFIG_NAME_RULES_HOOKS,
+      rules: {
+        "react-hooks/exhaustive-deps": "error",
+        "react-hooks/rules-of-hooks": "error"
+      }
+    },
+    {
+      files,
+      name: REACT_CONFIG_NAME_RULES_REFRESH,
+      rules: {
+        "react-refresh/only-export-components": ["warn", { allowConstantExport: isAllowConstantExport }]
+      }
+    }
+  ];
+}
+
+// src/config/stylistic/stylistic.config-name.ts
+var STYLISTIC_CONFIG_NAME = `${plugin_prefix_default}/stylistic`;
+var STYLISTIC_CONFIG_NAME_SETUP = `${STYLISTIC_CONFIG_NAME}/setup`;
+var STYLISTIC_CONFIG_NAME_RULES = `${STYLISTIC_CONFIG_NAME}/rules`;
+var STYLISTIC_CONFIG_NAME_RULES_UNICORN = `${STYLISTIC_CONFIG_NAME_RULES}/unicorn`;
+var STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN = `${STYLISTIC_CONFIG_NAME_RULES_UNICORN}/markdown`;
+var STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN_SOURCE = `${STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN}/source`;
+var STYLISTIC_CONFIG_NAME_RULES_PERFECTIONIST = `${STYLISTIC_CONFIG_NAME_RULES}/perfectionist`;
+var STYLISTIC_CONFIG_NAME_RULES_MARKDOWN = `${STYLISTIC_CONFIG_NAME_RULES}/markdown`;
+var STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_SOURCE = `${STYLISTIC_CONFIG_NAME_RULES_MARKDOWN}/source`;
+var STYLISTIC_CONFIG_NAME_RULES_ASTRO = `${STYLISTIC_CONFIG_NAME_RULES}/astro`;
+var STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_ASRTO = `${STYLISTIC_CONFIG_NAME_RULES}/astro`;
+var STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_JSON = `${STYLISTIC_CONFIG_NAME_RULES}/json`;
+var STYLISTIC_CONFIG_NAME_RULES_JSON = `${STYLISTIC_CONFIG_NAME_RULES}/json`;
+var STYLISTIC_CONFIG_NAME_RULES_JSON_PACKAGE = `${STYLISTIC_CONFIG_NAME_RULES_JSON}/package.json`;
+var STYLISTIC_CONFIG_NAME_RULES_JSON_TSCONFIG = `${STYLISTIC_CONFIG_NAME_RULES_JSON}/tsconfig.json`;
+var STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT = `${STYLISTIC_CONFIG_NAME_RULES}/typescript`;
+var STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT_DTS = `${STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT}/dts`;
+var STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT_TYPE_AWARE = `${STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT}/type-aware`;
+var STYLISTIC_CONFIG_NAME_RULES_PRETTIER = `${STYLISTIC_CONFIG_NAME_RULES}/prettier`;
+var STYLISTIC_CONFIG_NAME_RULES_PRETTIER_ASTRO = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER}/astro`;
+var STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER}/markdown`;
+var STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN_SOURCE = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN}/source`;
+var STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN_ASTRO = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN}/astro`;
+
+// src/config/stylistic/stylistic.options-prettier.ts
+function prettierOptions(options) {
+  const {
+    arrowParens,
+    bracketSameLine,
+    bracketSpacing,
+    endOfLine,
+    indent,
+    indentSize,
+    printWidth,
+    quoteProps,
+    quotes,
+    semicolons,
+    singleAttributePerLine,
+    trailingComma
+  } = options;
+  return {
+    arrowParens,
+    bracketSameLine,
+    bracketSpacing,
+    endOfLine,
+    jsxSingleQuote: quotes === "single",
+    printWidth,
+    quoteProps,
+    semi: semicolons,
+    singleAttributePerLine,
+    singleQuote: quotes === "single",
+    tabWidth: indentSize,
+    trailingComma,
+    useTabs: indent === "tab"
+  };
+}
+
+// src/config/stylistic/stylistic.options-stylistic.ts
+function stylisticOptions(options) {
+  const {
+    arrowParens,
+    braceStyle,
+    bracketSpacing,
+    indent,
+    indentSize,
+    quoteProps,
+    quotes,
+    semicolons,
+    trailingComma
+  } = options;
+  return {
+    arrowParens: arrowParens === "always",
+    blockSpacing: bracketSpacing,
+    braceStyle,
+    commaDangle: trailingComma === "es5" ? "only-multiline" : trailingComma === "none" ? "never" : "always",
+    indent: indent === "tab" ? "tab" : indentSize,
+    jsx: true,
+    quoteProps: quoteProps === "preserve" ? "as-needed" : quoteProps,
+    quotes,
+    semi: semicolons
+  };
+}
+
+// src/config/stylistic/stylistic.config.ts
+async function stylistic(options) {
+  const { astro: astro2, json: json2, markdown: markdown2, stylistic: stylistic2, typescript: typescript2 } = options;
+  if (stylistic2 === false) {
+    return [];
+  }
+  const { format, indent, indentSize, perfectionist, unicorn } = stylistic2;
+  const isTypeAware = typeof typescript2 !== "boolean";
+  const typescriptPluginRename = plugin_rename_default["@typescript-eslint"];
+  const stylisticPluginRename = plugin_rename_default["@stylistic"];
+  const jsonPluginRename = plugin_rename_default.jsonc;
+  const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
+  const pluginStylisticOptions = stylisticOptions(stylistic2);
+  const pluginStylisticConfig = pluginStylistic.configs.customize(pluginStylisticOptions);
+  const pluginStylisticRules = pluginStylisticConfig.rules;
+  const pluginUnicorn = await interopDefault(import("eslint-plugin-unicorn"));
+  const pluginPerfectionistRoot = await interopDefault(import("eslint-plugin-perfectionist"));
+  const pluginPerfectionist = pluginPerfectionistRoot.configs["recommended-natural"];
+  const config = [
+    {
+      name: STYLISTIC_CONFIG_NAME_SETUP,
+      plugins: {
+        style: pluginStylistic,
+        ...unicorn && {
+          unicorn: pluginUnicorn
+        },
+        ...perfectionist && {
+          ...pluginPerfectionist.plugins
+        },
+        ...format && {
+          format: await interopDefault(import("eslint-plugin-format"))
+        }
+      }
+    },
+    {
+      name: STYLISTIC_CONFIG_NAME_RULES,
+      rules: {
+        ...renameRules(pluginStylisticRules, plugin_rename_default),
+        [`${stylisticPluginRename}/arrow-parens`]: ["error", "as-needed"],
+        [`${stylisticPluginRename}/brace-style`]: "off",
+        [`${stylisticPluginRename}/implicit-arrow-linebreak`]: "off",
+        [`${stylisticPluginRename}/indent-binary-ops`]: "off",
+        [`${stylisticPluginRename}/indent`]: "off",
+        [`${stylisticPluginRename}/jsx-closing-bracket-location`]: [
+          "error",
+          {
+            nonEmpty: "after-props",
+            selfClosing: "tag-aligned"
+          }
+        ],
+        [`${stylisticPluginRename}/jsx-curly-newline`]: "off",
+        [`${stylisticPluginRename}/jsx-indent`]: "off",
+        [`${stylisticPluginRename}/jsx-one-expression-per-line`]: "off",
+        [`${stylisticPluginRename}/jsx-quotes`]: ["error", "prefer-single"],
+        [`${stylisticPluginRename}/line-comment-position`]: ["error", { position: "above" }],
+        [`${stylisticPluginRename}/max-len`]: "off",
+        [`${stylisticPluginRename}/multiline-comment-style`]: ["error", "starred-block"],
+        [`${stylisticPluginRename}/multiline-ternary`]: "off",
+        [`${stylisticPluginRename}/no-extra-semi`]: "error",
+        [`${stylisticPluginRename}/padding-line-between-statements`]: [
+          "error",
+          { blankLine: "always", next: "return", prev: "*" }
+        ],
+        curly: ["error", "all"],
+        ...format && {
+          [`${stylisticPluginRename}/operator-linebreak`]: "off"
+        }
+      }
+    }
+  ];
+  if (markdown2) {
+    config.push({
+      files: [
+        ...GLOB_MARKDOWN_SOURCE,
+        ...json2 ? GLOB_MARKDOWN_JSON : [],
+        ...astro2 ? GLOB_MARKDOWN_ASTRO : []
+      ],
+      name: STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_SOURCE,
+      rules: {
+        [`${stylisticPluginRename}/indent`]: ["error", 2],
+        [`${stylisticPluginRename}/line-comment-position`]: "off",
+        [`${stylisticPluginRename}/multiline-comment-style`]: "off"
+      }
+    });
+  }
+  if (typescript2) {
+    const plugin = await interopDefault(import("@typescript-eslint/eslint-plugin"));
+    config.push({
+      files: SOURCE_GLOBS,
+      name: STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT,
+      rules: {
+        ...pluginConfigRules(plugin, "stylistic", plugin_rename_typescript_default),
+        [`${typescriptPluginRename}/consistent-type-assertions`]: "off",
+        [`${typescriptPluginRename}/member-ordering`]: [
+          "error",
+          {
+            default: {
+              memberTypes: [
+                // Index signature
+                "signature",
+                "call-signature",
+                // Fields
+                "public-static-field",
+                "protected-static-field",
+                "private-static-field",
+                "#private-static-field",
+                "public-decorated-field",
+                "protected-decorated-field",
+                "private-decorated-field",
+                "public-instance-field",
+                "protected-instance-field",
+                "private-instance-field",
+                "#private-instance-field",
+                "public-abstract-field",
+                "protected-abstract-field",
+                "public-field",
+                "protected-field",
+                "private-field",
+                "#private-field",
+                "static-field",
+                "instance-field",
+                "abstract-field",
+                "decorated-field",
+                "field",
+                // Static initialization
+                "static-initialization",
+                // Constructors
+                "public-constructor",
+                "protected-constructor",
+                "private-constructor",
+                "constructor",
+                // Getters
+                "public-static-get",
+                "protected-static-get",
+                "private-static-get",
+                "#private-static-get",
+                "public-decorated-get",
+                "protected-decorated-get",
+                "private-decorated-get",
+                "public-instance-get",
+                "protected-instance-get",
+                "private-instance-get",
+                "#private-instance-get",
+                "public-abstract-get",
+                "protected-abstract-get",
+                "public-get",
+                "protected-get",
+                "private-get",
+                "#private-get",
+                "static-get",
+                "instance-get",
+                "abstract-get",
+                "decorated-get",
+                "get",
+                // Setters
+                "public-static-set",
+                "protected-static-set",
+                "private-static-set",
+                "#private-static-set",
+                "public-decorated-set",
+                "protected-decorated-set",
+                "private-decorated-set",
+                "public-instance-set",
+                "protected-instance-set",
+                "private-instance-set",
+                "#private-instance-set",
+                "public-abstract-set",
+                "protected-abstract-set",
+                "public-set",
+                "protected-set",
+                "private-set",
+                "#private-set",
+                "static-set",
+                "instance-set",
+                "abstract-set",
+                "decorated-set",
+                "set",
+                // Methods
+                "public-static-method",
+                "protected-static-method",
+                "private-static-method",
+                "#private-static-method",
+                "public-decorated-method",
+                "protected-decorated-method",
+                "private-decorated-method",
+                "public-instance-method",
+                "protected-instance-method",
+                "private-instance-method",
+                "#private-instance-method",
+                "public-abstract-method",
+                "protected-abstract-method",
+                "public-method",
+                "protected-method",
+                "private-method",
+                "#private-method",
+                "static-method",
+                "instance-method",
+                "abstract-method",
+                "decorated-method",
+                "method"
+              ],
+              order: "natural"
+            }
+          }
+        ]
+      }
+    });
+    if (isTypeAware) {
+      config.push({
+        files: TYPESCRIPT_GLOBS,
+        ignores: GLOB_MARKDOWN_SOURCE,
+        name: STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT_TYPE_AWARE,
+        rules: {
+          ...pluginConfigRules(plugin, "stylistic-type-checked-only", plugin_rename_typescript_default),
+          // Move this rule here cause needs tsconfig.json
+          [`${typescriptPluginRename}/consistent-type-assertions`]: "error"
+        }
+      });
+    }
+    config.push({
+      files: DTS_GLOBS,
+      name: STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT_DTS,
+      rules: {
+        [`${stylisticPluginRename}/multiline-comment-style`]: "off",
+        [`${stylisticPluginRename}/spaced-comment`]: "off"
+      }
+    });
+  }
+  if (json2) {
+    config.push(
+      {
+        files: GLOB_JSON,
+        name: STYLISTIC_CONFIG_NAME_RULES_JSON,
+        rules: {
+          [`${jsonPluginRename}/array-bracket-spacing`]: ["error", "never"],
+          [`${jsonPluginRename}/comma-dangle`]: ["error", "never"],
+          [`${jsonPluginRename}/comma-style`]: ["error", "last"],
+          [`${jsonPluginRename}/indent`]: ["error", indent === "space" ? indentSize : indent],
+          [`${jsonPluginRename}/key-spacing`]: ["error", { afterColon: true, beforeColon: false }],
+          [`${jsonPluginRename}/object-curly-newline`]: ["error", { consistent: true, multiline: true }],
+          [`${jsonPluginRename}/object-curly-spacing`]: ["error", "always"],
+          [`${jsonPluginRename}/object-property-newline`]: [
+            "error",
+            { allowMultiplePropertiesPerLine: true }
+          ],
+          [`${jsonPluginRename}/quote-props`]: "error",
+          [`${jsonPluginRename}/quotes`]: "error"
+        }
+      },
+      {
+        files: GLOB_JSON_PACKAGE,
+        name: STYLISTIC_CONFIG_NAME_RULES_JSON_PACKAGE,
+        rules: {
+          "jsonc/sort-array-values": [
+            "error",
+            {
+              order: { type: "asc" },
+              pathPattern: "^files$"
+            }
+          ],
+          "jsonc/sort-keys": [
+            "error",
+            {
+              order: [
+                "name",
+                "displayName",
+                "version",
+                "author",
+                "publisher",
+                "description",
+                "keywords",
+                "categories",
+                "repository",
+                "homepage",
+                "bugs",
+                "funding",
+                "license",
+                "private",
+                "publishConfig",
+                "type",
+                "sideEffects",
+                "bin",
+                "icon",
+                "files",
+                "main",
+                "module",
+                "unpkg",
+                "jsdelivr",
+                "types",
+                "exports",
+                "typesVersions",
+                "scripts",
+                "peerDependencies",
+                "peerDependenciesMeta",
+                "dependencies",
+                "optionalDependencies",
+                "devDependencies",
+                "overrides",
+                "resolutions",
+                "engines",
+                "packageManager",
+                "pnpm",
+                "activationEvents",
+                "contributes",
+                "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: { type: "asc" },
+              pathPattern: "^(?:scripts)$"
+            },
+            {
+              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)$"
+            }
+          ]
+        }
+      },
+      {
+        files: GLOB_JSON_TSCONFIG,
+        name: STYLISTIC_CONFIG_NAME_RULES_JSON_TSCONFIG,
+        rules: {
+          "jsonc/sort-keys": [
+            "error",
+            {
+              order: ["extends", "compilerOptions", "references", "files", "include", "exclude"],
+              pathPattern: "^$"
+            },
+            {
+              order: [
+                /* Projects */
+                "incremental",
+                "composite",
+                "tsBuildInfoFile",
+                "disableSourceOfProjectReferenceRedirect",
+                "disableSolutionSearching",
+                "disableReferencedProjectLoad",
+                /* Language and Environment */
+                "target",
+                "jsx",
+                "jsxFactory",
+                "jsxFragmentFactory",
+                "jsxImportSource",
+                "lib",
+                "moduleDetection",
+                "noLib",
+                "reactNamespace",
+                "useDefineForClassFields",
+                "emitDecoratorMetadata",
+                "experimentalDecorators",
+                /* Modules */
+                "baseUrl",
+                "rootDir",
+                "rootDirs",
+                "customConditions",
+                "module",
+                "moduleResolution",
+                "moduleSuffixes",
+                "noResolve",
+                "paths",
+                "resolveJsonModule",
+                "resolvePackageJsonExports",
+                "resolvePackageJsonImports",
+                "typeRoots",
+                "types",
+                "allowArbitraryExtensions",
+                "allowImportingTsExtensions",
+                "allowUmdGlobalAccess",
+                /* JavaScript Support */
+                "allowJs",
+                "checkJs",
+                "maxNodeModuleJsDepth",
+                /* Type Checking */
+                "strict",
+                "strictBindCallApply",
+                "strictFunctionTypes",
+                "strictNullChecks",
+                "strictPropertyInitialization",
+                "allowUnreachableCode",
+                "allowUnusedLabels",
+                "alwaysStrict",
+                "exactOptionalPropertyTypes",
+                "noFallthroughCasesInSwitch",
+                "noImplicitAny",
+                "noImplicitOverride",
+                "noImplicitReturns",
+                "noImplicitThis",
+                "noPropertyAccessFromIndexSignature",
+                "noUncheckedIndexedAccess",
+                "noUnusedLocals",
+                "noUnusedParameters",
+                "useUnknownInCatchVariables",
+                /* Emit */
+                "declaration",
+                "declarationDir",
+                "declarationMap",
+                "downlevelIteration",
+                "emitBOM",
+                "emitDeclarationOnly",
+                "importHelpers",
+                "importsNotUsedAsValues",
+                "inlineSourceMap",
+                "inlineSources",
+                "mapRoot",
+                "newLine",
+                "noEmit",
+                "noEmitHelpers",
+                "noEmitOnError",
+                "outDir",
+                "outFile",
+                "preserveConstEnums",
+                "preserveValueImports",
+                "removeComments",
+                "sourceMap",
+                "sourceRoot",
+                "stripInternal",
+                /* Interop Constraints */
+                "allowSyntheticDefaultImports",
+                "esModuleInterop",
+                "forceConsistentCasingInFileNames",
+                "isolatedModules",
+                "preserveSymlinks",
+                "verbatimModuleSyntax",
+                /* Completeness */
+                "skipDefaultLibCheck",
+                "skipLibCheck"
+              ],
+              pathPattern: "^compilerOptions$"
+            }
+          ]
+        }
+      }
+    );
+  }
+  if (astro2) {
+    config.push({
+      files: GLOB_ASTRO,
+      name: STYLISTIC_CONFIG_NAME_RULES_ASTRO,
+      rules: {
+        "astro/prefer-class-list-directive": "error",
+        "astro/prefer-object-class-list": "error",
+        "astro/prefer-split-class-list": "error",
+        "astro/semi": "error"
+      }
+    });
+  }
+  if (unicorn) {
+    const unicornFlatRecommended = pluginUnicorn.configs ? pluginUnicorn.configs["flat/recommended"] : void 0;
+    const unicornRules = unicornFlatRecommended?.rules;
+    config.push({
+      name: STYLISTIC_CONFIG_NAME_RULES_UNICORN,
+      rules: {
+        ...unicornRules,
+        "unicorn/consistent-function-scoping": "off",
+        "unicorn/no-array-reduce": "off",
+        "unicorn/no-nested-ternary": "off",
+        "unicorn/no-static-only-class": "off",
+        "unicorn/prefer-dom-node-dataset": "off",
+        "unicorn/prevent-abbreviations": [
+          "error",
+          {
+            allowList: {
+              Env: true,
+              env: true,
+              ProcessEnv: true,
+              Props: true
+            }
+          }
+        ]
+      }
+    });
+    if (markdown2) {
+      config.push(
+        {
+          files: GLOB_MARKDOWN,
+          name: STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN,
+          rules: {
+            "unicorn/filename-case": "off"
+          }
+        },
+        {
+          files: [
+            ...GLOB_MARKDOWN_SOURCE,
+            ...json2 ? GLOB_MARKDOWN_JSON : [],
+            ...astro2 ? GLOB_MARKDOWN_ASTRO : []
+          ],
+          name: STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN_SOURCE,
+          rules: {
+            "unicorn/filename-case": "off"
+          }
+        }
+      );
+    }
+  }
+  if (perfectionist) {
+    config.push({
+      name: STYLISTIC_CONFIG_NAME_RULES_PERFECTIONIST,
+      rules: {
+        ...pluginPerfectionist.rules,
+        "perfectionist/sort-classes": "off",
+        "perfectionist/sort-exports": "off",
+        "perfectionist/sort-imports": "off",
+        "perfectionist/sort-interfaces": "off",
+        "perfectionist/sort-jsx-props": "error",
+        "perfectionist/sort-modules": "off",
+        "perfectionist/sort-named-exports": "off",
+        "perfectionist/sort-named-imports": "off",
+        "perfectionist/sort-object": [
+          "off",
+          {
+            specialCharacters: "trim"
+          }
+        ],
+        "perfectionist/sort-object-types": "off"
+      }
+    });
+  }
+  if (format) {
+    const prettierConfig = prettierOptions(stylistic2);
+    config.push({
+      files: typescript2 ? SOURCE_GLOBS : JAVASCRIPT_GLOBS,
+      ignores: [
+        ...GLOB_MARKDOWN_SOURCE,
+        ...json2 ? GLOB_MARKDOWN_JSON : [],
+        ...astro2 ? GLOB_MARKDOWN_ASTRO : []
+      ],
+      name: STYLISTIC_CONFIG_NAME_RULES_PRETTIER,
+      rules: {
+        "format/prettier": ["error", { ...prettierConfig, parser: "typescript" }]
+      }
+    });
+    if (astro2) {
+      config.push({
+        files: GLOB_ASTRO,
+        name: STYLISTIC_CONFIG_NAME_RULES_PRETTIER_ASTRO,
+        rules: {
+          "format/prettier": [
+            "error",
+            {
+              ...prettierConfig,
+              parser: "astro",
+              plugins: ["prettier-plugin-astro"]
+            }
+          ]
+        }
+      });
+    }
+    if (markdown2) {
+      config.push({
+        files: GLOB_MARKDOWN_SOURCE,
+        name: STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN_SOURCE,
+        rules: {
+          "format/prettier": [
+            "error",
+            { ...prettierConfig, parser: "typescript", tabWidth: 2, useTabs: false }
+          ]
+        }
+      });
+      if (astro2) {
+        config.push({
+          files: GLOB_MARKDOWN_ASTRO,
+          name: STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN_ASTRO,
+          rules: {
+            "format/prettier": [
+              "error",
+              {
+                ...prettierConfig,
+                parser: "astro",
+                plugins: ["prettier-plugin-astro"],
+                tabWidth: 2,
+                useTabs: false
+              }
+            ]
+          }
+        });
+      }
+    }
+  }
+  if (json2) {
+    config.push({
+      files: GLOB_MARKDOWN_JSON,
+      name: STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_JSON,
+      rules: {
+        "json/indent": ["error", 2]
+      }
+    });
+  }
+  if (astro2) {
+    config.push({
+      files: GLOB_MARKDOWN_ASTRO,
+      name: STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_ASRTO,
+      rules: {
+        [`${stylisticPluginRename}/indent`]: ["error", 2]
+      }
+    });
+  }
+  return config;
+}
+
+// src/options/hexadrop-eslint.options.ts
+var import_node_fs2 = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_process2 = __toESM(require("process"), 1);
+var import_local_pkg2 = require("local-pkg");
+function getCwdTsconfigPath() {
+  const root = import_node_process2.default.cwd();
+  const cwdTsconfigPath = import_node_path.default.resolve(root, "tsconfig.json");
+  if ((0, import_node_fs2.existsSync)(cwdTsconfigPath)) {
+    return "tsconfig.json";
+  }
+  return void 0;
+}
+function defaultOptions(options = {}) {
+  let typescript2 = false;
+  const installedTypescript = (0, import_local_pkg2.isPackageExists)("typescript");
+  const installedReact = (0, import_local_pkg2.isPackageExists)("react");
+  const installedAstro = (0, import_local_pkg2.isPackageExists)("astro");
+  if (options.typescript === true) {
+    typescript2 = true;
+  } else if (installedTypescript) {
+    if (options.typescript === void 0) {
+      typescript2 = getCwdTsconfigPath() ?? true;
+    } else if (options.typescript === "string") {
+      typescript2 = options.typescript.length > 0 ? options.typescript : true;
+    } else if (Array.isArray(options.typescript)) {
+      typescript2 = options.typescript.length > 0 ? options.typescript.filter(Boolean) : true;
+    }
+  }
+  return {
+    astro: options.astro ?? installedAstro,
+    ignore: typeof options.ignore === "object" ? {
+      ...options.ignore,
+      files: typeof options.ignore.files === "string" ? options.ignore.files : options.ignore.files?.filter(Boolean) ?? [],
+      filesGitModules: typeof options.ignore.filesGitModules === "string" ? options.ignore.filesGitModules : options.ignore.filesGitModules?.filter(Boolean) ?? [],
+      globs: options.ignore.globs?.filter(Boolean) ?? []
+    } : options.ignore ?? true,
+    imports: options.imports ?? true,
+    json: options.json ?? true,
+    markdown: options.markdown ?? true,
+    module: {
+      amd: false,
+      commonjs: false,
+      node: true,
+      webpack: false,
+      ...options.module,
+      ignore: [
+        String.raw`bun\:.*`,
+        String.raw`astro\:.*`,
+        ...options.module?.ignore?.filter(Boolean) ?? []
+      ]
+    },
+    node: options.node ?? true,
+    react: options.react ?? installedReact,
+    stylistic: options.stylistic === false ? false : {
+      arrowParens: "avoid",
+      braceStyle: "1tbs",
+      bracketSameLine: true,
+      bracketSpacing: true,
+      endOfLine: "lf",
+      format: true,
+      imports: true,
+      indent: "tab",
+      indentSize: 4,
+      perfectionist: true,
+      printWidth: 120,
+      quoteProps: "as-needed",
+      quotes: "single",
+      semicolons: true,
+      singleAttributePerLine: true,
+      trailingComma: "es5",
+      unicorn: true,
+      ...options.stylistic
+    },
+    typescript: typescript2
+  };
+}
+
+// src/factory.ts
+function hexadrop(optionsOrFlatConfigItem, ...configs) {
+  const options = defaultOptions(optionsOrFlatConfigItem);
+  let pipeline = new import_eslint_flat_config_utils.FlatConfigComposer(
+    ignore(options),
+    core(options),
+    astro(options),
+    typescript(options),
+    react(options),
+    json(options),
+    markdown(options),
+    imports(options),
+    stylistic(options)
+  ).renamePlugins(plugin_rename_default);
+  const flatConfig = extractTypedFlatConfigItem(optionsOrFlatConfigItem);
+  if (flatConfig) {
+    pipeline = pipeline.append(flatConfig);
+  }
+  pipeline = pipeline.append(...configs);
+  return pipeline;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  combine
+});