@hexadrop/eslint-config 0.1.18 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1689 @@
+import { FlatConfigComposer } from "eslint-flat-config-utils";
+import globals from "globals";
+import "eslint";
+import { mergeProcessors, processorPassThrough } from "eslint-merge-processors";
+import { meta, parseForESLint } from "eslint-parser-plain";
+import fs, { existsSync } from "node:fs";
+import process, { cwd } from "node:process";
+import { isPackageExists } from "local-pkg";
+import path from "node:path";
+//#region src/utils/combine.ts
+/**
+* Combine array and non-array configs into a single array.
+*/
+async function combine(...configs) {
+	return (await Promise.all(configs.map((config) => Promise.resolve(config)))).flat();
+}
+//#endregion
+//#region src/utils/extract-typed-flat-config-item.ts
+const flatConfigProperties = [
+	"name",
+	"files",
+	"ignores",
+	"languageOptions",
+	"linterOptions",
+	"processor",
+	"plugins",
+	"rules",
+	"settings"
+];
+function extractTypedFlatConfigItem(config) {
+	if (!config) return;
+	const result = {};
+	for (const key of flatConfigProperties) if (Object.hasOwn(config, key)) result[key] = config[key];
+	if (Object.keys(result).length === 0) return;
+	return result;
+}
+//#endregion
+//#region src/utils/interop-default.ts
+async function interopDefault(m) {
+	const resolved = await m;
+	return resolved.default ?? resolved;
+}
+//#endregion
+//#region src/utils/rename-rules.ts
+/**
+* Rename plugin prefixes in a rule object.
+* Accepts a map of prefixes to rename.
+*
+* @example
+* ```ts
+* import { renameRules } from '@hexadrop/eslint-config'
+*
+* export default [{
+*   rules: renameRules(
+*     {
+*       '@typescript-eslint/indent': 'error'
+*     },
+*     { '@typescript-eslint': '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];
+	}));
+}
+//#endregion
+//#region 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 && Object.hasOwn(plugin.configs, configName)) {
+		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);
+}
+//#endregion
+//#region src/utils/plugin-config-rules.ts
+function pluginConfigRules(plugin, configName, map = {}) {
+	let rules = {};
+	if (plugin.configs && Object.hasOwn(plugin.configs, configName)) {
+		const config = plugin.configs[configName];
+		if (config && "rules" in config && config.rules) rules = config.rules;
+	}
+	return renameRules(rules, map);
+}
+//#endregion
+//#region src/utils/to-array.ts
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+//#endregion
+//#region src/const/plugin-prefix.ts
+const PLUGIN_PREFIX = "hexadrop";
+//#endregion
+//#region src/const/plugin-rename-typescript.ts
+const PLUGIN_RENAME_TYPESCRIPT = { "@typescript-eslint": "typescript" };
+//#endregion
+//#region src/const/plugin-rename.ts
+const PLUGIN_RENAME = {
+	...PLUGIN_RENAME_TYPESCRIPT,
+	"@stylistic": "style",
+	"import-x": "import",
+	jsonc: "json",
+	n: "node",
+	"simple-import-sort": "import-sort",
+	"unused-imports": "import-unused",
+	vitest: "test",
+	yml: "yaml"
+};
+//#endregion
+//#region src/config/astro/astro.config-name.ts
+const ASTRO_CONFIG_NAME = `${PLUGIN_PREFIX}/astro`;
+const ASTRO_CONFIG_NAME_SETUP = `${ASTRO_CONFIG_NAME}/setup`;
+const ASTRO_CONFIG_NAME_SETUP_PARSER = `${ASTRO_CONFIG_NAME_SETUP}/parser`;
+const ASTRO_CONFIG_NAME_SETUP_PARSER_JAVASCRIPT = `${ASTRO_CONFIG_NAME_SETUP_PARSER}/javascript`;
+`${ASTRO_CONFIG_NAME_SETUP_PARSER}`;
+const ASTRO_CONFIG_NAME_RULES = `${ASTRO_CONFIG_NAME}/rules`;
+//#endregion
+//#region src/config/astro/astro.globs.ts
+const GLOB_ASTRO = ["*.astro", "**/*.astro"];
+const GLOB_ASTRO_JAVASCRIPT = ["**/*.astro/*.js", "*.astro/*.js"];
+const GLOB_ASTRO_TYPESCRIPT = ["**/*.astro/*.ts", "*.astro/*.ts"];
+//#endregion
+//#region src/config/astro/astro.config.ts
+async function astro(options) {
+	const { astro, typescript } = options;
+	if (!astro) 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: {
+					...globals.node,
+					Astro: false,
+					Fragment: false
+				},
+				parser,
+				parserOptions: {
+					extraFileExtensions: [".astro"],
+					parser: typescript ? parserTypescript : void 0
+				},
+				sourceType: "module"
+			},
+			name: ASTRO_CONFIG_NAME_SETUP_PARSER,
+			processor: typescript ? "astro/client-side-ts" : "astro/astro"
+		},
+		{
+			files: GLOB_ASTRO_JAVASCRIPT,
+			languageOptions: {
+				globals: { ...globals.browser },
+				sourceType: "module"
+			},
+			name: ASTRO_CONFIG_NAME_SETUP_PARSER_JAVASCRIPT
+		}
+	];
+	if (typescript) configs.push({
+		files: GLOB_ASTRO_TYPESCRIPT,
+		languageOptions: {
+			globals: { ...globals.browser },
+			parser: parserTypescript,
+			parserOptions: { project: typescript === true ? void 0 : toArray(typescript) },
+			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;
+}
+//#endregion
+//#region src/config/markdown/markdown.config-name.ts
+const MARKDOWN_CONFIG_NAME_SETUP = `${`${PLUGIN_PREFIX}/markdown`}/setup`;
+const MARKDOWN_CONFIG_NAME_SETUP_PROCESSOR = `${MARKDOWN_CONFIG_NAME_SETUP}/processor`;
+const MARKDOWN_CONFIG_NAME_SETUP_PARSER = `${MARKDOWN_CONFIG_NAME_SETUP}/parser`;
+//#endregion
+//#region src/config/core/core.globs.ts
+const SOURCE_GLOBS = ["**/*.?([cm])[jt]s?(x)"];
+const JAVASCRIPT_GLOBS = ["**/*.?([cm])js?(x)"];
+const ESLINT_CONFIG_GLOBS = ["**/eslint.config.js"];
+//#endregion
+//#region src/config/json/json.config-name.ts
+const JSON_CONFIG_NAME = `${PLUGIN_PREFIX}/json`;
+const JSON_CONFIG_NAME_SETUP = `${JSON_CONFIG_NAME}/setup`;
+const JSON_CONFIG_NAME_SETUP_PARSER = `${JSON_CONFIG_NAME_SETUP}/parser`;
+const JSON_CONFIG_NAME_RULES = `${JSON_CONFIG_NAME}/rules`;
+//#endregion
+//#region src/config/json/json.globs.ts
+const GLOB_JSON = [
+	"**/*.json",
+	"**/*.json5",
+	"**/*.jsonc"
+];
+const GLOB_JSON_PACKAGE = ["**/package.json"];
+const GLOB_JSON_TSCONFIG = ["**/tsconfig.json", "**/tsconfig.*.json"];
+//#endregion
+//#region src/config/json/json.config.ts
+async function json(options) {
+	const { json } = options;
+	if (!json) return [];
+	const [pluginJsonc, parserJsonc] = await Promise.all([interopDefault(import("eslint-plugin-jsonc")), interopDefault(import("jsonc-eslint-parser"))]);
+	const jsonPluginRename = PLUGIN_RENAME.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"
+			}
+		}
+	];
+}
+//#endregion
+//#region src/config/markdown/markdown.globs.ts
+const GLOB_MARKDOWN = ["**/*.md"];
+const GLOB_MARKDOWN_IN_MARKDOWN = ["**/*.md/*.md"];
+const GLOB_MARKDOWN_SOURCE = SOURCE_GLOBS.flatMap((source) => GLOB_MARKDOWN.map((markdown) => `${markdown}/${source}`));
+const GLOB_MARKDOWN_JSON = GLOB_JSON.flatMap((json) => GLOB_MARKDOWN.map((markdown) => `${markdown}/${json}`));
+const GLOB_MARKDOWN_ASTRO = GLOB_ASTRO.flatMap((json) => GLOB_MARKDOWN.map((markdown) => `${markdown}/${json}`));
+//#endregion
+//#region src/config/markdown/markdown.config.ts
+async function markdown(options) {
+	const { markdown } = options;
+	if (!markdown) return [];
+	const pluginMarkdown = await interopDefault(import("@eslint/markdown"));
+	const processor = pluginMarkdown.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,
+			processor: mergeProcessors([processor, processorPassThrough])
+		},
+		{
+			files: GLOB_MARKDOWN,
+			languageOptions: { parser: {
+				meta,
+				parseForESLint
+			} },
+			name: MARKDOWN_CONFIG_NAME_SETUP_PARSER
+		}
+	];
+}
+//#endregion
+//#region src/config/core/core.config-name.ts
+const CORE_CONFIG_NAME = `${PLUGIN_PREFIX}/core`;
+const CORE_CONFIG_NAME_SETUP = `${CORE_CONFIG_NAME}/setup`;
+const CORE_CONFIG_NAME_RULES = `${CORE_CONFIG_NAME}/rules`;
+const CORE_CONFIG_NAME_RULES_MARKDOWN_SOURCE = `${CORE_CONFIG_NAME_RULES}/markdown/source`;
+const CORE_CONFIG_NAME_RULES_NODE = `${CORE_CONFIG_NAME_RULES}/node`;
+//#endregion
+//#region src/config/core/core.config.ts
+async function core(options) {
+	const { markdown, module: { node: useNodeModules }, node } = options;
+	const nodePluginName = PLUGIN_RENAME.n;
+	const configs = [{
+		languageOptions: {
+			ecmaVersion: "latest",
+			globals: {
+				...globals.browser,
+				...globals.es2021,
+				...globals.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 (markdown) configs.push({
+		files: GLOB_MARKDOWN_SOURCE,
+		name: CORE_CONFIG_NAME_RULES_MARKDOWN_SOURCE,
+		rules: {
+			"no-console": "off",
+			"no-inline-comments": "off"
+		}
+	});
+	return configs;
+}
+//#endregion
+//#region src/config/ignore/ignore.config-name.ts
+const IGNORE_CONFIG_NAME = `${PLUGIN_PREFIX}/ignore`;
+const IGNORE_CONFIG_NAME_DEFAULT = IGNORE_CONFIG_NAME;
+const IGNORE_CONFIG_NAME_ADDITIONAL = `${IGNORE_CONFIG_NAME}/additional`;
+const IGNORE_CONFIG_NAME_GITIGNORE = `${IGNORE_CONFIG_NAME}/gitignore`;
+//#endregion
+//#region src/config/ignore/ignore.globs.ts
+const 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__"
+];
+//#endregion
+//#region src/config/ignore/ignore.config.ts
+async function ignore({ ignore }) {
+	if (ignore === false) return [];
+	const config = [{
+		ignores: IGNORE_GLOB,
+		name: IGNORE_CONFIG_NAME_DEFAULT
+	}];
+	if (typeof ignore === "object" && ignore.globs) config.push({
+		ignores: ignore.globs,
+		name: IGNORE_CONFIG_NAME_ADDITIONAL
+	});
+	if (typeof ignore === "boolean") {
+		if (fs.existsSync(".gitignore")) {
+			const gitignore = await interopDefault(import("eslint-config-flat-gitignore"));
+			return [...config, {
+				...gitignore(),
+				name: IGNORE_CONFIG_NAME_GITIGNORE
+			}];
+		}
+		return [];
+	}
+	const gitignore = await interopDefault(import("eslint-config-flat-gitignore"));
+	return [...config, {
+		...gitignore(ignore),
+		name: IGNORE_CONFIG_NAME_GITIGNORE
+	}];
+}
+//#endregion
+//#region src/config/typescript/typescript.config-name.ts
+const TYPESCRIPT_CONFIG_NAME = `${PLUGIN_PREFIX}/typescript`;
+const TYPESCRIPT_CONFIG_NAME_SETUP = `${TYPESCRIPT_CONFIG_NAME}/setup`;
+const TYPESCRIPT_CONFIG_NAME_SETUP_PARSER = `${TYPESCRIPT_CONFIG_NAME_SETUP}/parser`;
+const TYPESCRIPT_CONFIG_NAME_SETUP_PARSER_TYPEAWARE = `${TYPESCRIPT_CONFIG_NAME_SETUP_PARSER}/type-aware`;
+const TYPESCRIPT_CONFIG_NAME_RULES = `${TYPESCRIPT_CONFIG_NAME}/rules`;
+const TYPESCRIPT_CONFIG_NAME_RULES_DTS = `${TYPESCRIPT_CONFIG_NAME_RULES}/dts`;
+const TYPESCRIPT_CONFIG_NAME_RULES_TEST = `${TYPESCRIPT_CONFIG_NAME_RULES}/test`;
+const TYPESCRIPT_CONFIG_NAME_RULES_TYPEAWARE = `${TYPESCRIPT_CONFIG_NAME_RULES}/type-aware`;
+//#endregion
+//#region src/config/typescript/typescript.globs.ts
+const TYPESCRIPT_GLOBS = ["**/*.?([cm])ts?(x)"];
+const DTS_GLOBS = ["**/*.d.ts"];
+const TEST_GLOBS = ["**/*.spec.[jt]s?(x)", "**/*.test.[jt]s?(x)"];
+//#endregion
+//#region src/config/typescript/typescript.parser.ts
+function typescriptParser({ files, ignores, parser, parserOptions, tsconfigPath }) {
+	const config = {
+		files,
+		languageOptions: {
+			parser,
+			parserOptions: {
+				sourceType: "module",
+				...tsconfigPath && {
+					project: tsconfigPath,
+					tsconfigRootDir: cwd()
+				},
+				...parserOptions
+			}
+		},
+		name: tsconfigPath ? TYPESCRIPT_CONFIG_NAME_SETUP_PARSER_TYPEAWARE : TYPESCRIPT_CONFIG_NAME_SETUP_PARSER
+	};
+	if (ignores) config.ignores = ignores;
+	return config;
+}
+//#endregion
+//#region src/config/typescript/typescript.config.ts
+async function typescript(options) {
+	const { typescript } = options;
+	if (typescript === false) return [];
+	const [plugin, parser] = await Promise.all([interopDefault(import("@typescript-eslint/eslint-plugin")), interopDefault(import("@typescript-eslint/parser"))]);
+	const typescriptPluginRename = PLUGIN_RENAME["@typescript-eslint"];
+	const config = [];
+	const isTypeAware = typeof typescript !== "boolean";
+	config.push({
+		name: TYPESCRIPT_CONFIG_NAME_SETUP,
+		plugins: { typescript: plugin }
+	});
+	if (typescript === 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(typescript)
+	}));
+	config.push({
+		files: SOURCE_GLOBS,
+		name: TYPESCRIPT_CONFIG_NAME_RULES,
+		rules: {
+			...pluginConfigOverrideRules(plugin, "eslint-recommended", PLUGIN_RENAME_TYPESCRIPT),
+			...pluginConfigRules(plugin, "strict", PLUGIN_RENAME_TYPESCRIPT),
+			[`${typescriptPluginRename}/explicit-module-boundary-types`]: ["error"],
+			[`${typescriptPluginRename}/no-extraneous-class`]: "off",
+			[`${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),
+			[`${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;
+}
+//#endregion
+//#region src/config/imports/imports.config-name.ts
+const IMPORTS_CONFIG_NAME = `${PLUGIN_PREFIX}/imports`;
+const IMPORTS_CONFIG_NAME_SETUP = `${IMPORTS_CONFIG_NAME}/setup`;
+const IMPORTS_CONFIG_NAME_SETUP_TYPESCRIPT = `${IMPORTS_CONFIG_NAME_SETUP}/typescript`;
+const IMPORTS_CONFIG_NAME_RULES = `${IMPORTS_CONFIG_NAME}/rules`;
+const IMPORTS_CONFIG_NAME_RULES_WARNINGS = `${IMPORTS_CONFIG_NAME_RULES}/warnings`;
+const IMPORTS_CONFIG_NAME_RULES_WARNINGS_ESLINT_CONFIG = `${IMPORTS_CONFIG_NAME_RULES_WARNINGS}/eslint-config`;
+const IMPORTS_CONFIG_NAME_RULES_ASTRO = `${IMPORTS_CONFIG_NAME_RULES}/astro`;
+const IMPORTS_CONFIG_NAME_RULES_TYPESCRIPT = `${IMPORTS_CONFIG_NAME_RULES}/typescript`;
+const IMPORTS_CONFIG_NAME_RULES_STATIC = `${IMPORTS_CONFIG_NAME_RULES}/static`;
+const IMPORTS_CONFIG_NAME_RULES_STATIC_MARKDOWN_SOURCE = `${IMPORTS_CONFIG_NAME_RULES_STATIC}/markdown/source`;
+const IMPORTS_CONFIG_NAME_RULES_STYLISTIC = `${IMPORTS_CONFIG_NAME_RULES}/stylistic`;
+const IMPORTS_CONFIG_NAME_RULES_STYLISTIC_ASTRO = `${IMPORTS_CONFIG_NAME_RULES_STYLISTIC}/astro`;
+const IMPORTS_CONFIG_NAME_RULES_STYLISTIC_TYPESCRIPT_DTS = `${IMPORTS_CONFIG_NAME_RULES_STYLISTIC}/typescript/dts`;
+const IMPORTS_CONFIG_NAME_RULES_STYLISTIC_MARKDOWN_SOURCE = `${IMPORTS_CONFIG_NAME_RULES_STYLISTIC}/markdown/source`;
+//#endregion
+//#region src/config/imports/imports.config.ts
+async function imports(options) {
+	const { astro, imports, json, markdown, module: { amd, commonjs, ignore: ignoreModules, node: useNodeModules, webpack }, stylistic, typescript } = options;
+	if (!imports) return [];
+	const importXPlugin = "import-x";
+	const importXPluginRename = PLUGIN_RENAME[importXPlugin];
+	const unusedImportsPrefix = PLUGIN_RENAME["unused-imports"];
+	const importSortPrefix = PLUGIN_RENAME["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: {
+			[importXPluginRename]: importX,
+			...stylistic && {
+				[importSortPrefix]: await interopDefault(import("eslint-plugin-simple-import-sort")),
+				[unusedImportsPrefix]: await interopDefault(import("eslint-plugin-unused-imports"))
+			}
+		},
+		settings: { [`${importXPlugin}/resolver-next`]: [createNodeResolver({})] }
+	}];
+	if (typescript) {
+		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: {
+			[`${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",
+			...!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: {
+			[`${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 (markdown) configs.push({
+		files: [
+			...GLOB_MARKDOWN_SOURCE,
+			...json ? GLOB_MARKDOWN_JSON : [],
+			...astro ? GLOB_MARKDOWN_ASTRO : []
+		],
+		name: IMPORTS_CONFIG_NAME_RULES_STATIC_MARKDOWN_SOURCE,
+		rules: { [`${importXPluginRename}/no-unresolved`]: "off" }
+	});
+	if (typescript) configs.push({
+		files: TYPESCRIPT_GLOBS,
+		name: IMPORTS_CONFIG_NAME_RULES_TYPESCRIPT,
+		rules: { [`${importXPluginRename}/named`]: "off" }
+	});
+	if (astro) configs.push({
+		files: GLOB_ASTRO,
+		name: IMPORTS_CONFIG_NAME_RULES_ASTRO,
+		rules: { [`${importXPluginRename}/named`]: "off" }
+	});
+	if (stylistic) {
+		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" },
+				[`${importSortPrefix}/exports`]: "error",
+				[`${importSortPrefix}/imports`]: "error",
+				[`${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 (typescript) configs.push({
+			files: DTS_GLOBS,
+			name: IMPORTS_CONFIG_NAME_RULES_STYLISTIC_TYPESCRIPT_DTS,
+			rules: { [`${importXPluginRename}/prefer-default-export`]: "off" }
+		});
+		if (markdown) configs.push({
+			files: GLOB_MARKDOWN_SOURCE,
+			name: IMPORTS_CONFIG_NAME_RULES_STYLISTIC_MARKDOWN_SOURCE,
+			rules: { [`${unusedImportsPrefix}/no-unused-vars`]: ["off"] }
+		});
+		if (astro) configs.push({
+			files: GLOB_ASTRO,
+			name: IMPORTS_CONFIG_NAME_RULES_STYLISTIC_ASTRO,
+			rules: {
+				[`${importXPluginRename}/exports-last`]: ["off"],
+				[`${importXPluginRename}/prefer-default-export`]: ["off"]
+			}
+		});
+	}
+	return configs;
+}
+//#endregion
+//#region src/config/react/react.config-name.ts
+const REACT_CONFIG_NAME = `${PLUGIN_PREFIX}/react`;
+const REACT_CONFIG_NAME_SETUP = `${REACT_CONFIG_NAME}/setup`;
+const REACT_CONFIG_NAME_RULES = `${REACT_CONFIG_NAME}/rules`;
+const REACT_CONFIG_NAME_RULES_HOOKS = `${REACT_CONFIG_NAME_RULES}/hooks`;
+const REACT_CONFIG_NAME_RULES_REFRESH = `${REACT_CONFIG_NAME_RULES}/refresh`;
+//#endregion
+//#region src/config/react/react.globs.ts
+const GLOB_REACT_JSX = ["**/*.?([cm])jsx"];
+const GLOB_REACT_TSX = ["**/*.?([cm])tsx"];
+//#endregion
+//#region src/config/react/react.config.ts
+const REACT_REFRESH_ALLOW_CONSTANT_EXPORT_PACKAGES = ["vite"];
+async function react(options) {
+	const { react, typescript } = options;
+	if (!react) 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) => isPackageExists(index));
+	const files = [...GLOB_REACT_JSX, ...typescript ? 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",
+				...!typescript && {
+					"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 }] }
+		}
+	];
+}
+//#endregion
+//#region src/config/stylistic/stylistic.config-name.ts
+const STYLISTIC_CONFIG_NAME = `${PLUGIN_PREFIX}/stylistic`;
+const STYLISTIC_CONFIG_NAME_SETUP = `${STYLISTIC_CONFIG_NAME}/setup`;
+const STYLISTIC_CONFIG_NAME_RULES = `${STYLISTIC_CONFIG_NAME}/rules`;
+const STYLISTIC_CONFIG_NAME_RULES_UNICORN = `${STYLISTIC_CONFIG_NAME_RULES}/unicorn`;
+const STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN = `${STYLISTIC_CONFIG_NAME_RULES_UNICORN}/markdown`;
+const STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN_SOURCE = `${STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN}/source`;
+const STYLISTIC_CONFIG_NAME_RULES_PERFECTIONIST = `${STYLISTIC_CONFIG_NAME_RULES}/perfectionist`;
+const STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_SOURCE = `${`${STYLISTIC_CONFIG_NAME_RULES}/markdown`}/source`;
+const STYLISTIC_CONFIG_NAME_RULES_ASTRO = `${STYLISTIC_CONFIG_NAME_RULES}/astro`;
+const STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_ASRTO = `${STYLISTIC_CONFIG_NAME_RULES}/astro`;
+const STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_JSON = `${STYLISTIC_CONFIG_NAME_RULES}/json`;
+const STYLISTIC_CONFIG_NAME_RULES_JSON = `${STYLISTIC_CONFIG_NAME_RULES}/json`;
+const STYLISTIC_CONFIG_NAME_RULES_JSON_PACKAGE = `${STYLISTIC_CONFIG_NAME_RULES_JSON}/package.json`;
+const STYLISTIC_CONFIG_NAME_RULES_JSON_TSCONFIG = `${STYLISTIC_CONFIG_NAME_RULES_JSON}/tsconfig.json`;
+const STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT = `${STYLISTIC_CONFIG_NAME_RULES}/typescript`;
+const STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT_DTS = `${STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT}/dts`;
+const STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT_TYPE_AWARE = `${STYLISTIC_CONFIG_NAME_RULES_TYPESCRIPT}/type-aware`;
+const STYLISTIC_CONFIG_NAME_RULES_PRETTIER = `${STYLISTIC_CONFIG_NAME_RULES}/prettier`;
+const STYLISTIC_CONFIG_NAME_RULES_PRETTIER_ASTRO = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER}/astro`;
+const STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER}/markdown`;
+const STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN_SOURCE = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN}/source`;
+const STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN_ASTRO = `${STYLISTIC_CONFIG_NAME_RULES_PRETTIER_MARKDOWN}/astro`;
+//#endregion
+//#region 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"
+	};
+}
+//#endregion
+//#region 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
+	};
+}
+//#endregion
+//#region src/config/stylistic/stylistic.config.ts
+async function stylistic(options) {
+	const { astro, json, markdown, stylistic, typescript } = options;
+	if (stylistic === false) return [];
+	const { format, indent, indentSize, perfectionist, unicorn } = stylistic;
+	const isTypeAware = typeof typescript !== "boolean";
+	const typescriptPluginRename = PLUGIN_RENAME["@typescript-eslint"];
+	const stylisticPluginRename = PLUGIN_RENAME["@stylistic"];
+	const jsonPluginRename = PLUGIN_RENAME.jsonc;
+	const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
+	const pluginStylisticOptions = stylisticOptions(stylistic);
+	const pluginStylisticRules = pluginStylistic.configs.customize(pluginStylisticOptions).rules;
+	const pluginUnicorn = await interopDefault(import("eslint-plugin-unicorn"));
+	const pluginPerfectionist = (await interopDefault(import("eslint-plugin-perfectionist"))).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),
+			[`${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 (markdown) config.push({
+		files: [
+			...GLOB_MARKDOWN_SOURCE,
+			...json ? GLOB_MARKDOWN_JSON : [],
+			...astro ? 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 (typescript) {
+		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),
+				[`${typescriptPluginRename}/consistent-type-assertions`]: "off",
+				[`${typescriptPluginRename}/member-ordering`]: ["error", { default: {
+					memberTypes: [
+						"signature",
+						"call-signature",
+						"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",
+						"public-constructor",
+						"protected-constructor",
+						"private-constructor",
+						"constructor",
+						"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",
+						"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",
+						"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),
+				[`${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 (json) 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: [
+						"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: [
+					"incremental",
+					"composite",
+					"tsBuildInfoFile",
+					"disableSourceOfProjectReferenceRedirect",
+					"disableSolutionSearching",
+					"disableReferencedProjectLoad",
+					"target",
+					"jsx",
+					"jsxFactory",
+					"jsxFragmentFactory",
+					"jsxImportSource",
+					"lib",
+					"moduleDetection",
+					"noLib",
+					"reactNamespace",
+					"useDefineForClassFields",
+					"emitDecoratorMetadata",
+					"experimentalDecorators",
+					"baseUrl",
+					"rootDir",
+					"rootDirs",
+					"customConditions",
+					"module",
+					"moduleResolution",
+					"moduleSuffixes",
+					"noResolve",
+					"paths",
+					"resolveJsonModule",
+					"resolvePackageJsonExports",
+					"resolvePackageJsonImports",
+					"typeRoots",
+					"types",
+					"allowArbitraryExtensions",
+					"allowImportingTsExtensions",
+					"allowUmdGlobalAccess",
+					"allowJs",
+					"checkJs",
+					"maxNodeModuleJsDepth",
+					"strict",
+					"strictBindCallApply",
+					"strictFunctionTypes",
+					"strictNullChecks",
+					"strictPropertyInitialization",
+					"allowUnreachableCode",
+					"allowUnusedLabels",
+					"alwaysStrict",
+					"exactOptionalPropertyTypes",
+					"noFallthroughCasesInSwitch",
+					"noImplicitAny",
+					"noImplicitOverride",
+					"noImplicitReturns",
+					"noImplicitThis",
+					"noPropertyAccessFromIndexSignature",
+					"noUncheckedIndexedAccess",
+					"noUnusedLocals",
+					"noUnusedParameters",
+					"useUnknownInCatchVariables",
+					"declaration",
+					"declarationDir",
+					"declarationMap",
+					"downlevelIteration",
+					"emitBOM",
+					"emitDeclarationOnly",
+					"importHelpers",
+					"importsNotUsedAsValues",
+					"inlineSourceMap",
+					"inlineSources",
+					"mapRoot",
+					"newLine",
+					"noEmit",
+					"noEmitHelpers",
+					"noEmitOnError",
+					"outDir",
+					"outFile",
+					"preserveConstEnums",
+					"preserveValueImports",
+					"removeComments",
+					"sourceMap",
+					"sourceRoot",
+					"stripInternal",
+					"allowSyntheticDefaultImports",
+					"esModuleInterop",
+					"forceConsistentCasingInFileNames",
+					"isolatedModules",
+					"preserveSymlinks",
+					"verbatimModuleSyntax",
+					"skipDefaultLibCheck",
+					"skipLibCheck"
+				],
+				pathPattern: "^compilerOptions$"
+			}
+		] }
+	});
+	if (astro) 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 unicornRules = (pluginUnicorn.configs ? pluginUnicorn.configs["flat/recommended"] : void 0)?.rules;
+		config.push({
+			name: STYLISTIC_CONFIG_NAME_RULES_UNICORN,
+			rules: {
+				...unicornRules,
+				"unicorn/consistent-function-scoping": "off",
+				"unicorn/dom-node-dataset": "off",
+				"unicorn/name-replacements": ["error", { allowList: {
+					env: true,
+					props: true
+				} }],
+				"unicorn/no-array-reduce": "off",
+				"unicorn/no-nested-ternary": "off",
+				"unicorn/no-static-only-class": "off"
+			}
+		});
+		if (markdown) config.push({
+			files: GLOB_MARKDOWN,
+			name: STYLISTIC_CONFIG_NAME_RULES_UNICORN_MARKDOWN,
+			rules: { "unicorn/filename-case": "off" }
+		}, {
+			files: [
+				...GLOB_MARKDOWN_SOURCE,
+				...json ? GLOB_MARKDOWN_JSON : [],
+				...astro ? 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(stylistic);
+		config.push({
+			files: typescript ? SOURCE_GLOBS : JAVASCRIPT_GLOBS,
+			ignores: [
+				...GLOB_MARKDOWN_SOURCE,
+				...json ? GLOB_MARKDOWN_JSON : [],
+				...astro ? GLOB_MARKDOWN_ASTRO : []
+			],
+			name: STYLISTIC_CONFIG_NAME_RULES_PRETTIER,
+			rules: { "format/prettier": ["error", {
+				...prettierConfig,
+				parser: "typescript"
+			}] }
+		});
+		if (astro) config.push({
+			files: GLOB_ASTRO,
+			name: STYLISTIC_CONFIG_NAME_RULES_PRETTIER_ASTRO,
+			rules: { "format/prettier": ["error", {
+				...prettierConfig,
+				parser: "astro",
+				plugins: ["prettier-plugin-astro"]
+			}] }
+		});
+		if (markdown) {
+			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 (astro) 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 (json) config.push({
+		files: GLOB_MARKDOWN_JSON,
+		name: STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_JSON,
+		rules: { "json/indent": ["error", 2] }
+	});
+	if (astro) config.push({
+		files: GLOB_MARKDOWN_ASTRO,
+		name: STYLISTIC_CONFIG_NAME_RULES_MARKDOWN_ASRTO,
+		rules: { [`${stylisticPluginRename}/indent`]: ["error", 2] }
+	});
+	return config;
+}
+//#endregion
+//#region src/options/hexadrop-eslint.options.ts
+function getCwdTsconfigPath() {
+	const root = process.cwd();
+	if (existsSync(path.resolve(root, "tsconfig.json"))) return "tsconfig.json";
+}
+function defaultOptions(options = {}) {
+	let typescript = false;
+	const isInstalledTypescript = isPackageExists("typescript");
+	const isInstalledReact = isPackageExists("react");
+	const isInstalledAstro = isPackageExists("astro");
+	if (options.typescript === true) typescript = true;
+	else if (isInstalledTypescript) {
+		if (options.typescript === void 0) typescript = getCwdTsconfigPath() ?? true;
+		else if (options.typescript === "string") typescript = options.typescript.length > 0 ? options.typescript : true;
+		else if (Array.isArray(options.typescript)) typescript = options.typescript.length > 0 ? options.typescript.filter(Boolean) : true;
+	}
+	return {
+		astro: options.astro ?? isInstalledAstro,
+		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) ?? [],
+			recursive: typeof options.ignore.recursive === "boolean" ? options.ignore.recursive : typeof options.ignore.recursive === "object" && options.ignore.recursive.skipDirs ? { skipDirs: options.ignore.recursive.skipDirs.filter(Boolean) } : false
+		} : 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 ?? isInstalledReact,
+		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
+	};
+}
+//#endregion
+//#region src/factory.ts
+function hexadrop(optionsOrFlatConfigItem, ...configs) {
+	const options = defaultOptions(optionsOrFlatConfigItem);
+	let pipeline = new FlatConfigComposer(ignore(options), core(options), astro(options), typescript(options), react(options), json(options), markdown(options), imports(options), stylistic(options)).renamePlugins(PLUGIN_RENAME);
+	const flatConfig = extractTypedFlatConfigItem(optionsOrFlatConfigItem);
+	if (flatConfig) pipeline = pipeline.append(flatConfig);
+	pipeline = pipeline.append(...configs);
+	return pipeline;
+}
+//#endregion
+export { combine, hexadrop as default };