@dhzh/eslint-config 1.25.2 → 1.27.0

package/dist/index.mjs

@@ -0,0 +1,1417 @@
+import pluginReact from "@eslint-react/eslint-plugin";
+import pluginReactHooks from "eslint-plugin-react-hooks";
+import pluginReactRefresh from "eslint-plugin-react-refresh";
+import pluginReactCompiler from "eslint-plugin-react-compiler";
+import pluginReactGoogleTranslate from "eslint-plugin-react-google-translate";
+import { isPackageExists } from "local-pkg";
+import { defineConfig as defineConfig$1 } from "eslint/config";
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+import pluginVue from "eslint-plugin-vue";
+import globals from "globals";
+import { mergeProcessors } from "eslint-merge-processors";
+import processorVueBlocks from "eslint-processor-vue-blocks";
+import pluginStylistic from "@stylistic/eslint-plugin";
+import pluginAntfu from "eslint-plugin-antfu";
+import process from "node:process";
+import pluginNode from "eslint-plugin-n";
+import pluginJsonc from "eslint-plugin-jsonc";
+import pluginPackageJson from "eslint-plugin-package-json";
+import pluginUnicorn from "eslint-plugin-unicorn";
+import pluginImportX from "eslint-plugin-import-x";
+import pluginUnusedImports from "eslint-plugin-unused-imports";
+import pluginSimpleImportSort from "eslint-plugin-simple-import-sort";
+import pluginFormat from "eslint-plugin-format";
+import pluginTailwindcss from "eslint-plugin-tailwindcss";
+import configUnocss from "@unocss/eslint-config/flat";
+import pluginYml from "eslint-plugin-yml";
+import pluginToml from "eslint-plugin-toml";
+import * as parserToml from "toml-eslint-parser";
+import * as pluginRegexp from "eslint-plugin-regexp";
+import pluginEslintComments from "@eslint-community/eslint-plugin-eslint-comments/configs";
+//#region src/consts.ts
+const RULE_PREFIX = "tinywaves";
+const GLOB_YML = "**/*.y?(a)ml";
+const GLOB_TOML = "**/*.toml";
+const GLOB_JSON = "**/*.json";
+const GLOB_JSON5 = "**/*.json5";
+const GLOB_JSONC = "**/*.jsonc";
+const GLOB_PACKAGE_JSON = "**/package.json";
+const GLOB_HTML = "**/*.htm?(l)";
+const GLOB_CSS = "**/*.css";
+const GLOB_POSTCSS = "**/*.{p,post}css";
+const GLOB_LESS = "**/*.less";
+const GLOB_SCSS = "**/*.scss";
+const GLOB_GRAPHQL = "**/*.{g,graph}ql";
+const GLOB_XML = "**/*.xml";
+const GLOB_SVG = "**/*.svg";
+const GLOB_VUE = "**/*.vue";
+const GLOB_JSON_SRC = [
+	GLOB_JSON,
+	GLOB_JSON5,
+	GLOB_JSONC,
+	GLOB_PACKAGE_JSON
+];
+const GLOB_TS_SRC = [
+	"**/*.cts",
+	"**/*.mts",
+	"**/*.ts",
+	"**/*.tsx"
+];
+const GLOB_JS_SRC = [
+	"**/*.cjs",
+	"**/*.mjs",
+	"**/*.js",
+	"**/*.jsx"
+];
+const GLOB_JSX_SRC = ["**/*.jsx", "**/*.tsx"];
+const GLOB_SRC = [...GLOB_TS_SRC, ...GLOB_JS_SRC];
+const GLOB_SRC_EXT = GLOB_SRC.map((item) => item.replace("**/*.", ""));
+GLOB_SRC_EXT.flatMap((item) => [
+	`**/__tests__/**/*.${item}`,
+	`**/*.spec.${item}`,
+	`**/*.test.${item}`,
+	`**/*.bench.${item}`,
+	`**/*.benchmark.${item}`
+]);
+const GLOB_EXCLUDE = [
+	"**/node_modules",
+	"**/dist",
+	"**/package-lock.json",
+	"**/yarn.lock",
+	"**/pnpm-lock.yaml",
+	"**/bun.lockb",
+	"**/output",
+	"**/coverage",
+	"**/temp",
+	"**/.temp",
+	"**/tmp",
+	"**/.tmp",
+	"**/.history",
+	"**/.vitepress/cache",
+	"**/.nuxt",
+	"**/.next",
+	"**/.svelte-kit",
+	"**/.vercel",
+	"**/.changeset",
+	"**/.idea",
+	"**/.cache",
+	"**/.output",
+	"**/.vite-inspect",
+	"**/.yarn",
+	"**/vite.config.*.timestamp-*",
+	"**/CHANGELOG*.md",
+	"**/*.min.*",
+	"**/LICENSE*",
+	"**/__snapshots__",
+	"**/auto-import?(s).d.ts",
+	"**/components.d.ts"
+];
+//#endregion
+//#region src/utils.ts
+const parserPlain = {
+	meta: { name: "parser-plain" },
+	parseForESLint: (code) => ({
+		ast: {
+			body: [],
+			comments: [],
+			loc: {
+				end: code.length,
+				start: 0
+			},
+			range: [0, code.length],
+			tokens: [],
+			type: "Program"
+		},
+		scopeManager: null,
+		services: { isPlain: true },
+		visitorKeys: { Program: [] }
+	})
+};
+const mergeRule = (...rules) => {
+	let finalLevel;
+	let finalOptions = {};
+	for (const rule of rules) {
+		if (!rule) continue;
+		if (!Array.isArray(rule)) {
+			finalLevel = rule;
+			continue;
+		}
+		const [level, options] = rule;
+		finalLevel = level;
+		if (options && typeof options === "object") finalOptions = {
+			...finalOptions,
+			...options
+		};
+	}
+	if (Object.keys(finalOptions).length === 0) return finalLevel;
+	return [finalLevel, finalOptions];
+};
+//#endregion
+//#region src/configs/react.ts
+const ReactRefreshAllowConstantExportPackages = ["vite"];
+const RemixPackages = [
+	"@remix-run/node",
+	"@remix-run/react",
+	"@remix-run/serve",
+	"@remix-run/dev"
+];
+const ReactRouterPackages = [
+	"@react-router/node",
+	"@react-router/react",
+	"@react-router/serve",
+	"@react-router/dev"
+];
+const NextJsPackages = ["next"];
+const ExpoPackages = ["expo"];
+function react(options = {}) {
+	const { language = "typescript", overrides = {
+		compiler: {},
+		core: {},
+		hooks: {},
+		refresh: {},
+		googleTranslate: {}
+	} } = options;
+	const config = language === "typescript" ? pluginReact.configs["recommended-type-checked"] : pluginReact.configs.recommended;
+	const isAllowConstantExport = ReactRefreshAllowConstantExportPackages.some((i) => isPackageExists(i));
+	const isUsingRemix = RemixPackages.some((i) => isPackageExists(i));
+	const isUsingReactRouter = ReactRouterPackages.some((i) => isPackageExists(i));
+	const isUsingNext = NextJsPackages.some((i) => isPackageExists(i));
+	const isUsingExpo = ExpoPackages.some((i) => isPackageExists(i));
+	return [
+		{
+			...config,
+			name: `${RULE_PREFIX}/react/core/shared`,
+			files: GLOB_SRC
+		},
+		{
+			name: `${RULE_PREFIX}/react/core/customize`,
+			files: GLOB_SRC,
+			rules: {
+				"@eslint-react/no-missing-context-display-name": "warn",
+				"@eslint-react/no-missing-component-display-name": "off",
+				"@eslint-react/dom-no-hydrate": "error",
+				"@eslint-react/jsx-no-useless-fragment": ["warn", {
+					allowEmptyFragment: true,
+					allowExpressions: true
+				}],
+				"@eslint-react/no-unnecessary-use-prefix": "warn",
+				"@eslint-react/naming-convention-context-name": "warn",
+				...language === "typescript" ? { "@eslint-react/no-leaked-conditional-rendering": "warn" } : {},
+				...overrides.core
+			}
+		},
+		...defineConfig$1([pluginReactHooks.configs.flat["recommended-latest"]]).map((item) => ({
+			...item,
+			name: `${RULE_PREFIX}/react/hooks/shared`,
+			files: GLOB_SRC
+		})),
+		{
+			name: `${RULE_PREFIX}/react/hooks/customize`,
+			files: GLOB_SRC,
+			rules: overrides.hooks || {}
+		},
+		{
+			...pluginReactRefresh.configs.recommended,
+			name: `${RULE_PREFIX}/react/refresh/shared`,
+			files: GLOB_JSX_SRC
+		},
+		{
+			name: `${RULE_PREFIX}/react/refresh/customize`,
+			files: GLOB_JSX_SRC,
+			rules: {
+				"react-refresh/only-export-components": mergeRule(["warn", { allowConstantExport: isAllowConstantExport }], ["warn", { allowExportNames: [
+					...isUsingNext ? [
+						"dynamic",
+						"dynamicParams",
+						"revalidate",
+						"fetchCache",
+						"runtime",
+						"preferredRegion",
+						"maxDuration",
+						"config",
+						"generateMetadata",
+						"generateViewport",
+						"experimental_ppr",
+						"metadata",
+						"viewport",
+						"generateImageMetadata",
+						"generateSitemaps",
+						"generateStaticParams"
+					] : [],
+					...isUsingRemix || isUsingReactRouter ? [
+						"meta",
+						"links",
+						"headers",
+						"loader",
+						"action"
+					] : [],
+					...isUsingExpo ? ["unstable_settings"] : []
+				] }]),
+				...overrides.refresh
+			}
+		},
+		{
+			...pluginReactCompiler.configs.recommended,
+			name: `${RULE_PREFIX}/react/compiler/shared`,
+			files: GLOB_SRC
+		},
+		{
+			name: `${RULE_PREFIX}/react/compiler/customize`,
+			files: GLOB_SRC,
+			rules: overrides.compiler || {}
+		},
+		{
+			name: `${RULE_PREFIX}/react/google-translate`,
+			files: GLOB_JSX_SRC,
+			plugins: { "react-google-translate": pluginReactGoogleTranslate },
+			rules: {
+				"react-google-translate/no-conditional-text-nodes-with-siblings": "warn",
+				"react-google-translate/no-return-text-nodes": "warn",
+				...overrides.googleTranslate
+			}
+		}
+	];
+}
+//#endregion
+//#region src/configs/vue.ts
+function vue(options = {}) {
+	const { overrides = {} } = options;
+	return defineConfig$1({
+		...js.configs.recommended,
+		name: `${RULE_PREFIX}/vue/shared/javascript`,
+		files: [GLOB_VUE]
+	}, tseslint.configs.recommended.map((item) => ({
+		...item,
+		name: `${RULE_PREFIX}/vue/shared/typescript/${item.name?.replace("typescript-eslint/", "")}`,
+		files: [GLOB_VUE]
+	})), pluginVue.configs["flat/recommended"].map((item) => ({
+		...item,
+		name: `${RULE_PREFIX}/vue/shared/${item.name?.replace("vue/", "")}`,
+		files: [GLOB_VUE]
+	})), {
+		name: `${RULE_PREFIX}/vue/customize`,
+		files: [GLOB_VUE],
+		languageOptions: {
+			ecmaVersion: "latest",
+			sourceType: "module",
+			globals: globals.browser,
+			parserOptions: { parser: tseslint.parser }
+		},
+		processor: mergeProcessors([pluginVue.processors[".vue"], processorVueBlocks({ blocks: {
+			styles: true,
+			customBlocks: true,
+			script: false,
+			template: false
+		} })]),
+		rules: overrides
+	});
+}
+//#endregion
+//#region src/configs/stylistic.ts
+function stylistic(options = {}) {
+	const { overrides = {} } = options;
+	const jsxIgnoreNodes = [
+		"TemplateLiteral *",
+		"TSUnionType",
+		"TSIntersectionType",
+		"TSTypeParameterInstantiation",
+		"FunctionExpression > .params[decorators.length > 0]",
+		"FunctionExpression > .params > :matches(Decorator, :not(:first-child))"
+	];
+	const nonJsxIgnoreNodes = ["JSXOpeningElement", "JSXClosingElement"];
+	const basicIndentRuleOptions = {
+		ArrayExpression: 1,
+		CallExpression: { arguments: 1 },
+		flatTernaryExpressions: false,
+		FunctionDeclaration: {
+			body: 1,
+			parameters: 1
+		},
+		FunctionExpression: {
+			body: 1,
+			parameters: 1
+		},
+		ignoreComments: false,
+		ImportDeclaration: 1,
+		MemberExpression: 1,
+		ObjectExpression: 1,
+		offsetTernaryExpressions: true,
+		outerIIFEBody: 1,
+		SwitchCase: 1,
+		VariableDeclarator: 1
+	};
+	return [
+		{
+			...pluginStylistic.configs.customize({
+				arrowParens: true,
+				semi: true,
+				braceStyle: "1tbs"
+			}),
+			name: `${RULE_PREFIX}/stylistic/shared`,
+			files: [
+				...GLOB_SRC,
+				...GLOB_JSON_SRC,
+				GLOB_VUE
+			]
+		},
+		{
+			name: `${RULE_PREFIX}/stylistic/customize`,
+			files: [
+				...GLOB_SRC,
+				...GLOB_JSON_SRC,
+				GLOB_VUE
+			],
+			plugins: {
+				stylistic: pluginStylistic,
+				antfu: pluginAntfu
+			},
+			rules: {
+				"curly": ["error", "all"],
+				"object-shorthand": "error",
+				"prefer-destructuring": [
+					"error",
+					{
+						VariableDeclarator: {
+							array: false,
+							object: true
+						},
+						AssignmentExpression: {
+							array: false,
+							object: false
+						}
+					},
+					{ enforceForRenamedProperties: false }
+				],
+				"prefer-template": "error",
+				"stylistic/array-bracket-newline": ["error", { multiline: true }],
+				"stylistic/array-element-newline": ["error", "consistent"],
+				"stylistic/brace-style": [
+					"error",
+					"1tbs",
+					{ allowSingleLine: false }
+				],
+				"stylistic/function-call-spacing": ["error", "never"],
+				"stylistic/function-paren-newline": "off",
+				"stylistic/indent": [
+					"error",
+					2,
+					{
+						...basicIndentRuleOptions,
+						ignoredNodes: [...jsxIgnoreNodes, ...nonJsxIgnoreNodes]
+					}
+				],
+				"stylistic/key-spacing": ["error", {
+					beforeColon: false,
+					afterColon: true,
+					mode: "strict"
+				}],
+				"stylistic/keyword-spacing": ["error", {
+					before: true,
+					after: true
+				}],
+				"stylistic/line-comment-position": "off",
+				"stylistic/linebreak-style": ["error", "unix"],
+				"stylistic/lines-around-comment": "off",
+				"stylistic/new-parens": ["error", "always"],
+				"stylistic/no-confusing-arrow": ["error", {
+					allowParens: true,
+					onlyOneSimpleParam: true
+				}],
+				"stylistic/no-extra-semi": "error",
+				"stylistic/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+				"stylistic/space-before-function-paren": ["error", {
+					named: "never",
+					anonymous: "always",
+					asyncArrow: "always",
+					catch: "always"
+				}],
+				"stylistic/switch-colon-spacing": ["error", {
+					after: true,
+					before: false
+				}],
+				"stylistic/type-annotation-spacing": "error",
+				"stylistic/wrap-regex": "error",
+				"stylistic/quotes": [
+					"error",
+					"single",
+					{
+						allowTemplateLiterals: true,
+						avoidEscape: true
+					}
+				],
+				"stylistic/no-tabs": "off",
+				"antfu/consistent-chaining": "error",
+				"antfu/consistent-list-newline": "error",
+				"antfu/top-level-function": "off",
+				"antfu/curly": "off",
+				...overrides
+			}
+		},
+		{
+			name: `${RULE_PREFIX}/stylistic/customize/jsx`,
+			files: [...GLOB_JSX_SRC, GLOB_VUE],
+			plugins: { stylistic: pluginStylistic },
+			rules: {
+				"stylistic/indent": [
+					"error",
+					2,
+					{
+						...basicIndentRuleOptions,
+						ignoredNodes: jsxIgnoreNodes
+					}
+				],
+				"stylistic/jsx-closing-bracket-location": ["error", {
+					nonEmpty: "tag-aligned",
+					selfClosing: "tag-aligned"
+				}],
+				"stylistic/jsx-closing-tag-location": ["error", "tag-aligned"],
+				"stylistic/jsx-curly-brace-presence": ["error", {
+					props: "never",
+					children: "never",
+					propElementValues: "always"
+				}],
+				"stylistic/jsx-curly-newline": ["error", {
+					singleline: "consistent",
+					multiline: "consistent"
+				}],
+				"stylistic/jsx-curly-spacing": ["error", {
+					when: "never",
+					attributes: { when: "never" },
+					children: { when: "never" }
+				}],
+				"stylistic/jsx-first-prop-new-line": ["error", "multiline"],
+				"stylistic/jsx-one-expression-per-line": ["error", { allow: "non-jsx" }],
+				"stylistic/jsx-pascal-case": ["error", {
+					allowAllCaps: false,
+					allowLeadingUnderscore: false,
+					allowNamespace: true
+				}],
+				"stylistic/jsx-props-no-multi-spaces": "error",
+				"stylistic/jsx-quotes": ["error", "prefer-double"],
+				"stylistic/jsx-self-closing-comp": ["error", {
+					component: true,
+					html: true
+				}],
+				"stylistic/jsx-sort-props": "off",
+				"stylistic/jsx-indent-props": "off",
+				...overrides
+			}
+		}
+	];
+}
+//#endregion
+//#region src/configs/typescript.ts
+function typescript(options = {}) {
+	const { overrides = {}, typeSafe = false, strict = false } = options;
+	return [...defineConfig$1(tseslint.configs.base, tseslint.configs.recommendedTypeChecked, tseslint.configs.strictTypeChecked, tseslint.configs.stylisticTypeChecked).map((item) => ({
+		...item,
+		name: `${RULE_PREFIX}/typescript/shared/${item.name?.replace("typescript-eslint/", "")}`,
+		files: GLOB_TS_SRC
+	})), {
+		name: `${RULE_PREFIX}/typescript/customize`,
+		files: GLOB_TS_SRC,
+		languageOptions: {
+			parserOptions: {
+				projectService: true,
+				tsconfigRootDir: process.cwd()
+			},
+			sourceType: "module"
+		},
+		rules: {
+			"@typescript-eslint/consistent-type-imports": ["error", { disallowTypeAnnotations: false }],
+			"@typescript-eslint/no-import-type-side-effects": "error",
+			"@typescript-eslint/method-signature-style": ["error", "property"],
+			"no-unused-expressions": "off",
+			"@typescript-eslint/no-unused-expressions": ["error", {
+				allowShortCircuit: true,
+				allowTernary: true
+			}],
+			"@typescript-eslint/no-dynamic-delete": "off",
+			"@typescript-eslint/no-empty-object-type": ["error", {
+				allowInterfaces: "with-single-extends",
+				allowObjectTypes: "never",
+				allowWithName: "Props$"
+			}],
+			"@typescript-eslint/no-non-null-assertion": "off",
+			"@typescript-eslint/ban-ts-comment": "off",
+			"@typescript-eslint/no-explicit-any": "off",
+			"@typescript-eslint/no-non-null-asserted-optional-chain": "warn",
+			"@typescript-eslint/await-thenable": "error",
+			"@typescript-eslint/no-floating-promises": "error",
+			"@typescript-eslint/consistent-type-exports": "error",
+			"@typescript-eslint/no-misused-promises": ["error", { checksVoidReturn: {
+				arguments: false,
+				attributes: false
+			} }],
+			"@typescript-eslint/restrict-template-expressions": ["error", {}],
+			"@typescript-eslint/no-deprecated": "warn",
+			"@typescript-eslint/no-empty-function": "off",
+			"@typescript-eslint/consistent-type-definitions": "off",
+			"@typescript-eslint/array-type": ["error", { default: "array-simple" }],
+			"@typescript-eslint/prefer-nullish-coalescing": "off",
+			"@typescript-eslint/no-confusing-void-expression": ["error", { ignoreArrowShorthand: true }],
+			...typeSafe ? {} : {
+				"@typescript-eslint/no-unsafe-assignment": "off",
+				"@typescript-eslint/no-unsafe-member-access": "off",
+				"@typescript-eslint/no-unsafe-call": "off",
+				"@typescript-eslint/no-unsafe-return": "off",
+				"@typescript-eslint/no-unsafe-argument": "off"
+			},
+			...strict ? {} : { "@typescript-eslint/no-extraneous-class": "off" },
+			...overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/javascript.ts
+function javascript(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		name: `${RULE_PREFIX}/javascript/shared`,
+		files: GLOB_SRC,
+		languageOptions: {
+			ecmaVersion: 2022,
+			globals: {
+				...globals.browser,
+				...globals.es2021,
+				...globals.node,
+				document: "readonly",
+				navigator: "readonly",
+				window: "readonly"
+			},
+			parserOptions: {
+				ecmaFeatures: { jsx: true },
+				ecmaVersion: 2022,
+				sourceType: "module"
+			},
+			sourceType: "module"
+		},
+		linterOptions: { reportUnusedDisableDirectives: true },
+		rules: js.configs.recommended.rules
+	}, {
+		name: `${RULE_PREFIX}/javascript/customize`,
+		files: GLOB_SRC,
+		plugins: { antfu: pluginAntfu },
+		rules: {
+			"arrow-body-style": ["error", "as-needed"],
+			"func-style": [
+				"warn",
+				"declaration",
+				{ allowArrowFunctions: true }
+			],
+			"no-empty-function": "off",
+			"prefer-destructuring": "off",
+			"capitalized-comments": "off",
+			"id-length": "off",
+			"accessor-pairs": ["error", {
+				enforceForClassMembers: true,
+				setWithoutGet: true
+			}],
+			"antfu/no-top-level-await": "error",
+			"array-callback-return": "error",
+			"block-scoped-var": "error",
+			"constructor-super": "error",
+			"default-case-last": "error",
+			"dot-notation": ["error", { allowKeywords: true }],
+			"eqeqeq": ["error", "smart"],
+			"new-cap": ["error", {
+				capIsNew: false,
+				newIsCap: true,
+				properties: true
+			}],
+			"no-alert": "error",
+			"no-array-constructor": "error",
+			"no-async-promise-executor": "error",
+			"no-caller": "error",
+			"no-case-declarations": "error",
+			"no-class-assign": "error",
+			"no-compare-neg-zero": "error",
+			"no-cond-assign": ["error", "always"],
+			"no-console": ["error", { allow: [
+				"warn",
+				"error",
+				"info"
+			] }],
+			"no-const-assign": "error",
+			"no-control-regex": "error",
+			"no-debugger": "error",
+			"no-delete-var": "error",
+			"no-dupe-args": "error",
+			"no-dupe-class-members": "error",
+			"no-dupe-keys": "error",
+			"no-duplicate-case": "error",
+			"no-empty": ["error", { allowEmptyCatch: true }],
+			"no-empty-character-class": "error",
+			"no-empty-pattern": "error",
+			"no-eval": "error",
+			"no-ex-assign": "error",
+			"no-extend-native": "error",
+			"no-extra-bind": "error",
+			"no-extra-boolean-cast": "error",
+			"no-fallthrough": "error",
+			"no-func-assign": "error",
+			"no-global-assign": "error",
+			"no-implied-eval": "error",
+			"no-import-assign": "error",
+			"no-invalid-regexp": "error",
+			"no-irregular-whitespace": "error",
+			"no-iterator": "error",
+			"no-labels": ["error", {
+				allowLoop: false,
+				allowSwitch: false
+			}],
+			"no-lone-blocks": "error",
+			"no-loss-of-precision": "error",
+			"no-misleading-character-class": "error",
+			"no-multi-str": "error",
+			"no-new": "error",
+			"no-new-func": "error",
+			"no-new-native-nonconstructor": "error",
+			"no-new-wrappers": "error",
+			"no-obj-calls": "error",
+			"no-octal": "error",
+			"no-octal-escape": "error",
+			"no-param-reassign": "warn",
+			"no-proto": "error",
+			"no-prototype-builtins": "error",
+			"no-redeclare": ["error", { builtinGlobals: false }],
+			"no-regex-spaces": "error",
+			"no-restricted-globals": [
+				"error",
+				{
+					message: "Use `globalThis` instead.",
+					name: "global"
+				},
+				{
+					message: "Use `globalThis` instead.",
+					name: "self"
+				}
+			],
+			"no-restricted-properties": [
+				"error",
+				{
+					message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
+					property: "__proto__"
+				},
+				{
+					message: "Use `Object.defineProperty` instead.",
+					property: "__defineGetter__"
+				},
+				{
+					message: "Use `Object.defineProperty` instead.",
+					property: "__defineSetter__"
+				},
+				{
+					message: "Use `Object.getOwnPropertyDescriptor` instead.",
+					property: "__lookupGetter__"
+				},
+				{
+					message: "Use `Object.getOwnPropertyDescriptor` instead.",
+					property: "__lookupSetter__"
+				}
+			],
+			"no-restricted-syntax": [
+				"error",
+				"TSEnumDeclaration[const=true]",
+				"TSExportAssignment"
+			],
+			"no-self-assign": ["error", { props: true }],
+			"no-self-compare": "error",
+			"no-sequences": "error",
+			"no-shadow-restricted-names": "error",
+			"no-sparse-arrays": "error",
+			"no-template-curly-in-string": "error",
+			"no-this-before-super": "error",
+			"no-throw-literal": "error",
+			"no-undef": "error",
+			"no-undef-init": "error",
+			"no-unexpected-multiline": "error",
+			"no-unmodified-loop-condition": "error",
+			"no-unneeded-ternary": ["error", { defaultAssignment: false }],
+			"no-unreachable": "error",
+			"no-unreachable-loop": "error",
+			"no-unsafe-finally": "error",
+			"no-unsafe-negation": "error",
+			"no-unused-expressions": ["error", {
+				allowShortCircuit: true,
+				allowTaggedTemplates: true,
+				allowTernary: true
+			}],
+			"no-unused-vars": ["error", {
+				args: "none",
+				caughtErrors: "none",
+				ignoreRestSiblings: true,
+				vars: "all"
+			}],
+			"no-use-before-define": ["error", {
+				classes: false,
+				functions: false,
+				variables: true
+			}],
+			"no-useless-backreference": "error",
+			"no-useless-call": "error",
+			"no-useless-catch": "error",
+			"no-useless-computed-key": "error",
+			"no-useless-constructor": "error",
+			"no-useless-rename": "error",
+			"no-useless-return": "error",
+			"no-var": "error",
+			"no-with": "error",
+			"object-shorthand": [
+				"error",
+				"always",
+				{
+					avoidQuotes: true,
+					ignoreConstructors: false
+				}
+			],
+			"one-var": ["error", { initialized: "never" }],
+			"prefer-arrow-callback": ["error", {
+				allowNamedFunctions: false,
+				allowUnboundThis: true
+			}],
+			"prefer-const": ["error", {
+				destructuring: "all",
+				ignoreReadBeforeAssign: true
+			}],
+			"prefer-exponentiation-operator": "error",
+			"prefer-promise-reject-errors": "error",
+			"prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+			"prefer-rest-params": "error",
+			"prefer-spread": "error",
+			"prefer-template": "error",
+			"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", "never"],
+			...overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/node.ts
+function node(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		...pluginNode.configs["flat/recommended"],
+		name: `${RULE_PREFIX}/node/shared`,
+		files: GLOB_SRC
+	}, {
+		name: `${RULE_PREFIX}/node/customize`,
+		files: GLOB_SRC,
+		rules: {
+			"n/handle-callback-err": ["error", "^(err|error)$"],
+			"n/no-new-require": "error",
+			"n/no-path-concat": "error",
+			"n/prefer-global/buffer": ["error", "never"],
+			"n/prefer-global/process": ["error", "never"],
+			"n/no-missing-import": "off",
+			...overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/json.ts
+function json(options = {}) {
+	const { overrides = {
+		core: {},
+		packageJson: {}
+	}, indent = 2, packageJsonRequireType = true } = options;
+	return [
+		...pluginJsonc.configs["recommended-with-json"].map((item) => ({
+			...item,
+			name: `${RULE_PREFIX}/json/shared/json`,
+			files: [GLOB_JSON]
+		})),
+		...pluginJsonc.configs["recommended-with-jsonc"].map((item) => ({
+			...item,
+			name: `${RULE_PREFIX}/json/shared/jsonc`,
+			files: [GLOB_JSONC]
+		})),
+		...pluginJsonc.configs["recommended-with-json5"].map((item) => ({
+			...item,
+			name: `${RULE_PREFIX}/json/shared/json5`,
+			files: [GLOB_JSON5]
+		})),
+		{
+			name: `${RULE_PREFIX}/json/customize`,
+			files: [
+				GLOB_JSON,
+				GLOB_JSON5,
+				GLOB_JSONC
+			],
+			rules: {
+				"jsonc/array-bracket-spacing": ["error", "never"],
+				"jsonc/comma-dangle": ["error", "never"],
+				"jsonc/comma-style": ["error", "last"],
+				"jsonc/indent": ["error", indent],
+				"jsonc/no-comments": "off",
+				"jsonc/key-spacing": ["error", {
+					afterColon: true,
+					beforeColon: false
+				}],
+				"jsonc/object-curly-newline": ["error", {
+					consistent: true,
+					multiline: true
+				}],
+				"jsonc/object-curly-spacing": ["error", "always"],
+				"jsonc/quote-props": "error",
+				"jsonc/quotes": "error",
+				"jsonc/no-bigint-literals": "error",
+				"jsonc/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
+				"jsonc/no-binary-expression": "error",
+				"jsonc/no-binary-numeric-literals": "error",
+				"jsonc/no-dupe-keys": "error",
+				"jsonc/no-escape-sequence-in-identifier": "error",
+				"jsonc/no-floating-decimal": "error",
+				"jsonc/no-hexadecimal-numeric-literals": "error",
+				"jsonc/no-infinity": "error",
+				"jsonc/no-multi-str": "error",
+				"jsonc/no-nan": "error",
+				"jsonc/no-number-props": "error",
+				"jsonc/no-numeric-separators": "error",
+				"jsonc/no-octal": "error",
+				"jsonc/no-octal-escape": "error",
+				"jsonc/no-octal-numeric-literals": "error",
+				"jsonc/no-parenthesized": "error",
+				"jsonc/no-plus-sign": "error",
+				"jsonc/no-regexp-literals": "error",
+				"jsonc/no-sparse-arrays": "error",
+				"jsonc/no-template-literals": "error",
+				"jsonc/no-undefined-value": "error",
+				"jsonc/no-unicode-codepoint-escapes": "error",
+				"jsonc/no-useless-escape": "error",
+				"jsonc/space-unary-ops": "error",
+				"jsonc/valid-json-number": "error",
+				"jsonc/vue-custom-block/no-parsing-error": "error",
+				...overrides.core
+			}
+		},
+		{
+			...pluginPackageJson.configs.recommended,
+			name: `${RULE_PREFIX}/json/shared/package.json`,
+			files: [GLOB_PACKAGE_JSON]
+		},
+		{
+			name: `${RULE_PREFIX}/json/customize/package.json`,
+			files: [GLOB_PACKAGE_JSON],
+			rules: {
+				"package-json/order-properties": ["error", { order: [
+					"publisher",
+					"name",
+					"displayName",
+					"type",
+					"version",
+					"private",
+					"packageManager",
+					"description",
+					"author",
+					"contributors",
+					"license",
+					"funding",
+					"homepage",
+					"repository",
+					"bugs",
+					"keywords",
+					"categories",
+					"sideEffects",
+					"exports",
+					"main",
+					"module",
+					"unpkg",
+					"jsdelivr",
+					"types",
+					"typesVersions",
+					"bin",
+					"icon",
+					"files",
+					"engines",
+					"activationEvents",
+					"contributes",
+					"scripts",
+					"release-it",
+					"peerDependencies",
+					"peerDependenciesMeta",
+					"dependencies",
+					"optionalDependencies",
+					"devDependencies",
+					"pnpm",
+					"overrides",
+					"resolutions",
+					"husky",
+					"simple-git-hooks",
+					"lint-staged",
+					"eslintConfig"
+				] }],
+				"package-json/require-type": packageJsonRequireType ? "error" : "off",
+				...overrides.packageJson
+			}
+		}
+	];
+}
+//#endregion
+//#region src/configs/unicorn.ts
+function unicorn(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		...pluginUnicorn.configs.recommended,
+		name: `${RULE_PREFIX}/unicorn/shared`,
+		files: GLOB_SRC
+	}, {
+		name: `${RULE_PREFIX}/unicorn/customize`,
+		files: GLOB_SRC,
+		rules: {
+			"unicorn/consistent-destructuring": "off",
+			"unicorn/prevent-abbreviations": "off",
+			"unicorn/prefer-top-level-await": "off",
+			"unicorn/no-unreadable-array-destructuring": "off",
+			"unicorn/no-null": "off",
+			"unicorn/consistent-empty-array-spread": "error",
+			"unicorn/error-message": "error",
+			"unicorn/escape-case": "error",
+			"unicorn/no-hex-escape": "error",
+			"unicorn/new-for-builtins": "error",
+			"unicorn/no-instanceof-builtins": "error",
+			"unicorn/no-new-array": "error",
+			"unicorn/no-new-buffer": "error",
+			"unicorn/number-literal-case": "error",
+			"unicorn/prefer-dom-node-text-content": "error",
+			"unicorn/prefer-includes": "error",
+			"unicorn/prefer-node-protocol": "error",
+			"unicorn/prefer-query-selector": "off",
+			"unicorn/prefer-number-properties": "error",
+			"unicorn/prefer-string-starts-ends-with": "error",
+			"unicorn/prefer-type-error": "error",
+			"unicorn/throw-new-error": "error",
+			...overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/imports.ts
+function imports(options = {}) {
+	const { overrides = {}, closeOrder = true } = options;
+	return [{
+		name: `${RULE_PREFIX}/imports/customize`,
+		files: GLOB_SRC,
+		plugins: {
+			"antfu": pluginAntfu,
+			"import-x": pluginImportX,
+			"unused-imports": pluginUnusedImports,
+			"simple-import-sort": pluginSimpleImportSort
+		},
+		rules: {
+			"sort-imports": "off",
+			"no-unused-vars": "off",
+			"no-duplicate-imports": "off",
+			"@typescript-eslint/no-unused-vars": "off",
+			"antfu/import-dedupe": "error",
+			"antfu/no-import-dist": "error",
+			"antfu/no-import-node-modules-by-path": "error",
+			"import-x/consistent-type-specifier-style": ["error", "prefer-top-level"],
+			"import-x/first": "error",
+			"import-x/no-duplicates": "error",
+			"import-x/no-mutable-exports": "error",
+			"import-x/no-named-default": "error",
+			"import-x/no-self-import": "error",
+			"import-x/no-webpack-loader-syntax": "error",
+			"import-x/order": "off",
+			"import-x/newline-after-import": ["error", { count: 1 }],
+			"unused-imports/no-unused-imports": "warn",
+			"unused-imports/no-unused-vars": ["error", {
+				args: "after-used",
+				argsIgnorePattern: "^_",
+				ignoreRestSiblings: true,
+				vars: "all",
+				varsIgnorePattern: "^_"
+			}],
+			"simple-import-sort/imports": closeOrder ? "off" : "error",
+			"simple-import-sort/exports": closeOrder ? "off" : "error",
+			...overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/format.ts
+const mergePrettierOptions = (options, overrides) => ({
+	...options,
+	...overrides,
+	plugins: [...overrides.plugins || []]
+});
+function format(options = {}) {
+	const { enable = {
+		html: true,
+		css: true,
+		graphql: true,
+		xml: true,
+		svg: true
+	}, customPrettierOptions = {} } = options;
+	const configs = [];
+	if (!enable) return configs;
+	const prettierOptions = Object.assign({
+		printWidth: 120,
+		tabWidth: 2,
+		semi: true,
+		singleQuote: true,
+		quoteProps: "consistent",
+		jsxSingleQuote: false,
+		trailingComma: "all",
+		bracketSpacing: true,
+		bracketSameLine: false,
+		arrowParens: "always",
+		useTabs: false,
+		endOfLine: "lf",
+		singleAttributePerLine: false
+	}, customPrettierOptions);
+	const prettierXmlOptions = {
+		xmlQuoteAttributes: "double",
+		xmlSelfClosingSpace: true,
+		xmlSortAttributesByKey: false,
+		xmlWhitespaceSensitivity: "ignore"
+	};
+	configs.push({
+		name: `${RULE_PREFIX}/format`,
+		plugins: { format: pluginFormat }
+	});
+	if (enable.html) configs.push({
+		name: `${RULE_PREFIX}/format/html`,
+		files: [GLOB_HTML],
+		languageOptions: { parser: parserPlain },
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "html" })] }
+	});
+	if (enable.css) configs.push({
+		name: `${RULE_PREFIX}/format/css`,
+		files: [GLOB_CSS, GLOB_POSTCSS],
+		languageOptions: { parser: parserPlain },
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "css" })] }
+	}, {
+		name: `${RULE_PREFIX}/format/scss`,
+		files: [GLOB_SCSS],
+		languageOptions: { parser: parserPlain },
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "scss" })] }
+	}, {
+		name: `${RULE_PREFIX}/format/less`,
+		files: [GLOB_LESS],
+		languageOptions: { parser: parserPlain },
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "less" })] }
+	});
+	if (enable.graphql) configs.push({
+		name: `${RULE_PREFIX}/format/graphql`,
+		files: [GLOB_GRAPHQL],
+		languageOptions: { parser: parserPlain },
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "graphql" })] }
+	});
+	if (enable.xml) configs.push({
+		name: `${RULE_PREFIX}/format/xml`,
+		files: [GLOB_XML],
+		languageOptions: { parser: parserPlain },
+		rules: { "format/prettier": ["error", mergePrettierOptions({
+			...prettierXmlOptions,
+			...prettierOptions
+		}, {
+			parser: "xml",
+			plugins: ["@prettier/plugin-xml"]
+		})] }
+	});
+	if (enable.svg) configs.push({
+		name: `${RULE_PREFIX}/format/svg`,
+		files: [GLOB_SVG],
+		languageOptions: { parser: parserPlain },
+		rules: { "format/prettier": ["error", mergePrettierOptions({
+			...prettierXmlOptions,
+			...prettierOptions
+		}, {
+			parser: "xml",
+			plugins: ["@prettier/plugin-xml"]
+		})] }
+	});
+	return configs;
+}
+//#endregion
+//#region src/configs/tailwindcss.ts
+function tailwindcss(options = {}) {
+	const { overrides = {} } = options;
+	return isPackageExists("tailwindcss") ? [...pluginTailwindcss.configs["flat/recommended"].map((item) => ({
+		...item,
+		name: `${RULE_PREFIX}/tailwindcss/shared/${item.name?.replace("tailwindcss:", "")}`,
+		files: GLOB_SRC
+	})), {
+		name: `${RULE_PREFIX}/tailwindcss/customize`,
+		files: GLOB_SRC,
+		rules: {
+			"tailwindcss/no-custom-classname": "off",
+			...overrides
+		}
+	}] : [];
+}
+//#endregion
+//#region src/configs/unocss.ts
+function unocss(options = {}) {
+	const { overrides = {} } = options;
+	if (!isPackageExists("unocss")) return [];
+	return [{
+		...configUnocss,
+		name: `${RULE_PREFIX}/unocss/shared`,
+		files: GLOB_SRC
+	}, {
+		name: `${RULE_PREFIX}/unocss/customize`,
+		files: GLOB_SRC,
+		rules: overrides
+	}];
+}
+//#endregion
+//#region src/configs/yml.ts
+function yml(options = {}) {
+	const { overrides = {}, indent = 2, quotes = "single" } = options;
+	return [
+		...pluginYml.configs.recommended.map((item) => ({
+			...item,
+			name: `${RULE_PREFIX}/yml/shared`,
+			files: [GLOB_YML]
+		})),
+		{
+			name: `${RULE_PREFIX}/yml/customize`,
+			files: [GLOB_YML],
+			rules: {
+				"yml/block-mapping": "error",
+				"yml/block-sequence": "error",
+				"yml/no-empty-key": "error",
+				"yml/no-empty-sequence-entry": "error",
+				"yml/no-irregular-whitespace": "error",
+				"yml/plain-scalar": "error",
+				"yml/block-mapping-question-indicator-newline": "error",
+				"yml/block-sequence-hyphen-indicator-newline": "error",
+				"yml/flow-mapping-curly-newline": "error",
+				"yml/flow-mapping-curly-spacing": "error",
+				"yml/flow-sequence-bracket-newline": "error",
+				"yml/flow-sequence-bracket-spacing": "error",
+				"yml/indent": ["error", indent],
+				"yml/key-spacing": "error",
+				"yml/no-tab-indent": "error",
+				"yml/quotes": ["error", {
+					avoidEscape: true,
+					prefer: quotes
+				}],
+				"yml/spaced-comment": "error",
+				...overrides
+			}
+		},
+		{
+			name: `${RULE_PREFIX}/yml/customize/pnpm-workspace.yaml`,
+			files: ["pnpm-workspace.yaml"],
+			rules: { "yml/sort-keys": [
+				"error",
+				{
+					order: [
+						"packages",
+						"overrides",
+						"patchedDependencies",
+						"hoistPattern",
+						"catalog",
+						"catalogs",
+						"allowedDeprecatedVersions",
+						"allowNonAppliedPatches",
+						"configDependencies",
+						"ignoredBuiltDependencies",
+						"ignoredOptionalDependencies",
+						"neverBuiltDependencies",
+						"onlyBuiltDependencies",
+						"onlyBuiltDependenciesFile",
+						"packageExtensions",
+						"peerDependencyRules",
+						"supportedArchitectures"
+					],
+					pathPattern: "^$"
+				},
+				{
+					order: { type: "asc" },
+					pathPattern: ".*"
+				}
+			] }
+		}
+	];
+}
+//#endregion
+//#region src/configs/toml.ts
+function toml(options = {}) {
+	const { overrides = {}, indent = 2 } = options;
+	return [...pluginToml.configs.recommended.map((item) => ({
+		...item,
+		name: `${RULE_PREFIX}/toml/shared`,
+		files: [GLOB_TOML]
+	})), {
+		name: `${RULE_PREFIX}/toml/customize`,
+		files: [GLOB_TOML],
+		languageOptions: { parser: parserToml },
+		rules: {
+			"toml/comma-style": "error",
+			"toml/keys-order": "error",
+			"toml/no-space-dots": "error",
+			"toml/no-unreadable-number-separator": "error",
+			"toml/precision-of-fractional-seconds": "error",
+			"toml/precision-of-integer": "error",
+			"toml/tables-order": "error",
+			"toml/array-bracket-newline": "error",
+			"toml/array-bracket-spacing": "error",
+			"toml/array-element-newline": "error",
+			"toml/indent": ["error", indent],
+			"toml/inline-table-curly-spacing": "error",
+			"toml/key-spacing": "error",
+			"toml/padding-line-between-pairs": "error",
+			"toml/padding-line-between-tables": "error",
+			"toml/quoted-keys": "error",
+			"toml/spaced-comment": "error",
+			"toml/table-bracket-spacing": "error",
+			...overrides
+		}
+	}];
+}
+//#endregion
+//#region src/configs/regexp.ts
+function regexp(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		...pluginRegexp.configs.recommended,
+		name: `${RULE_PREFIX}/regexp/shared`,
+		files: GLOB_SRC
+	}, {
+		name: `${RULE_PREFIX}/regexp/customize`,
+		files: GLOB_SRC,
+		rules: overrides
+	}];
+}
+//#endregion
+//#region src/configs/ignores.ts
+function ignores(ignorePatterns) {
+	return [{
+		name: `${RULE_PREFIX}/ignores`,
+		ignores: [...GLOB_EXCLUDE, ...ignorePatterns]
+	}];
+}
+//#endregion
+//#region src/configs/eslint-comments.ts
+function eslintComments(options = {}) {
+	const { overrides = {} } = options;
+	return [{
+		...pluginEslintComments.recommended,
+		name: `${RULE_PREFIX}/eslint-comments/shared`
+	}, {
+		name: `${RULE_PREFIX}/eslint-comments/customize`,
+		rules: overrides
+	}];
+}
+//#endregion
+//#region src/configs/disables.ts
+function disables(options = {}) {
+	const { overrides = {
+		scripts: {},
+		cli: {},
+		bin: {},
+		dts: {},
+		cjs: {},
+		config: {}
+	} } = options;
+	return [
+		{
+			name: `${RULE_PREFIX}/disables/scripts`,
+			files: GLOB_SRC.map((item) => `**/scripts/${item}`),
+			rules: {
+				"antfu/no-top-level-await": "off",
+				"no-console": "off",
+				"@typescript-eslint/explicit-function-return-type": "off",
+				...overrides.scripts
+			}
+		},
+		{
+			name: `${RULE_PREFIX}/disables/cli`,
+			files: [...GLOB_SRC.map((item) => `**/cli/${item}`), ...GLOB_SRC_EXT.map((item) => `**/cli.${item}`)],
+			rules: {
+				"antfu/no-top-level-await": "off",
+				"no-console": "off",
+				...overrides.cli
+			}
+		},
+		{
+			name: `${RULE_PREFIX}/disables/bin`,
+			files: ["**/bin/**/*", ...GLOB_SRC_EXT.map((item) => `**/bin.${item}`)],
+			rules: {
+				"antfu/no-import-dist": "off",
+				"antfu/no-import-node-modules-by-path": "off",
+				...overrides.bin
+			}
+		},
+		{
+			name: `${RULE_PREFIX}/disables/dts`,
+			files: ["**/*.d.?([cm])ts"],
+			rules: {
+				"eslint-comments/no-unlimited-disable": "off",
+				"import/no-duplicates": "off",
+				"no-restricted-syntax": "off",
+				"unused-imports/no-unused-vars": "off",
+				...overrides.dts
+			}
+		},
+		{
+			name: `${RULE_PREFIX}/disables/cjs`,
+			files: ["**/*.js", "**/*.cjs"],
+			rules: {
+				"ts/no-require-imports": "off",
+				...overrides.cjs
+			}
+		},
+		{
+			name: `${RULE_PREFIX}/disables/config`,
+			files: [...GLOB_SRC_EXT.map((item) => `**/*.config.${item}`), ...GLOB_SRC_EXT.map((item) => `**/*.config.*.${item}`)],
+			rules: {
+				"antfu/no-top-level-await": "off",
+				"no-console": "off",
+				"ts/explicit-function-return-type": "off",
+				...overrides.config
+			}
+		}
+	];
+}
+//#endregion
+//#region src/configs/language-options.ts
+function languageOptions(options = {}) {
+	const { sourceType = "module" } = options;
+	return [{
+		name: `${RULE_PREFIX}/language-options`,
+		files: GLOB_SRC,
+		languageOptions: { sourceType }
+	}];
+}
+//#endregion
+//#region src/index.ts
+function defineConfig(options = {}) {
+	const { configs = {}, ignorePatterns = [], sourceType = "module" } = options;
+	return [
+		...react(configs.react),
+		...vue(configs.vue),
+		...stylistic(configs.stylistic),
+		...typescript(configs.typescript),
+		...javascript(configs.javascript),
+		...node(configs.node),
+		...json(configs.json),
+		...unicorn(configs.unicorn),
+		...imports(configs.imports),
+		...format(configs.format),
+		...tailwindcss(configs.tailwindcss),
+		...unocss(configs.unocss),
+		...yml(configs.yml),
+		...toml(configs.toml),
+		...regexp(configs.regexp),
+		...ignores(ignorePatterns),
+		...eslintComments(configs.eslintComments),
+		...disables(configs.disables),
+		...languageOptions({ sourceType })
+	];
+}
+//#endregion
+export { defineConfig };