@favorodera/eslint-config 0.0.1 → 0.0.3

package/dist/index.cjs

@@ -24,62 +24,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let eslint_flat_config_utils = require("eslint-flat-config-utils");
 let defu = require("defu");
 let eslint_merge_processors = require("eslint-merge-processors");
+let eslint_processor_vue_blocks = require("eslint-processor-vue-blocks");
+eslint_processor_vue_blocks = __toESM(eslint_processor_vue_blocks, 1);
 let globals = require("globals");
 globals = __toESM(globals, 1);
-//#region src/utils.ts
-/**
-* Return the default export from a module-like object.
-* If the module has no default export, return the original resolved value.
-*
-* @param module - module or promise resolving to a module
-* @returns resolved module default or original module
-*/
-async function getModuleDefault(module) {
-	const resolvedModule = await module;
-	return resolvedModule.default || resolvedModule;
-}
-/**
-* Normalize boolean or options value into merged options or null.
-* Returns null when the input is false or undefined.
-*
-* @param value - boolean, options object, or undefined
-* @param defaults - defaults to merge with
-* @returns merged options or false
-*/
-function resolveOptions(value, defaults) {
-	if (!value) return false;
-	return (0, defu.defu)(value === true ? {} : value, defaults);
-}
-/**
-* Rename rules by replacing configured plugin prefixes.
-*
-* @param rules - rules object to rename
-* @param map - prefix map used for renaming
-* @returns renamed rules object
-*/
-function renameRules(rules, map) {
-	return Object.fromEntries(Object.entries(rules).map(([key, value]) => {
-		for (const [from, to] of Object.entries(map)) if (key.startsWith(`${from}/`)) return [to + key.slice(from.length), value];
-		return [key, value];
-	}));
-}
-//#endregion
 //#region src/globs.ts
-/** Glob pattern for JavaScript linting */
-const jsGlob = "**/*.?([cm])js";
-/** Glob pattern for TypeScript linting */
-const tsGlob = "**/*.?([cm])ts";
-/** Glob pattern for Vue linting */
+const jsGlob = "**/*.{js,cjs,mjs}";
+const tsGlob = "**/*.{ts,cts,mts}";
 const vueGlob = "**/*.vue";
-/** Glob pattern for Markdown linting */
 const mdGlob = "**/*.md";
-/**
-* Default glob patterns for files and directories to ignore
-* Includes common build outputs, dependencies, caches, and temporary files
-*/
+const mdInMdGlob = "**/*.md/*.md";
+const codeInMdGlob = "**/*.md/**/*.{js,cjs,mjs,ts,cts,mts,vue}";
+const jsonGlob = "**/*.json";
+const json5Glob = "**/*.json5";
+const jsoncGlob = "**/*.jsonc";
+const tsConfigGlob = ["**/tsconfig.json", "**/tsconfig.*.json"];
+const packageJsonGlob = "**/package.json";
 const ignoresGlob = [
-	"**/node_modules",
-	"**/dist",
+	"**/node_modules/**",
+	"**/dist/**",
 	"**/package-lock.json",
 	"**/yarn.lock",
 	"**/pnpm-lock.yaml",
@@ -115,6 +78,38 @@ const ignoresGlob = [
 	"**/.*/skills"
 ];
 //#endregion
+//#region src/utils.ts
+/**
+* Resolves a module (or a promise of one) and returns its default export
+* if present, otherwise returns the module itself.
+*
+* Handles both ESM modules (which wrap exports under `.default`) and
+* CJS / plain-object modules uniformly.
+*
+* @param module - A module or a promise that resolves to one
+* @returns The `.default` export if it exists, otherwise the module itself
+*/
+async function importModule(module) {
+	const resolved = await module;
+	if (resolved !== null && typeof resolved === "object" && "default" in resolved) return resolved.default;
+	return resolved;
+}
+/**
+* Normalize boolean or options value into merged options or null.
+* Returns null when the input is false or undefined.
+*
+* @param value - boolean, options object, or undefined
+* @param defaults - defaults to merge with
+* @returns merged options or false
+*/
+function resolveOptions(value, defaults) {
+	if (!value) return false;
+	return (0, defu.defu)(value === true ? {} : value, defaults);
+}
+function extractRules(...configArrays) {
+	return Object.assign({}, ...configArrays.flat().map((config) => config?.rules || {}));
+}
+//#endregion
 //#region src/configs/vue.ts
 const sfcBlocksDefaults = { blocks: {
 	styles: true,
@@ -125,41 +120,39 @@ const vueDefaults = {
 	files: [vueGlob],
 	sfcBlocks: sfcBlocksDefaults
 };
-/**
-* Vue SFC linting via `vue-eslint-parser`, `eslint-plugin-vue`, `typescript-eslint(parser)`.
-* @param options - Vue configuration options
-* @returns Promise resolving to Vue ESLint config items
-*/
 async function vue(options) {
 	const resolved = (0, defu.defu)(options, vueDefaults);
 	const sfcBlocks = resolveOptions(resolved.sfcBlocks, sfcBlocksDefaults);
-	const [vuePlugin, vueParser, tsEsLint, vueBlocksProcessor] = await Promise.all([
-		getModuleDefault(import("eslint-plugin-vue")),
-		getModuleDefault(import("vue-eslint-parser")),
-		getModuleDefault(import("typescript-eslint")),
-		getModuleDefault(import("eslint-processor-vue-blocks"))
+	const [vuePlugin, vueParser, tsEsLint] = await Promise.all([
+		importModule(import("eslint-plugin-vue")),
+		importModule(import("vue-eslint-parser")),
+		importModule(import("typescript-eslint"))
 	]);
+	const baseRules = extractRules(vuePlugin.configs["flat/essential"], vuePlugin.configs["flat/strongly-recommended"], vuePlugin.configs["flat/recommended"]);
+	const processor = sfcBlocks === false ? vuePlugin.processors[".vue"] : (0, eslint_merge_processors.mergeProcessors)([vuePlugin.processors[".vue"], (0, eslint_processor_vue_blocks.default)(sfcBlocks)]);
 	return [{
-		name: "favorodera/vue/rules",
+		name: "favorodera/vue/setup",
 		plugins: { vue: vuePlugin },
+		languageOptions: { globals: {
+			computed: "readonly",
+			defineEmits: "readonly",
+			defineExpose: "readonly",
+			defineProps: "readonly",
+			onMounted: "readonly",
+			onUnmounted: "readonly",
+			reactive: "readonly",
+			ref: "readonly",
+			shallowReactive: "readonly",
+			shallowRef: "readonly",
+			toRef: "readonly",
+			toRefs: "readonly",
+			watch: "readonly",
+			watchEffect: "readonly"
+		} }
+	}, {
+		name: "favorodera/vue/rules",
 		files: resolved.files,
 		languageOptions: {
-			globals: {
-				computed: "readonly",
-				defineEmits: "readonly",
-				defineExpose: "readonly",
-				defineProps: "readonly",
-				onMounted: "readonly",
-				onUnmounted: "readonly",
-				reactive: "readonly",
-				ref: "readonly",
-				shallowReactive: "readonly",
-				shallowRef: "readonly",
-				toRef: "readonly",
-				toRefs: "readonly",
-				watch: "readonly",
-				watchEffect: "readonly"
-			},
 			parser: vueParser,
 			parserOptions: {
 				parser: tsEsLint.parser,
@@ -167,21 +160,9 @@ async function vue(options) {
 				sourceType: "module"
 			}
 		},
-		processor: sfcBlocks === false ? vuePlugin.processors[".vue"] : (0, eslint_merge_processors.mergeProcessors)([vuePlugin.processors[".vue"], vueBlocksProcessor(sfcBlocks)]),
+		processor,
 		rules: {
-			...vuePlugin.configs.base.rules,
-			...vuePlugin.configs["flat/essential"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
-				...accumulator,
-				...currentConfig
-			}), {}),
-			...vuePlugin.configs["flat/strongly-recommended"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
-				...accumulator,
-				...currentConfig
-			}), {}),
-			...vuePlugin.configs["flat/recommended"].map((config) => config.rules).reduce((accumulator, currentConfig) => ({
-				...accumulator,
-				...currentConfig
-			}), {}),
+			...baseRules,
 			"vue/block-order": ["error", { order: [
 				"script",
 				"template",
@@ -203,82 +184,196 @@ async function vue(options) {
 	}];
 }
 //#endregion
-//#region src/configs/typescript.ts
-const typescriptDefaults = { files: [tsGlob] };
+//#region src/configs/ignores.ts
+const defaultPatterns = ignoresGlob;
 /**
-* Extract and merge rules from a compatible config array.
-* @param configs - Array of compatible ESLint configs
-* @returns Merged rules object from all configs
+* Globs for ignoring files and directories from ESLint scanning.
+* @param patterns - Additional ignore patterns or a function to modify the defaults.
+* @returns An array containing the ignore flat config item.
 */
-function extractRules(configs) {
-	return Object.assign({}, ...configs.map((config) => config.rules || {}));
+function ignores(patterns = []) {
+	return [{
+		name: "favorodera/ignores",
+		ignores: typeof patterns === "function" ? patterns(defaultPatterns) : [...defaultPatterns, ...patterns]
+	}];
 }
-/**
-* Typescript linting via `typescript-eslint`.
-* @param options - TypeScript configuration options
-* @returns Promise resolving to TypeScript ESLint config items
-*/
-async function typescript(options) {
-	const resolved = (0, defu.defu)(options, typescriptDefaults);
-	const tsEsLint = await getModuleDefault(import("typescript-eslint"));
+//#endregion
+//#region src/configs/imports.ts
+const importsDefaults = { files: [
+	jsGlob,
+	tsGlob,
+	vueGlob
+] };
+async function imports(options) {
+	const resolved = (0, defu.defu)(options, importsDefaults);
+	const [importPlugin, unusedImportsPlugin] = await Promise.all([importModule(import("eslint-plugin-import-lite")), importModule(import("eslint-plugin-unused-imports"))]);
+	const baseRules = importPlugin.configs.recommended?.rules || {};
 	return [{
-		name: "favorodera/typescript/rules",
+		name: "favorodera/imports/setup",
+		plugins: {
+			"import": importPlugin,
+			"unused-imports": unusedImportsPlugin
+		}
+	}, {
+		name: "favorodera/imports/rules",
 		files: resolved.files,
-		plugins: { ts: tsEsLint.plugin },
-		languageOptions: {
-			parser: tsEsLint.parser,
-			parserOptions: { sourceType: "module" }
-		},
 		rules: {
-			...renameRules(extractRules(tsEsLint.configs.strict), { "@typescript-eslint": "ts" }),
-			...renameRules(extractRules(tsEsLint.configs.stylistic), { "@typescript-eslint": "ts" }),
-			"ts/consistent-type-imports": ["error", { prefer: "type-imports" }],
-			"ts/no-empty-object-type": ["error", { allowInterfaces: "with-single-extends" }],
-			"ts/array-type": ["error", { default: "array" }],
+			...(0, eslint_flat_config_utils.renamePluginsInRules)(baseRules, { "import-lite": "import" }),
+			"import/consistent-type-specifier-style": ["error", "top-level"],
+			"import/first": "error",
+			"import/no-duplicates": "error",
+			"import/no-mutable-exports": "error",
+			"import/no-named-default": "error",
+			"import/newline-after-import": ["error", { count: 1 }],
+			"unused-imports/no-unused-imports": "error",
+			"unused-imports/no-unused-vars": ["error", {
+				args: "after-used",
+				argsIgnorePattern: "^_",
+				ignoreRestSiblings: true,
+				vars: "all",
+				varsIgnorePattern: "^_"
+			}],
 			...resolved.overrides
 		}
 	}];
 }
 //#endregion
-//#region src/configs/ignores.ts
-const defaultPatterns = ignoresGlob;
+//#region src/configs/javascript.ts
+const javascriptDefaults = { files: [
+	jsGlob,
+	tsGlob,
+	vueGlob
+] };
 /**
-* Globs for ignoring files and directories from ESLint scanning.
-* @param patterns - Additional ignore patterns or a function to modify the defaults.
-* @returns An array containing the ignore flat config item.
+* Javascript linting via `eslint`
+* @param options - Javascript configuration options
+* @returns Promise resolving to javascript ESLint config items
 */
-function ignores(patterns = []) {
+async function javascript(options) {
+	const resolved = (0, defu.defu)(options, javascriptDefaults);
+	const baseRules = (await importModule(import("@eslint/js"))).configs.recommended.rules;
 	return [{
-		name: "favorodera/ignores",
-		ignores: typeof patterns === "function" ? patterns(defaultPatterns) : [...defaultPatterns, ...patterns]
+		name: "favorodera/javascript/setup",
+		languageOptions: {
+			ecmaVersion: "latest",
+			sourceType: "module",
+			globals: {
+				...globals.default.browser,
+				...globals.default.es2021,
+				...globals.default.node,
+				document: "readonly",
+				navigator: "readonly",
+				window: "readonly"
+			}
+		},
+		linterOptions: { reportUnusedDisableDirectives: true }
+	}, {
+		name: "favorodera/javascript/rules",
+		files: resolved.files,
+		rules: {
+			...baseRules,
+			"accessor-pairs": ["error", {
+				enforceForClassMembers: true,
+				setWithoutGet: true
+			}],
+			"array-callback-return": "error",
+			"block-scoped-var": "error",
+			...resolved.overrides
+		}
 	}];
 }
 //#endregion
+//#region src/configs/markdown.ts
+const markdownDefaults = {
+	files: [mdGlob],
+	gfm: true
+};
+async function markdown(options) {
+	const resolved = (0, defu.defu)(options, markdownDefaults);
+	const markdownPlugin = await importModule(import("@eslint/markdown"));
+	const baseRules = extractRules(markdownPlugin.configs.recommended);
+	return [
+		{
+			name: "favorodera/markdown/setup",
+			plugins: { md: markdownPlugin }
+		},
+		{
+			name: "favorodera/markdown/rules",
+			files: resolved.files,
+			language: resolved.gfm ? "md/gfm" : "md/commonmark",
+			ignores: [mdInMdGlob],
+			processor: (0, eslint_merge_processors.mergeProcessors)([markdownPlugin.processors?.markdown, eslint_merge_processors.processorPassThrough]),
+			rules: {
+				...(0, eslint_flat_config_utils.renamePluginsInRules)(baseRules, { markdown: "md" }),
+				"md/fenced-code-language": "off",
+				"md/no-missing-label-refs": "off",
+				...resolved.overrides
+			}
+		},
+		{
+			name: "favorodera/markdown/disables/code",
+			files: [codeInMdGlob],
+			languageOptions: { parserOptions: { ecmaFeatures: { impliedStrict: true } } },
+			rules: {
+				"no-alert": "off",
+				"no-console": "off",
+				"no-labels": "off",
+				"no-lone-blocks": "off",
+				"no-restricted-syntax": "off",
+				"no-undef": "off",
+				"no-unused-expressions": "off",
+				"no-unused-labels": "off",
+				"no-unused-vars": "off",
+				"node/prefer-global/process": "off",
+				"style/comma-dangle": "off",
+				"style/eol-last": "off",
+				"style/padding-line-between-statements": "off",
+				"ts/consistent-type-imports": "off",
+				"ts/explicit-function-return-type": "off",
+				"ts/no-namespace": "off",
+				"ts/no-redeclare": "off",
+				"ts/no-require-imports": "off",
+				"ts/no-unused-expressions": "off",
+				"ts/no-unused-vars": "off",
+				"ts/no-use-before-define": "off",
+				"unicode-bom": "off",
+				"unused-imports/no-unused-imports": "off",
+				"unused-imports/no-unused-vars": "off"
+			}
+		}
+	];
+}
+//#endregion
 //#region src/configs/stylistic.ts
 const stylisticDefaults = {
-	indent: 2,
-	experimental: false,
-	quotes: "single",
-	semi: false,
-	jsx: false
+	settings: {
+		indent: 2,
+		experimental: false,
+		quotes: "single",
+		semi: false,
+		jsx: false
+	},
+	files: [
+		jsGlob,
+		tsGlob,
+		vueGlob
+	]
 };
-/**
-* Code style via `@stylistic/eslint-plugin`.
-* @param options - Stylistic configuration options
-* @returns Promise resolving to stylistic ESLint config items
-*/
 async function stylistic(options) {
 	const resolved = (0, defu.defu)(options, stylisticDefaults);
-	const stylePlugin = await getModuleDefault(import("@stylistic/eslint-plugin"));
-	const customizedStyleConfig = stylePlugin.configs.customize({
+	const stylePlugin = await importModule(import("@stylistic/eslint-plugin"));
+	const baseRules = stylePlugin.configs.customize({
 		pluginName: "style",
-		...resolved
-	});
+		...resolved.settings
+	})?.rules || {};
 	return [{
+		name: "favorodera/stylistic/setup",
+		plugins: { style: stylePlugin }
+	}, {
 		name: "favorodera/stylistic/rules",
-		plugins: { style: stylePlugin },
+		files: resolved.files,
 		rules: {
-			...customizedStyleConfig.rules,
+			...baseRules,
 			"style/quotes": [
 				"error",
 				"single",
@@ -321,15 +416,20 @@ const tailwindDefaults = {
 */
 async function tailwind(options) {
 	const resolved = (0, defu.defu)(options, tailwindDefaults);
-	const tailwindPlugin = await getModuleDefault(import("eslint-plugin-better-tailwindcss"));
+	const tailwindPlugin = await importModule(import("eslint-plugin-better-tailwindcss"));
+	const baseRules = {
+		...tailwindPlugin.configs["recommended-error"].rules,
+		...tailwindPlugin.configs["stylistic-error"].rules
+	};
 	return [{
-		name: "favorodera/tailwind/rules",
+		name: "favorodera/tailwind/setup",
 		plugins: { tailwind: tailwindPlugin },
+		settings: { tailwindcss: resolved.settings }
+	}, {
+		name: "favorodera/tailwind/rules",
 		files: resolved.files,
-		settings: { tailwindcss: resolved.settings },
 		rules: {
-			...renameRules(tailwindPlugin.configs["recommended-error"].rules, { "better-tailwindcss": "tailwind" }),
-			...renameRules(tailwindPlugin.configs["stylistic-error"].rules, { "better-tailwindcss": "tailwind" }),
+			...(0, eslint_flat_config_utils.renamePluginsInRules)(baseRules, { "better-tailwindcss": "tailwind" }),
 			"tailwind/no-unregistered-classes": "off",
 			"tailwind/enforce-consistent-line-wrapping": ["error", { group: "emptyLine" }],
 			...resolved.overrides
@@ -337,321 +437,321 @@ async function tailwind(options) {
 	}];
 }
 //#endregion
-//#region src/configs/comments.ts
-const commentsDefaults = { files: [
-	jsGlob,
-	tsGlob,
-	vueGlob
-] };
-/**
-* Comments linting via `@eslint-community/eslint-plugin-eslint-comments`
-* @param options - Comments configuration options
-* @returns Promise resolving to comments ESLint config items
-*/
-async function comments(options) {
-	const resolved = (0, defu.defu)(options, commentsDefaults);
-	const commentsPlugin = await getModuleDefault(import("@eslint-community/eslint-plugin-eslint-comments"));
-	return [{
-		name: "favorodera/comments/rules",
-		files: resolved.files,
-		plugins: { comments: commentsPlugin },
-		rules: {
-			...renameRules(commentsPlugin.configs.recommended?.rules || {}, { "@eslint-community/eslint-comments": "comments" }),
-			"comments/no-aggregating-enable": "error",
-			"comments/no-duplicate-disable": "error",
-			"comments/no-unlimited-disable": "error",
-			"comments/no-unused-enable": "error",
-			...resolved.overrides
-		}
-	}];
-}
-//#endregion
-//#region src/configs/imports.ts
-const importsDefaults = { files: [
-	jsGlob,
-	tsGlob,
-	vueGlob
-] };
+//#region src/configs/typescript.ts
+const typescriptDefaults = { files: [tsGlob] };
 /**
-* Imports & unused imports linting via `eslint-plugin-import-lite` and `eslint-plugin-unused-imports`.
-* @param options - Imports & unused imports configuration options
-* @returns Promise resolving to imports & unused imports ESLint config items
+* Typescript linting via `typescript-eslint`.
+* @param options - TypeScript configuration options
+* @returns Array of TypeScript ESLint config items
 */
-async function imports(options) {
-	const resolved = (0, defu.defu)(options, importsDefaults);
-	const [importPlugin, unusedImportsPlugin] = await Promise.all([getModuleDefault(import("eslint-plugin-import-lite")), getModuleDefault(import("eslint-plugin-unused-imports"))]);
+async function typescript(options) {
+	const resolved = (0, defu.defu)(options, typescriptDefaults);
+	const tsEsLint = await importModule(import("typescript-eslint"));
+	const baseRules = extractRules(tsEsLint.configs.recommended, tsEsLint.configs.strict);
 	return [{
-		name: "favorodera/imports/rules",
+		name: "favorodera/typescript/setup",
+		plugins: { ts: tsEsLint.plugin }
+	}, {
+		name: "favorodera/typescript/rules",
 		files: resolved.files,
-		plugins: {
-			"import": importPlugin,
-			"unused-imports": unusedImportsPlugin
+		languageOptions: {
+			parser: tsEsLint.parser,
+			parserOptions: { sourceType: "module" }
 		},
 		rules: {
-			...renameRules(importPlugin.configs.recommended?.rules || {}, { "import-lite": "import" }),
-			"import/consistent-type-specifier-style": ["error", "top-level"],
-			"import/first": "error",
-			"import/no-duplicates": "error",
-			"import/no-mutable-exports": "error",
-			"import/no-named-default": "error",
-			"import/newline-after-import": ["error", { count: 1 }],
-			"unused-imports/no-unused-imports": "error",
-			"unused-imports/no-unused-vars": ["error", {
-				args: "after-used",
-				argsIgnorePattern: "^_",
-				ignoreRestSiblings: true,
-				vars: "all",
-				varsIgnorePattern: "^_"
+			...(0, eslint_flat_config_utils.renamePluginsInRules)(baseRules, { "@typescript-eslint": "ts" }),
+			"ts/consistent-type-imports": ["error", { prefer: "type-imports" }],
+			"ts/no-empty-object-type": ["error", { allowInterfaces: "with-single-extends" }],
+			"ts/array-type": ["error", {
+				default: "generic",
+				readonly: "generic"
 			}],
 			...resolved.overrides
 		}
 	}];
 }
 //#endregion
-//#region src/configs/markdown.ts
-const markdownDefaults = {
-	files: [mdGlob],
-	gfm: true
-};
-/**
-* Markdown linting via `@eslint/markdown`.
-* @param options - Markdown configuration options
-* @returns Promise resolving to Markdown ESLint config items
-*/
-async function markdown(options) {
-	const resolved = (0, defu.defu)(options, markdownDefaults);
-	const markdownPlugin = await getModuleDefault(import("@eslint/markdown"));
-	return [{
-		name: "favorodera/markdown/rules",
-		files: resolved.files,
-		plugins: { md: markdownPlugin },
-		processor: (0, eslint_merge_processors.mergeProcessors)([markdownPlugin.processors?.markdown, eslint_merge_processors.processorPassThrough]),
-		language: resolved.gfm ? "md/gfm" : "md/commonmark",
-		rules: {
-			...renameRules(markdownPlugin.configs.recommended[0]?.rules || {}, { markdown: "md" }),
-			"md/fenced-code-language": "off",
-			"md/no-missing-label-refs": "off",
-			...resolved.overrides
-		}
-	}];
-}
-//#endregion
-//#region src/configs/javascript.ts
-const javascriptDefaults = { files: [
-	jsGlob,
-	tsGlob,
-	vueGlob
+//#region src/configs/jsonc.ts
+const jsoncDefaults = { files: [
+	json5Glob,
+	jsoncGlob,
+	jsonGlob
 ] };
-/**
-* Javascript linting via `eslint`
-* @param options - Javascript configuration options
-* @returns Promise resolving to javascript ESLint config items
-*/
-async function javascript(options) {
-	const resolved = (0, defu.defu)(options, javascriptDefaults);
-	const jsPlugin = await getModuleDefault(import("@eslint/js"));
-	return [{
-		name: "favorodera/javascript/rules",
-		files: resolved.files,
-		languageOptions: {
-			ecmaVersion: "latest",
-			sourceType: "module",
-			globals: {
-				...globals.default.browser,
-				...globals.default.es2021,
-				...globals.default.node,
-				document: "readonly",
-				navigator: "readonly",
-				window: "readonly"
+async function jsonc(options) {
+	const resolved = (0, defu.defu)(options, jsoncDefaults);
+	return [
+		{
+			name: "favorodera/jsonc/setup",
+			plugins: { jsonc: await importModule(import("eslint-plugin-jsonc")) }
+		},
+		{
+			name: "favorodera/jsonc/rules",
+			files: resolved.files,
+			language: "jsonc/x",
+			rules: {
+				"jsonc/no-bigint-literals": "error",
+				"jsonc/no-binary-expression": "error",
+				"jsonc/no-binary-numeric-literals": "error",
+				"jsonc/no-dupe-keys": "error",
+				"jsonc/no-escape-sequence-in-identifier": "error",
+				"jsonc/no-floating-decimal": "error",
+				"jsonc/no-hexadecimal-numeric-literals": "error",
+				"jsonc/no-infinity": "error",
+				"jsonc/no-multi-str": "error",
+				"jsonc/no-nan": "error",
+				"jsonc/no-number-props": "error",
+				"jsonc/no-numeric-separators": "error",
+				"jsonc/no-octal": "error",
+				"jsonc/no-octal-escape": "error",
+				"jsonc/no-octal-numeric-literals": "error",
+				"jsonc/no-parenthesized": "error",
+				"jsonc/no-plus-sign": "error",
+				"jsonc/no-regexp-literals": "error",
+				"jsonc/no-sparse-arrays": "error",
+				"jsonc/no-template-literals": "error",
+				"jsonc/no-undefined-value": "error",
+				"jsonc/no-unicode-codepoint-escapes": "error",
+				"jsonc/no-useless-escape": "error",
+				"jsonc/space-unary-ops": "error",
+				"jsonc/valid-json-number": "error",
+				"jsonc/vue-custom-block/no-parsing-error": "error",
+				"jsonc/array-bracket-spacing": ["error", "never"],
+				"jsonc/comma-dangle": ["error", "never"],
+				"jsonc/comma-style": ["error", "last"],
+				"jsonc/indent": ["error", 2],
+				"jsonc/key-spacing": ["error", {
+					afterColon: true,
+					beforeColon: false
+				}],
+				"jsonc/object-curly-newline": ["error", {
+					consistent: true,
+					multiline: true
+				}],
+				"jsonc/object-curly-spacing": ["error", "always"],
+				"jsonc/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+				"jsonc/quote-props": "error",
+				"jsonc/quotes": "error",
+				...resolved.overrides
 			}
 		},
-		linterOptions: { reportUnusedDisableDirectives: true },
-		plugins: { js: jsPlugin },
-		rules: {
-			...jsPlugin.configs.recommended.rules,
-			"accessor-pairs": ["error", {
-				enforceForClassMembers: true,
-				setWithoutGet: true
-			}],
-			"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"] }],
-			"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-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": [
+		{
+			name: "favorodera/jsonc/sort/package-json",
+			files: [packageJsonGlob],
+			rules: {
+				"jsonc/sort-array-values": ["error", {
+					order: { type: "asc" },
+					pathPattern: "^files$"
+				}],
+				"jsonc/sort-keys": [
+					"error",
+					{
+						order: [
+							"publisher",
+							"name",
+							"displayName",
+							"type",
+							"version",
+							"private",
+							"packageManager",
+							"description",
+							"author",
+							"contributors",
+							"license",
+							"funding",
+							"homepage",
+							"repository",
+							"bugs",
+							"keywords",
+							"categories",
+							"sideEffects",
+							"imports",
+							"exports",
+							"main",
+							"module",
+							"unpkg",
+							"jsdelivr",
+							"types",
+							"typesVersions",
+							"bin",
+							"icon",
+							"files",
+							"engines",
+							"activationEvents",
+							"contributes",
+							"scripts",
+							"peerDependencies",
+							"peerDependenciesMeta",
+							"dependencies",
+							"optionalDependencies",
+							"devDependencies",
+							"pnpm",
+							"overrides",
+							"resolutions",
+							"husky",
+							"simple-git-hooks",
+							"lint-staged",
+							"eslintConfig"
+						],
+						pathPattern: "^$"
+					},
+					{
+						order: { type: "asc" },
+						pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$"
+					},
+					{
+						order: { type: "asc" },
+						pathPattern: "^(?:resolutions|overrides|pnpm.overrides)$"
+					},
+					{
+						order: { type: "asc" },
+						pathPattern: "^workspaces\\.catalog$"
+					},
+					{
+						order: { type: "asc" },
+						pathPattern: "^workspaces\\.catalogs\\.[^.]+$"
+					},
+					{
+						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)$"
+					}
+				]
+			}
+		},
+		{
+			name: "favorodera/jsonc/sort/tsconfig-json",
+			files: tsConfigGlob,
+			rules: { "jsonc/sort-keys": [
 				"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__"
+					order: [
+						"extends",
+						"compilerOptions",
+						"references",
+						"files",
+						"include",
+						"exclude"
+					],
+					pathPattern: "^$"
 				},
 				{
-					message: "Use `Object.getOwnPropertyDescriptor` instead.",
-					property: "__lookupSetter__"
+					order: [
+						"incremental",
+						"composite",
+						"tsBuildInfoFile",
+						"disableSourceOfProjectReferenceRedirect",
+						"disableSolutionSearching",
+						"disableReferencedProjectLoad",
+						"target",
+						"jsx",
+						"jsxFactory",
+						"jsxFragmentFactory",
+						"jsxImportSource",
+						"lib",
+						"moduleDetection",
+						"noLib",
+						"reactNamespace",
+						"useDefineForClassFields",
+						"emitDecoratorMetadata",
+						"experimentalDecorators",
+						"libReplacement",
+						"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",
+						"isolatedDeclarations",
+						"isolatedModules",
+						"preserveSymlinks",
+						"verbatimModuleSyntax",
+						"erasableSyntaxOnly",
+						"skipDefaultLibCheck",
+						"skipLibCheck"
+					],
+					pathPattern: "^compilerOptions$"
 				}
-			],
-			"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"],
-			...resolved.overrides
+			] }
 		}
-	}];
+	];
 }
 //#endregion
 //#region src/factory.ts
@@ -663,27 +763,30 @@ async function javascript(options) {
 function factory(options = {}) {
 	const configs = [];
 	configs.push(ignores(options.ignores));
-	const vueOptions = resolveOptions(options.vue, {});
-	const typescriptOptions = resolveOptions(options.typescript, {});
-	const stylisticOptions = resolveOptions(options.stylistic, {});
-	const tailwindOptions = resolveOptions(options.tailwind, {});
-	const commentsOptions = resolveOptions(options.comments, {});
-	const importsOptions = resolveOptions(options.imports, {});
-	const markdownOptions = resolveOptions(options.markdown, {});
-	const javascriptOptions = resolveOptions(options.javascript, {});
-	if (vueOptions) configs.push(vue(vueOptions));
-	if (typescriptOptions) configs.push(typescript(typescriptOptions));
-	if (stylisticOptions) configs.push(stylistic(stylisticOptions));
-	if (tailwindOptions) configs.push(tailwind(tailwindOptions));
-	if (commentsOptions) configs.push(comments(commentsOptions));
-	if (importsOptions) configs.push(imports(importsOptions));
-	if (markdownOptions) configs.push(markdown(markdownOptions));
-	if (javascriptOptions) configs.push(javascript(javascriptOptions));
+	const configFunctions = {
+		vue,
+		typescript,
+		stylistic,
+		tailwind,
+		imports,
+		markdown,
+		javascript,
+		jsonc
+	};
+	for (const [key, configFunction] of Object.entries(configFunctions)) {
+		const configOption = options[key];
+		const resolved = resolveOptions(configOption ?? true, {});
+		if (resolved) configs.push(configFunction(resolved));
+	}
 	let composer = new eslint_flat_config_utils.FlatConfigComposer();
-	composer = composer.append(...configs);
+	composer = composer.append(...configs).renamePlugins({
+		"better-tailwindcss": "tailwind",
+		"@typescript-eslint": "ts",
+		"markdown": "md",
+		"import-lite": "import"
+	});
 	return composer;
 }
 //#endregion
 exports.factory = factory;
-exports.getModuleDefault = getModuleDefault;
-exports.renameRules = renameRules;
+exports.importModule = importModule;