@fabdeh/eslint-config 0.6.4 → 0.7.0

package/dist/index.js

@@ -0,0 +1,2351 @@
+import tseslint from "typescript-eslint";
+import { statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import process from "node:process";
+import { isPackageExists } from "local-pkg";
+import eslintComments from "@eslint-community/eslint-plugin-eslint-comments";
+import * as importX from "eslint-plugin-import-x";
+import eslint from "@eslint/js";
+import preferArrowFunctions from "eslint-plugin-prefer-arrow-functions";
+import unusedImports from "eslint-plugin-unused-imports";
+import globals from "globals";
+import jsdocPlugin from "eslint-plugin-jsdoc";
+import { mergeProcessors, processorPassThrough } from "eslint-merge-processors";
+import nodePlugin from "eslint-plugin-n";
+import perfectionistPlugin from "eslint-plugin-perfectionist";
+import { configs } from "eslint-plugin-regexp";
+import unicornPlugin from "eslint-plugin-unicorn";
+
+//#region src/globs.ts
+/**
+* A glob pattern that matches the extension of JavaScript and TypeScript source files.
+*/
+const GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+/**
+* A glob pattern that matches JavaScript and TypeScript source files (including JSX/TSX).
+*/
+const GLOB_SRC = `**/*.${GLOB_SRC_EXT}`;
+/**
+* A glob pattern that matches JavaScript source files (including JSX).
+*/
+const GLOB_JS = "**/*.?([cm])js?(x)";
+/**
+* A glob pattern that matches the extensions of TypeScript source files (including TSX).
+*/
+const GLOB_TS_EXT = "?([cm])ts?(x)";
+/**
+* A glob pattern that matches TypeScript source files (including TSX).
+*/
+const GLOB_TS = `**/*.${GLOB_TS_EXT}`;
+/**
+* A glob pattern that matches all CSS files.
+*/
+const GLOB_CSS = "**/*.css";
+/**
+* A glob pattern that matches all PostCSS files.
+*/
+const GLOB_POSTCSS = "**/*.{p,post}css";
+/**
+* A glob pattern that matches all LESS files.
+*/
+const GLOB_LESS = "**/*.less";
+/**
+* A glob pattern that matches all SCSS files.
+*/
+const GLOB_SCSS = "**/*.scss";
+/**
+* A glob pattern that matches all JSON files.
+*/
+const GLOB_JSON = "**/*.json";
+/**
+* A glob pattern that matches all JSON5 files.
+*/
+const GLOB_JSON5 = "**/*.json5";
+/**
+* A glob pattern that matches all JSONC files.
+*/
+const GLOB_JSONC = "**/*.jsonc";
+/**
+* A glob pattern that matches all Markdown files.
+*/
+const GLOB_MARKDOWN = "**/*.md";
+/**
+* A glob pattern that matches all Markdown blocks embedded into a Markdown file.
+*/
+const GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
+/**
+* A glob pattern that matches all JavaScript/TypeScript source code block embedded in a markdown file.
+*/
+const GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
+/**
+* A glob pattern that matches YAML files.
+*/
+const GLOB_YAML = "**/*.y?(a)ml";
+/**
+* A glob pattern that matches TOML files.
+*/
+const GLOB_TOML = "**/*.toml";
+/**
+* A glob pattern that matches XML files.
+*/
+const GLOB_XML = "**/*.xml";
+/**
+* A glob pattern that matches SVG files.
+*/
+const GLOB_SVG = "**/*.svg";
+/**
+* A glob pattern that matches GraphQL files.
+*/
+const GLOB_GRAPHQL = "**/*.{g,graph}ql";
+/**
+* A glob pattern that matches HTML files.
+*/
+const GLOB_HTML = "**/*.htm?(l)";
+/**
+* A glob pattern that matches test files.
+*/
+const GLOB_TESTS = [
+	`**/*.spec.?([cm])[jt]s`,
+	`**/*.test.?([cm])[jt]s`,
+	`**/test-setup.?([cm])[jt]s`
+];
+/**
+* A glob pattern that matches files to exclude from linting.
+*/
+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",
+	"**/.tsup",
+	"**/.vite-inspect",
+	"**/.yarn",
+	"**/vite.config.*.timestamp-*",
+	"**/CHANGELOG*.md",
+	"**/*.min.*",
+	"**/LICENSE*",
+	"**/__snapshots__",
+	"**/auto-import?(s).d.ts",
+	"**/components.d.ts",
+	"**/prettier-types.ts"
+];
+
+//#endregion
+//#region src/utils.ts
+const SCOPE_URL = import.meta.dirname;
+const IS_CWD_IN_SCOPE = isPackageExists("@fabdeh/eslint-config");
+/**
+* A utility function to handle the default export of a module.
+*
+* This function takes an `Awaitable` module and returns its default export if it exists,
+* otherwise, it returns the module itself.
+*
+* @template T - The type of the module.
+* @param m - The module to resolve.
+* @returns A promise that resolves to the default export of the module if it exists, otherwise the module itself.
+*/
+async function interopDefault(m) {
+	const resolved = await m;
+	return resolved.default ?? resolved;
+}
+/**
+* Checks if a file exists at the given path.
+*
+* @param path - The path to the file.
+* @returns `true` if the file exists, `false` otherwise.
+*/
+function fileExists(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Retrieves the root directory of the workspace.
+*
+* This function determines the root directory of the workspace by checking for specific files
+* and directories that indicate the presence of an Nx workspace. If the `NX_WORKSPACE_ROOT_PATH`
+* environment variable is set, it returns that value. Otherwise, it recursively checks parent
+* directories until it finds the workspace root or reaches the filesystem root.
+*
+* @param dir - The current directory to start the search from.
+* @param candidateRoot - The initial candidate root directory.
+* @returns The root directory of the workspace.
+*/
+function getWorkspaceRoot(dir, candidateRoot) {
+	if (process.env.NX_WORKSPACE_ROOT) return process.env.NX_WORKSPACE_ROOT;
+	if (dirname(dir) === dir) return candidateRoot;
+	const matches = [
+		join(dir, "nx.json"),
+		join(dir, "nx"),
+		join(dir, "nx.bat")
+	];
+	if (matches.some((x) => fileExists(x))) return dir;
+	else if (fileExists(join(dir, "node_modules", "nx", "package.json"))) return getWorkspaceRoot(dirname(dir), dir);
+	else return getWorkspaceRoot(dirname(dir), candidateRoot);
+}
+/**
+* Returns the most probable filename for the TsConfig.
+*
+* @param dir - The directory into which the tsconfig.json is located.
+* @returns The tsconfig.*.json file
+*/
+function getTsConfigFileName(dir) {
+	return ["tsconfig.base.json", "tsconfig.json"].map((filename) => ({
+		filename,
+		path: join(dir, filename)
+	})).filter(({ path }) => fileExists(path)).map(({ filename }) => filename).at(0);
+}
+/**
+* Checks if a package is within the specified scope.
+*
+* @param name - The name of the package to check.
+* @returns A boolean indicating whether the package is in scope.
+*/
+function isPackageInScope(name) {
+	return isPackageExists(name, { paths: [SCOPE_URL] });
+}
+/**
+* Ensures that the specified packages are installed. If running in a CI environment,
+* or if the terminal is not interactive, or if the current working directory is not in scope,
+* the function will return immediately without doing anything.
+*
+* The function filters out packages that are already in scope and prompts the user to confirm
+* the installation of the remaining packages. If the user confirms, the packages are installed
+* as development dependencies.
+*
+* @param packages - An array of package names (or undefined) to check and install if necessary.
+* @returns A promise that resolves when the operation is complete.
+*/
+async function ensurePackages(packages) {
+	if (process.env.CI || !process.stdout.isTTY || !IS_CWD_IN_SCOPE) return;
+	const nonExistingPackages = packages.filter((i) => i && !isPackageInScope(i));
+	if (nonExistingPackages.length === 0) return;
+	const p = await import("@clack/prompts");
+	const result = await p.confirm({ message: `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(", ")}. Do you want to install them?` });
+	if (result) await import("@antfu/install-pkg").then((i) => i.installPackage(nonExistingPackages, { dev: true }));
+}
+/**
+* Search for the nearest package.json file and return the `name` property value.
+*
+* @param directoryPath - The folder to start from (default to current working directory).
+* @returns The name of the nearest package.json
+*/
+async function findNearestPackageJsonName(directoryPath = resolve()) {
+	try {
+		const packageJsonPath = join(directoryPath, "package.json");
+		const packageJsonData = JSON.parse(await readFile(packageJsonPath, "utf8"));
+		return packageJsonData.name;
+	} catch {
+		const parentDir = dirname(directoryPath);
+		if (directoryPath === parentDir) throw new Error("No package.json file found.");
+		return findNearestPackageJsonName(parentDir);
+	}
+}
+/**
+* Returns the object representation of the configuration or an empty object if it is a boolean.
+*
+* @param options - The {@link CreateConfigOptions} object to extract the sub-options from.
+* @param key - The property name.
+* @returns An object representing the required options.
+*/
+function resolveSubOptions(options, key) {
+	const option = options[key];
+	if (typeof option === "boolean") return {};
+	return option ?? {};
+}
+
+//#endregion
+//#region src/configs/angular.ts
+/**
+* Generates an ESLint configuration for Angular projects.
+*
+* @param options - Configuration options for Angular ESLint.
+* @param options.enableAccessibilityRules - Whether to enable accessibility rules for HTML templates.
+* @param options.tsOverrides - Additional TypeScript rule overrides.
+* @param options.htmlOverrides - Additional HTML rule overrides.
+* @param options.prefix - The prefix to use for Angular component and directive selectors.
+* @returns A promise that resolves to an array of ESLint configurations.
+*/
+async function angular(options = {}) {
+	const angularEslint = await interopDefault(import("angular-eslint"));
+	const { enableAccessibilityRules = true, tsOverrides = {}, htmlOverrides = {}, prefix = "app", ignoreClassNamePatternForInjectableProvidedIn: ignoreClassNamePattern, componentStylesMode = "string", preferOnPushOnly = true, banExperimentalApi = true, banDeveloperPreviewApi = true } = options;
+	return tseslint.config({
+		name: "fabdeh/angular/rules",
+		plugins: { "@angular-eslint": angularEslint.tsPlugin },
+		processor: angularEslint.processInlineTemplates,
+		files: [GLOB_TS],
+		rules: {
+			"max-classes-per-file": ["error", 1],
+			"max-lines": ["error", 400],
+			"new-cap": ["error", { capIsNewExceptions: [
+				"Attribute",
+				"Component",
+				"ContentChild",
+				"ContentChildren",
+				"Directive",
+				"Host",
+				"HostBinding",
+				"HostListener",
+				"Inject",
+				"Injectable",
+				"Input",
+				"NgModule",
+				"Optional",
+				"Output",
+				"Pipe",
+				"Self",
+				"SkipSelf",
+				"ViewChild",
+				"ViewChildren"
+			] }],
+			...angularEslint.configs.tsRecommended.find((c) => c.name === "angular-eslint/ts-recommended")?.rules,
+			"@angular-eslint/component-max-inline-declarations": "error",
+			"@angular-eslint/component-selector": ["error", {
+				type: "element",
+				prefix,
+				style: "kebab-case"
+			}],
+			"@angular-eslint/consistent-component-styles": ["error", componentStylesMode],
+			"@angular-eslint/contextual-decorator": "error",
+			"@angular-eslint/directive-selector": ["error", {
+				type: "attribute",
+				prefix,
+				style: "camelCase"
+			}],
+			"@angular-eslint/no-async-lifecycle-method": "error",
+			"@angular-eslint/no-attribute-decorator": "error",
+			"@angular-eslint/no-conflicting-lifecycle": "error",
+			...banDeveloperPreviewApi ? { "@angular-eslint/no-developer-preview": "error" } : {},
+			"@angular-eslint/no-duplicates-in-metadata-arrays": "error",
+			...banExperimentalApi ? { "@angular-eslint/no-experimental": "error" } : {},
+			"@angular-eslint/no-forward-ref": "error",
+			"@angular-eslint/no-lifecycle-call": "error",
+			"@angular-eslint/no-pipe-impure": "error",
+			"@angular-eslint/no-queries-metadata-property": "error",
+			"@angular-eslint/no-uncalled-signals": "error",
+			"@angular-eslint/prefer-output-emitter-ref": "error",
+			"@angular-eslint/prefer-output-readonly": "error",
+			"@angular-eslint/prefer-signals": "error",
+			...preferOnPushOnly ? { "@angular-eslint/prefer-on-push-component-change-detection": "error" } : {},
+			"@angular-eslint/relative-url-prefix": "error",
+			"@angular-eslint/require-lifecycle-on-prototype": "error",
+			"@angular-eslint/sort-keys-in-type-decorator": "error",
+			"@angular-eslint/sort-lifecycle-methods": "error",
+			"@angular-eslint/use-component-selector": "error",
+			"@angular-eslint/use-component-view-encapsulation": "error",
+			"@angular-eslint/use-injectable-provided-in": ignoreClassNamePattern ? ["error", { ignoreClassNamePattern }] : "error",
+			"@angular-eslint/use-lifecycle-interface": "error",
+			...tsOverrides
+		}
+	}, {
+		name: "fabdeh/angular-template/rules",
+		plugins: { "@angular-eslint/template": angularEslint.templatePlugin },
+		languageOptions: { parser: angularEslint.templateParser },
+		files: [GLOB_HTML],
+		rules: {
+			...angularEslint.configs.templateRecommended.find((c) => c.name === "angular-eslint/template-recommended")?.rules,
+			"@angular-eslint/template/attributes-order": ["error", { alphabetical: true }],
+			"@angular-eslint/template/button-has-type": "error",
+			"@angular-eslint/template/conditional-complexity": "error",
+			"@angular-eslint/template/eqeqeq": ["error", { allowNullOrUndefined: true }],
+			"@angular-eslint/template/no-any": "error",
+			"@angular-eslint/template/no-duplicate-attributes": "error",
+			"@angular-eslint/template/no-interpolation-in-attributes": "error",
+			"@angular-eslint/template/no-positive-tabindex": "error",
+			"@angular-eslint/template/prefer-control-flow": "error",
+			"@angular-eslint/template/prefer-ngsrc": "error",
+			"@angular-eslint/template/prefer-self-closing-tags": "error",
+			"@angular-eslint/template/prefer-static-string-properties": "error",
+			...enableAccessibilityRules ? angularEslint.configs.templateAccessibility.find((c) => c.name === "angular-eslint/template-accessibility")?.rules : {},
+			...htmlOverrides
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/comments.ts
+/**
+* Generates a configuration array for ESLint comments rules.
+*
+* This function returns a configuration array that includes rules for managing
+* ESLint comments in the codebase. It uses the `@eslint-community/eslint-comments`
+* plugin to enforce best practices and prevent common issues with ESLint comments.
+*
+* @returns The configuration array for ESLint comments rules.
+*/
+function comments() {
+	return tseslint.config({
+		name: "fabdeh/comments/rules",
+		files: [GLOB_SRC],
+		plugins: { "@eslint-community/eslint-comments": eslintComments },
+		rules: {
+			"@eslint-community/eslint-comments/disable-enable-pair": ["error", { allowWholeFile: true }],
+			"@eslint-community/eslint-comments/no-aggregating-enable": "error",
+			"@eslint-community/eslint-comments/no-duplicate-disable": "error",
+			"@eslint-community/eslint-comments/no-unlimited-disable": "error",
+			"@eslint-community/eslint-comments/no-unused-disable": "error",
+			"@eslint-community/eslint-comments/no-unused-enable": "error"
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/stylistic.ts
+const STYLISTIC_CONFIG_DEFAULT = {
+	semi: true,
+	arrowParens: true,
+	braceStyle: "1tbs",
+	quoteProps: "as-needed"
+};
+/**
+* Generates a stylistic ESLint configuration.
+*
+* @param [options] - Optional configuration options to customize the stylistic rules.
+* @returns A promise that resolves to an array of ESLint configurations.
+* @example
+* const config = await stylistic({ semi: false });
+*/
+async function stylistic(options = {}) {
+	const stylisticOptions = {
+		...STYLISTIC_CONFIG_DEFAULT,
+		...typeof options.stylistic === "boolean" ? {} : options.stylistic
+	};
+	const stylisticPlugin = await interopDefault(import("@stylistic/eslint-plugin"));
+	const config = stylisticPlugin.configs.customize(stylisticOptions);
+	return tseslint.config({
+		name: "fabdeh/stylistic/rules",
+		files: [GLOB_SRC],
+		plugins: { "@stylistic": stylisticPlugin },
+		rules: {
+			...config.rules,
+			"@stylistic/comma-dangle": ["error", {
+				arrays: "always-multiline",
+				objects: "always-multiline"
+			}],
+			"@stylistic/no-extra-semi": "error",
+			"@stylistic/operator-linebreak": [
+				"error",
+				"after",
+				{ overrides: {
+					"?": "before",
+					":": "before"
+				} }
+			]
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/formatters.ts
+/**
+* Merges the provided Prettier options with any overrides.
+*
+* @param options - The base Prettier options to merge.
+* @param overrides - Optional overrides for the Prettier options.
+* @returns The merged Prettier options.
+*/
+function mergePrettierOptions(options, overrides = {}) {
+	return {
+		...options,
+		...overrides,
+		plugins: [...overrides.plugins ?? [], ...options.plugins ?? []]
+	};
+}
+/**
+* Configures and returns an array of formatters based on the provided options.
+*
+* @param options - The options for configuring the formatters. If set to `true`, default options will be used.
+* @param stylistic - The stylistic options for the formatters.
+* @param hasAngularTemplateParser - Optional argument which indicates whether angular rules already registered the template parser or not.
+* @returns A promise that resolves to a `TypedConfigArray` containing the configured formatters.
+*/
+async function formatters(options = {}, stylistic$1 = {}, hasAngularTemplateParser = false) {
+	if (options === true) {
+		const isPrettierPluginXmlInScope = isPackageInScope("@prettier/plugin-xml");
+		options = {
+			css: true,
+			graphql: true,
+			html: true,
+			markdown: true,
+			slidev: isPackageExists("@slidev/cli"),
+			svg: isPrettierPluginXmlInScope,
+			xml: isPrettierPluginXmlInScope
+		};
+	}
+	await ensurePackages([
+		"eslint-plugin-format",
+		options.markdown && options.slidev ? "prettier-plugin-slidev" : void 0,
+		options.xml || options.svg ? "@prettier/plugin-xml" : void 0
+	]);
+	const { indent, quotes, semi } = {
+		...STYLISTIC_CONFIG_DEFAULT,
+		...stylistic$1
+	};
+	const prettierOptions = {
+		endOfLine: "auto",
+		printWidth: 120,
+		semi,
+		singleQuote: quotes === "single",
+		tabWidth: typeof indent === "number" ? indent : 2,
+		trailingComma: "all",
+		useTabs: indent === "tab",
+		...options.options
+	};
+	const prettierXmlOptions = {
+		xmlQuoteAttributes: "double",
+		xmlSelfClosingSpace: true,
+		xmlSortAttributesByKey: false,
+		xmlWhitespaceSensitivity: "ignore"
+	};
+	const formatPlugin = await interopDefault(import("eslint-plugin-format"));
+	const configs$1 = [{
+		name: "fabdeh/formatter/setup",
+		plugins: { format: formatPlugin }
+	}];
+	if (options.css) configs$1.push({
+		name: "fabdeh/formatter/css",
+		languageOptions: { parser: formatPlugin.parserPlain },
+		files: [GLOB_CSS, GLOB_POSTCSS],
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "css" })] }
+	}, {
+		name: "fabdeh/formatter/scss",
+		languageOptions: { parser: formatPlugin.parserPlain },
+		files: [GLOB_SCSS],
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "scss" })] }
+	}, {
+		name: "fabdeh/formatter/less",
+		languageOptions: { parser: formatPlugin.parserPlain },
+		files: [GLOB_LESS],
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "less" })] }
+	});
+	if (options.html) configs$1.push({
+		name: "fabdeh/formatter/html",
+		...hasAngularTemplateParser ? {} : { languageOptions: { parser: formatPlugin.parserPlain } },
+		files: [GLOB_HTML],
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "html" })] }
+	});
+	if (options.xml) configs$1.push({
+		name: "fabdeh/formatter/xml",
+		languageOptions: { parser: formatPlugin.parserPlain },
+		files: [GLOB_XML],
+		rules: { "format/prettier": ["error", mergePrettierOptions({
+			...prettierXmlOptions,
+			...prettierOptions
+		}, {
+			parser: "xml",
+			plugins: ["@prettier/plugin-xml"]
+		})] }
+	});
+	if (options.svg) configs$1.push({
+		name: "fabdeh/formatter/svg",
+		languageOptions: { parser: formatPlugin.parserPlain },
+		files: [GLOB_SVG],
+		rules: { "format/prettier": ["error", mergePrettierOptions({
+			...prettierXmlOptions,
+			...prettierOptions
+		}, {
+			parser: "xml",
+			plugins: ["@prettier/plugin-xml"]
+		})] }
+	});
+	if (options.markdown) {
+		const GLOB_SLIDEV = options.slidev ? options.slidev === true ? ["**/.slides.md"] : options.slidev.files : [];
+		configs$1.push({
+			name: "fabdeh/formatter/markdown",
+			languageOptions: { parser: formatPlugin.parserPlain },
+			files: [GLOB_MARKDOWN],
+			ignores: GLOB_SLIDEV,
+			rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, {
+				parser: "markdown",
+				embeddedLanguageFormatting: "off"
+			})] }
+		});
+		if (options.slidev) configs$1.push({
+			name: "fabdeh/formatter/slidev",
+			languageOptions: { parser: formatPlugin.parserPlain },
+			files: GLOB_SLIDEV,
+			rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, {
+				embeddedLanguageFormatting: "off",
+				parser: "slidev",
+				plugins: ["prettier-plugin-slidev"]
+			})] }
+		});
+	}
+	if (options.graphql) configs$1.push({
+		name: "fabdeh/formatter/graphql",
+		languageOptions: { parser: formatPlugin.parserPlain },
+		files: [GLOB_GRAPHQL],
+		rules: { "format/prettier": ["error", mergePrettierOptions(prettierOptions, { parser: "graphql" })] }
+	});
+	return tseslint.config(configs$1);
+}
+
+//#endregion
+//#region src/configs/ignore.ts
+/**
+* Generates a configuration array for ESLint with default and user-defined ignore patterns.
+*
+* @param userIgnores - An array of user-defined glob patterns to ignore. Defaults to an empty array.
+* @returns A TypedConfigArray object containing the combined "ignore" patterns.
+*/
+function ignores(userIgnores = []) {
+	return tseslint.config({
+		name: "fabdeh/ignores",
+		ignores: [...GLOB_EXCLUDE, ...userIgnores]
+	});
+}
+
+//#endregion
+//#region src/configs/imports.ts
+/**
+* Generates an ESLint configuration array for import rules.
+*
+* @param options - An object containing stylistic options.
+* @param options.stylistic - A boolean indicating whether to include stylistic rules. Defaults to true.
+* @returns A TypedConfigArray object with the specified import rules.
+*/
+function imports(options = {}) {
+	const { stylistic: stylistic$1 = true } = options;
+	return tseslint.config({
+		name: "fabdeh/imports/rules",
+		files: [GLOB_SRC],
+		plugins: { "import-x": importX },
+		rules: {
+			"import-x/consistent-type-specifier-style": ["error", "prefer-top-level"],
+			"import-x/default": "error",
+			"import-x/export": "error",
+			"import-x/first": "error",
+			"import-x/named": "error",
+			"import-x/no-absolute-path": "error",
+			"import-x/no-deprecated": "error",
+			"import-x/no-duplicates": "error",
+			"import-x/no-empty-named-blocks": "error",
+			"import-x/no-extraneous-dependencies": "error",
+			"import-x/no-mutable-exports": "error",
+			"import-x/no-named-as-default": "warn",
+			"import-x/no-named-as-default-member": "warn",
+			"import-x/no-named-default": "error",
+			"import-x/no-self-import": "error",
+			"import-x/no-useless-path-segments": "error",
+			"import-x/no-webpack-loader-syntax": "error",
+			...stylistic$1 ? { "import-x/newline-after-import": ["error", {
+				considerComments: true,
+				count: 1
+			}] } : {}
+		}
+	}, {
+		name: "fabdeh/imports/ts-disables",
+		files: [GLOB_TS],
+		rules: {
+			"import-x/named": "off",
+			"import-x/no-deprecated": "off"
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/javascript.ts
+/**
+* Generates a configuration array for JavaScript projects with ESLint.
+*
+* This function sets up ESLint configurations for JavaScript projects, including language options,
+* linter options, and specific rules. It supports options for Angular decorators and unused imports
+* handling based on the environment (editor or not).
+*
+* @param options - Configuration options for the JavaScript setup.
+* @param options.overrides - Additional rule overrides.
+* @returns A configuration array for ESLint.
+* @example
+* ```typescript
+* const config = javascript();
+* ```
+*/
+function javascript(options = {}) {
+	const { overrides = {} } = options;
+	return tseslint.config({
+		name: "fabdeh/javascript/setup",
+		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: "error" }
+	}, {
+		name: "fabdeh/javascript/rules",
+		files: [GLOB_SRC],
+		plugins: {
+			"@typescript-eslint": tseslint.plugin,
+			"prefer-arrow-functions": preferArrowFunctions,
+			"unused-imports": unusedImports
+		},
+		rules: {
+			...eslint.configs.recommended.rules,
+			"accessor-pairs": "error",
+			"array-callback-return": "error",
+			"block-scoped-var": "error",
+			"default-case-last": "error",
+			"dot-notation": "error",
+			eqeqeq: "error",
+			"id-denylist": [
+				"error",
+				"any",
+				"Number",
+				"number",
+				"String",
+				"string",
+				"Boolean",
+				"boolean",
+				"Undefined",
+				"undefined"
+			],
+			"new-cap": "error",
+			"no-alert": "error",
+			"no-caller": "error",
+			"no-cond-assign": ["error", "always"],
+			"no-console": ["error", { allow: ["warn", "error"] }],
+			"no-empty": ["error", { allowEmptyCatch: true }],
+			"no-eval": "error",
+			"no-extend-native": "error",
+			"no-extra-bind": "error",
+			"no-implied-eval": "error",
+			"no-iterator": "error",
+			"no-labels": "error",
+			"no-lone-blocks": "error",
+			"no-lonely-if": "error",
+			"no-multi-str": "error",
+			"no-new": "error",
+			"no-new-func": "error",
+			"no-new-wrappers": "error",
+			"no-octal-escape": "error",
+			"no-plusplus": ["error", { allowForLoopAfterthoughts: true }],
+			"no-proto": "error",
+			"no-self-compare": "error",
+			"no-sequences": "error",
+			"no-template-curly-in-string": "error",
+			"no-throw-literal": "error",
+			"no-undef-init": "error",
+			"no-unmodified-loop-condition": "error",
+			"no-unneeded-ternary": ["error", { defaultAssignment: false }],
+			"no-unreachable-loop": "error",
+			"no-unused-expressions": ["error", {
+				allowShortCircuit: true,
+				allowTaggedTemplates: true,
+				allowTernary: true
+			}],
+			"no-use-before-define": ["error", {
+				classes: false,
+				functions: false
+			}],
+			"no-useless-call": "error",
+			"no-useless-computed-key": "error",
+			"no-useless-constructor": "error",
+			"no-useless-rename": "error",
+			"no-useless-return": "error",
+			"no-var": "error",
+			"object-shorthand": [
+				"error",
+				"always",
+				{
+					avoidQuotes: true,
+					ignoreConstructors: false
+				}
+			],
+			"prefer-arrow-callback": "error",
+			"prefer-arrow-functions/prefer-arrow-functions": ["error", {
+				singleReturnOnly: true,
+				allowNamedFunctions: true
+			}],
+			"prefer-const": "error",
+			"prefer-exponentiation-operator": "error",
+			"prefer-object-spread": "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"],
+			"unused-imports/no-unused-imports": "error",
+			"no-unused-vars": "off",
+			"unused-imports/no-unused-vars": ["error", {
+				args: "after-used",
+				argsIgnorePattern: "^_",
+				ignoreRestSiblings: true,
+				vars: "all",
+				varsIgnorePattern: "^_"
+			}],
+			"use-isnan": ["error", { enforceForIndexOf: true }],
+			"valid-typeof": ["error", { requireStringLiterals: true }],
+			"vars-on-top": "error",
+			yoda: [
+				"error",
+				"never",
+				{ exceptRange: true }
+			],
+			"@typescript-eslint/ban-ts-comment": "error",
+			"@typescript-eslint/no-extra-non-null-assertion": "error",
+			"@typescript-eslint/no-misused-new": "error",
+			"@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+			"@typescript-eslint/no-require-imports": ["error", { allowAsImport: true }],
+			"@typescript-eslint/no-this-alias": "error",
+			...overrides
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/jsdoc.ts
+/**
+* Get the JSDoc rules based on specific parameters.
+*
+* @param level - The level of (mostly) all rules.
+* @param stylistic - Does the stylistic rules be included.
+* @param mode - To get on JS or TS rules or both.
+* @returns The JSDoc eslint rules configured with the requested level.
+*/
+function getJsDocRules(level, stylistic$1, mode) {
+	return {
+		...mode === "both" || mode === "jsOnly" ? {
+			"jsdoc/check-access": level,
+			"jsdoc/check-param-names": level,
+			"jsdoc/check-property-names": level,
+			"jsdoc/check-tag-names": level,
+			"jsdoc/check-types": level,
+			"jsdoc/check-values": level,
+			"jsdoc/empty-tags": level,
+			"jsdoc/implements-on-classes": level,
+			"jsdoc/no-defaults": level,
+			"jsdoc/no-undefined-types": level,
+			"jsdoc/require-jsdoc": level,
+			"jsdoc/require-param": level,
+			"jsdoc/require-param-description": level,
+			"jsdoc/require-param-name": level,
+			"jsdoc/require-param-type": level,
+			"jsdoc/require-property": level,
+			"jsdoc/require-property-description": level,
+			"jsdoc/require-property-name": level,
+			"jsdoc/require-property-type": level,
+			"jsdoc/require-returns": level,
+			"jsdoc/require-returns-check": level,
+			"jsdoc/require-returns-description": level,
+			"jsdoc/require-returns-type": level,
+			"jsdoc/require-yields": level,
+			"jsdoc/require-yields-check": level,
+			"jsdoc/valid-types": level,
+			...stylistic$1 ? {
+				"jsdoc/check-alignment": level,
+				"jsdoc/multiline-blocks": level,
+				"jsdoc/no-multi-asterisks": level,
+				"jsdoc/require-asterisk-prefix": level,
+				"jsdoc/require-hyphen-before-param-description": level,
+				"jsdoc/tag-lines": [
+					level,
+					"never",
+					{ startLines: 1 }
+				]
+			} : {}
+		} : {},
+		...mode === "both" || mode === "tsOnly" ? {
+			"jsdoc/check-tag-names": [level, { typed: true }],
+			"jsdoc/no-types": level,
+			"jsdoc/no-undefined-types": "off",
+			"jsdoc/require-param-type": "off",
+			"jsdoc/require-property-type": "off",
+			"jsdoc/require-returns-type": "off"
+		} : {}
+	};
+}
+/**
+* Generates a configuration array for JSDoc rules.
+*
+* @param options - An object containing stylistic options.
+* @param options.stylistic - A boolean indicating whether to include stylistic rules. Defaults to true.
+* @returns A configuration array for JSDoc rules.
+*/
+function jsdoc(options = {}) {
+	const { stylistic: stylistic$1 = true } = options;
+	return tseslint.config({
+		name: "fabdeh/jsdoc/rules",
+		files: [GLOB_SRC],
+		plugins: { jsdoc: jsdocPlugin },
+		rules: getJsDocRules("warn", !!stylistic$1, "jsOnly")
+	}, {
+		name: "fabdeh/jsdoc/ts-only/rules",
+		files: [GLOB_TS],
+		rules: getJsDocRules("warn", !!stylistic$1, "tsOnly")
+	});
+}
+
+//#endregion
+//#region src/configs/jsonc.ts
+/**
+* Generates an ESLint configuration for JSONC files.
+*
+* @param options - Configuration options for the JSONC setup.
+* @param options.files - An array of glob patterns to specify the JSONC files to lint. Defaults to `[GLOB_JSON, GLOB_JSON5, GLOB_JSONC]`.
+* @param options.overrides - Additional rules or configurations to override the default settings.
+* @param options.stylistic - A boolean or object to enable or configure stylistic rules. Defaults to `true`.
+* @returns A promise that resolves to a `TypedConfigArray` containing the ESLint configuration.
+* @example
+* ```typescript
+* const config = await jsonc({
+*   files: ['**\/*.json'],
+*   stylistic: {
+*     indent: 4,
+*   },
+* });
+* ```
+*/
+async function jsonc(options = {}) {
+	const { files = [
+		GLOB_JSON,
+		GLOB_JSON5,
+		GLOB_JSONC
+	], overrides = {}, stylistic: stylistic$1 = true } = options;
+	const { indent = 2 } = typeof stylistic$1 === "object" ? stylistic$1 : {};
+	const [jsoncPlugin, jsoncParser] = await Promise.all([interopDefault(import("eslint-plugin-jsonc")), interopDefault(import("jsonc-eslint-parser"))]);
+	return tseslint.config({
+		name: "fabdeh/jsonc/setup",
+		plugins: { jsonc: jsoncPlugin }
+	}, {
+		name: "fabdeh/jsonc/rules",
+		languageOptions: { parser: jsoncParser },
+		files,
+		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",
+			...stylistic$1 ? {
+				"jsonc/array-bracket-spacing": ["error", "never"],
+				"jsonc/comma-dangle": ["error", "never"],
+				"jsonc/comma-style": ["error", "last"],
+				"jsonc/indent": ["error", indent],
+				"jsonc/key-spacing": ["error", {
+					afterColon: true,
+					beforeColon: false
+				}],
+				"jsonc/object-curly-newline": ["error", {
+					consistent: true,
+					multiline: true
+				}],
+				"jsonc/object-curly-spacing": ["error", "always"],
+				"jsonc/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
+				"jsonc/quote-props": "error",
+				"jsonc/quotes": "error"
+			} : {},
+			...overrides
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/markdown.ts
+/**
+* Configures ESLint for Markdown files.
+*
+* This function sets up ESLint configurations specifically for Markdown files,
+* including custom parsers, plugins, processors, and rule overrides.
+*
+* @param options - An object containing file and override options.
+* @param options.files - An array of glob patterns to specify the Markdown files to lint.
+* @param options.overrides - An object containing rule overrides.
+* @returns A promise that resolves to a TypedConfigArray containing the ESLint configurations.
+* @example
+* ```typescript
+* const config = await markdown({
+*   files: ['**\/*.md'],
+*   overrides: {
+*     'no-console': 'warn',
+*   },
+* });
+* ```
+*/
+async function markdown(options = {}) {
+	const { files = [GLOB_MARKDOWN], overrides = {} } = options;
+	const markdownPlugin = await interopDefault(import("@eslint/markdown"));
+	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: [] }
+		})
+	};
+	return tseslint.config({
+		name: "fabdeh/markdown/setup",
+		plugins: { markdown: markdownPlugin }
+	}, {
+		name: "fabdeh/markdown/processor",
+		files,
+		ignores: [GLOB_MARKDOWN_IN_MARKDOWN],
+		processor: mergeProcessors([markdownPlugin.processors.markdown, processorPassThrough])
+	}, {
+		name: "fabdeh/markdown/parser",
+		files,
+		languageOptions: { parser: parserPlain }
+	}, {
+		name: "fabdeh/markdown/disables",
+		languageOptions: { parserOptions: { ecmaFeatures: { impliedStrict: true } } },
+		files: [GLOB_MARKDOWN_CODE],
+		rules: {
+			...tseslint.configs.disableTypeChecked.rules,
+			"import-x/newline-after-import": "off",
+			"no-alert": "off",
+			"no-console": "off",
+			"no-labels": "off",
+			"no-lone-blocks": "off",
+			"no-restricted-syntax": "off",
+			"no-undef": "off",
+			"no-unused-expressions": "off",
+			"no-unused-labels": "off",
+			"no-unused-vars": "off",
+			"@stylistic/comma-dangle": "off",
+			"@stylistic/eol-last": "off",
+			"@typescript-eslint/consistent-type-imports": "off",
+			"@typescript-eslint/explicit-function-return-type": "off",
+			"@typescript-eslint/no-namespace": "off",
+			"@typescript-eslint/no-redeclare": "off",
+			"@typescript-eslint/no-require-imports": "off",
+			"@typescript-eslint/no-unused-expressions": "off",
+			"@typescript-eslint/no-unused-vars": "off",
+			"@typescript-eslint/no-use-before-define": "off",
+			"unicode-bom": "off",
+			"unused-imports/no-unused-imports": "off",
+			"unused-imports/no-unused-vars": "off",
+			...overrides
+		}
+	}, {
+		name: "fabdeh/markdown/rules",
+		files,
+		rules: {
+			...markdownPlugin.configs.recommended.at(0)?.rules,
+			"markdown/no-duplicate-headings": "error"
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/rules-configs/naming-convention.ts
+/**
+* Retrieves the default @typescript-eslint/naming-convention rule configuration based on Google TypeScript Style Guide.
+*
+* @param strict -- When `true`, use "strictCamelCase" and "StrictPascalCase" instead of the more relaxed "camelCase" and "PascalCase".
+* @param allowJsx -- Allow or not to use "PascalCase" for functions.
+* @returns The default naming convention rule configuration.
+*/
+function namingConvention(strict, allowJsx = false) {
+	return [
+		{
+			selector: "default",
+			format: [strict ? "strictCamelCase" : "camelCase"],
+			leadingUnderscore: "forbid",
+			trailingUnderscore: "forbid"
+		},
+		{
+			selector: "typeLike",
+			format: [strict ? "StrictPascalCase" : "PascalCase"]
+		},
+		{
+			selector: "variable",
+			format: [strict ? "strictCamelCase" : "camelCase", "UPPER_CASE"]
+		},
+		{
+			selector: "function",
+			format: allowJsx ? [strict ? "strictCamelCase" : "camelCase", strict ? "StrictPascalCase" : "PascalCase"] : [strict ? "strictCamelCase" : "camelCase"]
+		},
+		{
+			selector: "variable",
+			modifiers: ["const", "global"],
+			format: ["UPPER_CASE"]
+		},
+		{
+			selector: "enumMember",
+			format: ["UPPER_CASE"]
+		},
+		{
+			selector: "classProperty",
+			modifiers: ["static", "readonly"],
+			format: ["UPPER_CASE"]
+		},
+		{
+			selector: "memberLike",
+			modifiers: ["requiresQuotes"],
+			format: null
+		},
+		{
+			selector: "parameter",
+			modifiers: ["unused"],
+			format: [strict ? "strictCamelCase" : "camelCase"],
+			leadingUnderscore: "allow"
+		},
+		{
+			selector: "variable",
+			modifiers: ["destructured"],
+			format: null
+		},
+		{
+			selector: "import",
+			modifiers: ["default", "namespace"],
+			format: [strict ? "strictCamelCase" : "camelCase", strict ? "StrictPascalCase" : "PascalCase"]
+		},
+		{
+			selector: "interface",
+			format: [strict ? "StrictPascalCase" : "PascalCase"],
+			custom: {
+				regex: "^I[A-Z]",
+				match: false
+			}
+		}
+	];
+}
+
+//#endregion
+//#region src/configs/ngrx.ts
+const DEFAULT_STORE_GLOB = [
+	`**/*.actions.${GLOB_TS_EXT}`,
+	`**/*.feature.${GLOB_TS_EXT}`,
+	`**/*.reducer.${GLOB_TS_EXT}`,
+	`**/*.state.${GLOB_TS_EXT}`
+];
+const DEFAULT_EFFECTS_GLOB = [`**/*.effects.${GLOB_TS_EXT}`];
+const DEFAULT_SIGNALS_GLOB = [`**/*.store.${GLOB_TS_EXT}`];
+/**
+* Generates an ESLint configuration array for NgRx based on the provided options.
+*
+* @param [options] - The options to configure NgRx rules.
+* @param [options.store] - If true or an object, includes NgRx store rules.
+* @param [options.effects] - If true or an object, includes NgRx effects rules.
+* @param [options.signals] - If true or an object, includes NgRx signals rules.
+* @returns A promise that resolves to the ESLint configuration array.
+* @example
+* // Basic usage
+* const config = await ngrx();
+* @example
+* ```ts
+* // With custom options
+* const config = await ngrx({
+*   store: { files: ['**\/*.store.ts'] },
+*   effects: { files: ['**\/*.effects.ts'] },
+*   signals: { files: ['**\/*.signals.ts'] }
+* });
+* ```
+*/
+async function ngrx(options = {}) {
+	const ngrxPlugin = await interopDefault(import("@ngrx/eslint-plugin/v9"));
+	const { store = isPackageExists("@ngrx/store"), effects = isPackageExists("@ngrx/effects"), signals = isPackageExists("@ngrx/signals"), useRelaxedNamingConventionForCamelAndPascalCases = false } = options;
+	const configs$1 = [];
+	let addOperatorsRules = false;
+	const ngrxOperatorsFiles = [];
+	if (store) {
+		const { files = DEFAULT_STORE_GLOB, enforceOperatorsRules = isPackageExists("@ngrx/operators"), overrides = {} } = typeof store === "object" ? store : {};
+		addOperatorsRules ||= enforceOperatorsRules;
+		ngrxOperatorsFiles.push(files);
+		configs$1.push({
+			name: "fabdeh/ngrx-store/rules",
+			files,
+			plugins: { "@ngrx": ngrxPlugin },
+			rules: {
+				...ngrxPlugin.configs.store.find((c) => c.name === "ngrx/store")?.rules,
+				"@typescript-eslint/naming-convention": [
+					"error",
+					...namingConvention(!useRelaxedNamingConventionForCamelAndPascalCases),
+					{
+						selector: ["objectLiteralProperty"],
+						format: null,
+						custom: {
+							regex: String.raw`^(?:(?:[a-z]+(?:[A-Z][a-z]*)*)|[A-Z][a-z]*(?:\s[A-Z][a-z]*)*)$`,
+							match: true
+						}
+					},
+					{
+						selector: "variable",
+						modifiers: [
+							"const",
+							"global",
+							"exported"
+						],
+						format: ["camelCase", "PascalCase"],
+						leadingUnderscore: "forbid",
+						trailingUnderscore: "forbid"
+					}
+				],
+				...overrides
+			}
+		});
+	}
+	if (effects) {
+		const { files = DEFAULT_EFFECTS_GLOB, enforceOperatorsRules = isPackageExists("@ngrx/operators"), overrides = {} } = typeof effects === "object" ? effects : {};
+		addOperatorsRules ||= enforceOperatorsRules;
+		ngrxOperatorsFiles.push(files);
+		configs$1.push({
+			name: "fabdeh/ngrx-effects/rules",
+			files,
+			plugins: { "@ngrx": ngrxPlugin },
+			rules: {
+				...ngrxPlugin.configs.effects.find((c) => c.name === "ngrx/effects")?.rules,
+				"@typescript-eslint/naming-convention": [
+					"error",
+					...namingConvention(!useRelaxedNamingConventionForCamelAndPascalCases),
+					{
+						selector: "variable",
+						modifiers: [
+							"const",
+							"global",
+							"exported"
+						],
+						format: ["camelCase"],
+						leadingUnderscore: "forbid",
+						trailingUnderscore: "forbid",
+						suffix: ["$"]
+					}
+				],
+				...overrides
+			}
+		});
+	}
+	if (signals) {
+		const { files = DEFAULT_SIGNALS_GLOB, enforceOperatorsRules = isPackageExists("@ngrx/operators"), overrides = {} } = typeof signals === "object" ? signals : {};
+		addOperatorsRules ||= enforceOperatorsRules;
+		ngrxOperatorsFiles.push(files);
+		configs$1.push({
+			name: "fabdeh/ngrx-signals/rules",
+			files,
+			plugins: { "@ngrx": ngrxPlugin },
+			rules: {
+				...ngrxPlugin.configs.signals.find((c) => c.name === "ngrx/signals")?.rules,
+				"@typescript-eslint/naming-convention": [
+					"error",
+					...namingConvention(!useRelaxedNamingConventionForCamelAndPascalCases),
+					{
+						selector: ["objectLiteralProperty", "objectLiteralMethod"],
+						format: ["camelCase"],
+						leadingUnderscore: "allow"
+					},
+					{
+						selector: "variable",
+						modifiers: [
+							"const",
+							"global",
+							"exported"
+						],
+						format: ["PascalCase"],
+						leadingUnderscore: "forbid",
+						trailingUnderscore: "forbid",
+						suffix: ["Store"]
+					}
+				],
+				...overrides
+			}
+		});
+	}
+	if (addOperatorsRules) configs$1.push({
+		name: "fabdeh/ngrx-operators/rules",
+		files: [...ngrxOperatorsFiles],
+		plugins: { "@ngrx": ngrxPlugin },
+		rules: { ...ngrxPlugin.configs.operators.find((c) => c.name === "ngrx/operators")?.rules }
+	});
+	return tseslint.config(configs$1);
+}
+
+//#endregion
+//#region src/configs/node.ts
+/**
+* Generates an array containing configuration settings for Node.js-specific rules and plugins.
+*
+* @returns An array defining Node.js rules, plugins, and their configurations.
+*/
+function node() {
+	return tseslint.config({
+		name: "fabdeh/node/rules",
+		files: [GLOB_SRC],
+		plugins: { n: nodePlugin },
+		rules: {
+			"n/handle-callback-err": ["error", "^(err|error)$"],
+			"n/no-callback-literal": "error",
+			"n/no-deprecated-api": "error",
+			"n/no-exports-assign": "error",
+			"n/no-new-require": "error",
+			"n/no-path-concat": "error",
+			"n/prefer-global/buffer": ["error", "never"],
+			"n/prefer-global/process": ["error", "never"],
+			"n/prefer-promises/dns": "error",
+			"n/prefer-promises/fs": "error",
+			"n/process-exit-as-throw": "error"
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/rules-configs/perfectionist-groups.ts
+const SORT_IMPORT_GROUPS = [
+	"type",
+	{ newlinesBetween: "never" },
+	"builtin-type",
+	{ newlinesBetween: "never" },
+	"external-type",
+	{ newlinesBetween: "never" },
+	"internal-type",
+	{ newlinesBetween: "never" },
+	"parent-type",
+	{ newlinesBetween: "never" },
+	"sibling-type",
+	{ newlinesBetween: "never" },
+	"index-type",
+	{ newlinesBetween: "always" },
+	"builtin",
+	{ newlinesBetween: "always" },
+	"external",
+	{ newlinesBetween: "always" },
+	"internal",
+	{ newlinesBetween: "always" },
+	"parent",
+	{ newlinesBetween: "never" },
+	"sibling",
+	{ newlinesBetween: "never" },
+	"index",
+	{ newlinesBetween: "always" },
+	"side-effect",
+	{ newlinesBetween: "always" },
+	"object",
+	{ newlinesBetween: "always" },
+	"unknown"
+];
+const SORT_UNION_OR_INTERSECTION_GROUPS = [
+	"named",
+	"keyword",
+	"operator",
+	"literal",
+	"function",
+	"import",
+	"conditional",
+	"object",
+	"tuple",
+	"intersection",
+	"union",
+	"nullish",
+	"unknown"
+];
+
+//#endregion
+//#region src/configs/perfectionist.ts
+/**
+* Generates a configuration array for the "perfectionist" ESLint plugin.
+*
+* This configuration includes rules for sorting various elements in the codebase
+* such as exports, imports, intersection types, named exports, named imports,
+* switch cases, and union types. The sorting order is set to "ascending" and the
+* type is natural.
+*
+* @returns The configuration array for the "perfectionist" plugin.
+* @see https://github.com/azat-io/eslint-plugin-perfectionist
+*/
+async function perfectionist() {
+	const rootDir = await findNearestPackageJsonName() === "@fabdeh/eslint-config" ? void 0 : getWorkspaceRoot(process.cwd(), process.cwd());
+	return tseslint.config({
+		name: "fabdeh/perfectionist/rules",
+		files: [GLOB_SRC],
+		plugins: { perfectionist: perfectionistPlugin },
+		rules: {
+			"perfectionist/sort-exports": ["error", {
+				order: "asc",
+				type: "natural"
+			}],
+			"perfectionist/sort-imports": ["error", {
+				groups: SORT_IMPORT_GROUPS,
+				tsconfig: rootDir ? {
+					rootDir,
+					filename: getTsConfigFileName(rootDir)
+				} : void 0,
+				order: "asc",
+				type: "natural",
+				newlinesBetween: "never"
+			}],
+			"perfectionist/sort-intersection-types": ["error", {
+				groups: SORT_UNION_OR_INTERSECTION_GROUPS,
+				order: "asc",
+				type: "natural"
+			}],
+			"perfectionist/sort-named-exports": ["error", {
+				order: "asc",
+				type: "natural"
+			}],
+			"perfectionist/sort-named-imports": ["error", {
+				order: "asc",
+				type: "natural"
+			}],
+			"perfectionist/sort-switch-case": ["error", {
+				order: "asc",
+				type: "natural"
+			}],
+			"perfectionist/sort-union-types": ["error", {
+				groups: SORT_UNION_OR_INTERSECTION_GROUPS,
+				order: "asc",
+				type: "natural"
+			}]
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/pnpm.ts
+/**
+* Generates an array containing configuration settings for PNPM workspace-specific rules and plugins.
+*
+* @returns An array defining PNPM workspace rules, plugins, and their configurations.
+*/
+async function pnpm() {
+	const [pluginPnpm, yamlParser, jsoncParser] = await Promise.all([
+		interopDefault(import("eslint-plugin-pnpm")),
+		interopDefault(import("yaml-eslint-parser")),
+		interopDefault(import("jsonc-eslint-parser"))
+	]);
+	return tseslint.config({
+		name: "fabdeh/pnpm/package-json",
+		files: ["package.json", "**/package.json"],
+		languageOptions: { parser: jsoncParser },
+		plugins: { pnpm: pluginPnpm },
+		rules: {
+			"pnpm/json-enforce-catalog": "error",
+			"pnpm/json-prefer-workspace-settings": "error",
+			"pnpm/json-valid-catalog": "error"
+		}
+	}, {
+		name: "fabdeh/pnpm/pnpm-workspace-yaml",
+		files: ["pnpm-workspace.yaml"],
+		languageOptions: { parser: yamlParser },
+		plugins: { pnpm: pluginPnpm },
+		rules: {
+			"pnpm/yaml-no-duplicate-catalog-item": "error",
+			"pnpm/yaml-no-unused-catalog-item": "error"
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/regexp.ts
+/**
+* Configure the recommended regexp rules.
+*
+* @param options - The options
+* @returns The ESLint configuration for regexp linting
+*/
+function regexp(options = {}) {
+	const { level, overrides } = options;
+	const config = configs["flat/recommended"];
+	const rules = Object.fromEntries(Object.entries(config.rules).map(([ruleName, ruleLevel]) => [ruleName, level === "warn" ? level : ruleLevel]));
+	return tseslint.config({
+		name: "fabdeh/regexp/rules",
+		files: [GLOB_SRC],
+		plugins: { ...config.plugins },
+		rules: {
+			...rules,
+			...overrides
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/sort.ts
+/**
+* Configures ESLint rules for sorting keys and array values in `package.json` files.
+*
+* This function returns a configuration array that enforces specific sorting rules
+* for various sections of `package.json` files. The rules include:
+* - Sorting array values in ascending order for the `files` field.
+* - Sorting keys in a predefined order for the root level of `package.json`.
+* - Sorting dependency fields (`dependencies`, `devDependencies`, `peerDependencies`, etc.) in ascending order.
+* - Sorting specific fields within the `exports` section.
+* - Sorting client hooks in a predefined order for `gitHooks`, `husky`, and `simple-git-hooks`.
+*
+* @returns The ESLint configuration array with sorting rules.
+*/
+function sortPackageJson() {
+	return tseslint.config({
+		name: "fabdeh/sort/package-json",
+		files: ["**/package.json"],
+		rules: {
+			"jsonc/sort-array-values": ["error", {
+				order: { type: "asc" },
+				pathPattern: "^files$"
+			}],
+			"jsonc/sort-keys": [
+				"error",
+				{
+					order: [
+						"publisher",
+						"name",
+						"displayName",
+						"type",
+						"version",
+						"private",
+						"packageManager",
+						"description",
+						"author",
+						"contributors",
+						"license",
+						"funding",
+						"homepage",
+						"repository",
+						"bugs",
+						"keywords",
+						"categories",
+						"sideEffects",
+						"exports",
+						"main",
+						"module",
+						"unpkg",
+						"jsdelivr",
+						"types",
+						"typesVersions",
+						"bin",
+						"icon",
+						"files",
+						"engines",
+						"activationEvents",
+						"contributes",
+						"scripts",
+						"peerDependencies",
+						"peerDependenciesMeta",
+						"dependencies",
+						"optionalDependencies",
+						"devDependencies",
+						"pnpm",
+						"overrides",
+						"resolutions",
+						"husky",
+						"simple-git-hooks",
+						"lint-staged",
+						"nano-staged",
+						"eslintConfig",
+						"config"
+					],
+					pathPattern: "^$"
+				},
+				{
+					order: { type: "asc" },
+					pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$"
+				},
+				{
+					order: { type: "asc" },
+					pathPattern: "^(?:resolutions|overrides|pnpm.overrides)$"
+				},
+				{
+					order: [
+						"types",
+						"import",
+						"require",
+						"default"
+					],
+					pathPattern: "^exports.*$"
+				},
+				{
+					order: [
+						"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)$"
+				}
+			]
+		}
+	});
+}
+/**
+* Generates a TypeScript ESLint configuration array that enforces sorting rules for `tsconfig.json` files.
+*
+* The configuration includes rules to:
+* - Sort the top-level keys of `tsconfig.json` files in a specific order.
+* - Sort the keys within the `compilerOptions` section of `tsconfig.json` files in a specific order.
+*
+* @returns The TypeScript ESLint configuration array with sorting rules.
+*/
+function sortTsConfig() {
+	return tseslint.config({
+		name: "fabdeh/sort/tsconfig-json",
+		files: ["**/tsconfig.json", "**/tsconfig.*.json"],
+		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",
+					"isolatedDeclarations",
+					"isolatedModules",
+					"preserveSymlinks",
+					"verbatimModuleSyntax",
+					"skipDefaultLibCheck",
+					"skipLibCheck"
+				],
+				pathPattern: "^compilerOptions$"
+			}
+		] }
+	});
+}
+
+//#endregion
+//#region src/configs/tailwindcss.ts
+/**
+* Generates an ESLint configuration array for Tailwind CSS using better-tailwindcss plugin.
+*
+* @param [options] - Optional overrides for the configuration.
+* @returns  A promise that resolves to the ESLint configuration array.
+* @example
+* const config = await tailwindcss({
+*   enableAllRules: true,
+*   overrides: {
+*     'better-tailwindcss/recommended': 'warn',
+*   },
+* });
+*/
+async function tailwindcss(options = {}) {
+	await ensurePackages(["eslint-plugin-better-tailwindcss"]);
+	const betterTailwindcssPlugin = await interopDefault(import("eslint-plugin-better-tailwindcss"));
+	const { files: filesGlob, overrides, enableAllRules, parsers,...settings } = options;
+	let files;
+	let parserConfigs;
+	if (parsers) {
+		files = { files: [...new Set(Object.keys(parsers))] };
+		parserConfigs = Object.entries(parsers).map(([glob, parser], index) => ({
+			name: `fabdeh/tailwindcss/parser-${index + 1}`,
+			files: [glob],
+			languageOptions: { parser }
+		}));
+	} else {
+		files = { files: filesGlob ?? [GLOB_SRC, GLOB_HTML] };
+		parserConfigs = [];
+	}
+	return tseslint.config(...parserConfigs, {
+		name: "@fabdeh/tailwindcss/rules",
+		...files,
+		plugins: { "better-tailwindcss": betterTailwindcssPlugin },
+		settings: { "better-tailwindcss": settings },
+		rules: {
+			...betterTailwindcssPlugin.configs.recommended?.rules,
+			...enableAllRules ? {
+				"better-tailwindcss/enforce-consistent-variable-syntax": "warn",
+				"better-tailwindcss/no-conflicting-classes": "error",
+				"better-tailwindcss/no-restricted-classes": "error"
+			} : {}
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/toml.ts
+/**
+* Generates an ESLint configuration for TOML files.
+*
+* @param options -  The configuration options.
+* @param options.files - The glob patterns for the files to lint.
+* @param options.overrides - The rules to override the default configuration.
+* @param options.stylistic - Whether to apply stylistic rules or a configuration object for stylistic rules.
+* @param options.stylistic.indent - The indentation style for stylistic rules.
+* @returns A promise that resolves to the ESLint configuration array.
+*/
+async function toml(options = {}) {
+	const { files = [GLOB_TOML], overrides = {}, stylistic: stylistic$1 = true } = options;
+	const { indent = 2 } = typeof stylistic$1 === "object" ? stylistic$1 : {};
+	const [tomlPlugin, tomlParser] = await Promise.all([interopDefault(import("eslint-plugin-toml")), interopDefault(import("toml-eslint-parser"))]);
+	return tseslint.config({
+		name: "fabdeh/toml/setup",
+		plugins: { toml: tomlPlugin }
+	}, {
+		name: "fabdeh/toml/rules",
+		languageOptions: { parser: tomlParser },
+		files,
+		rules: {
+			"@stylistic/spaced-comment": "off",
+			"toml/comma-style": "error",
+			"toml/keys-order": "error",
+			"toml/no-space-dots": "error",
+			"toml/no-unreadable-number-separator": "error",
+			"toml/precision-of-fractional-seconds": "error",
+			"toml/precision-of-integer": "error",
+			"toml/tables-order": "error",
+			"toml/vue-custom-block/no-parsing-error": "error",
+			...stylistic$1 ? {
+				"toml/array-bracket-newline": "error",
+				"toml/array-bracket-spacing": "error",
+				"toml/array-element-newline": "error",
+				"toml/indent": ["error", indent === "tab" ? 2 : indent],
+				"toml/inline-table-curly-spacing": "error",
+				"toml/key-spacing": "error",
+				"toml/padding-line-between-pairs": "error",
+				"toml/padding-line-between-tables": "error",
+				"toml/quoted-keys": "error",
+				"toml/spaced-comment": "error",
+				"toml/table-bracket-spacing": "error"
+			} : {},
+			...overrides
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/rules-configs/member-ordering.ts
+const MEMBER_ORDERING_OPTIONS = { default: [
+	"signature",
+	"#private-field",
+	"private-field",
+	"protected-field",
+	"public-field",
+	[
+		"#private-accessor",
+		"#private-get",
+		"#private-set"
+	],
+	[
+		"private-accessor",
+		"private-get",
+		"private-set"
+	],
+	[
+		"protected-accessor",
+		"protected-get",
+		"protected-set"
+	],
+	[
+		"public-accessor",
+		"public-get",
+		"public-set"
+	],
+	"static-initialization",
+	"constructor",
+	"call-signature",
+	"public-method",
+	"protected-method",
+	"private-method",
+	"#private-method"
+] };
+
+//#endregion
+//#region src/configs/typescript.ts
+/**
+* Generates a TypeScript ESLint configuration.
+*
+* @param options - Configuration options that include overrides, stylistic preferences, and parser options.
+* @param options.stylistic - A boolean indicating whether stylistic rules should be included. Defaults to true.
+* @param options.parserOptions - Options for the TypeScript parser.
+* @param options.overrides - Additional rule overrides.
+* @returns A TypedConfigArray containing the TypeScript ESLint configuration.
+*/
+async function typescript(options = {}) {
+	const { stylistic: stylistic$1 = true, parserOptions = {}, overrides = {}, enableErasableSyntaxOnly = false, useRelaxedNamingConventionForCamelAndPascalCases = false, type = "app" } = options;
+	let erasableSyntaxOnlyPlugin;
+	let erasableSyntaxOnlyRules;
+	if (enableErasableSyntaxOnly) {
+		await ensurePackages(["eslint-plugin-erasable-syntax-only"]);
+		const erasableSyntaxOnly = await interopDefault(import("eslint-plugin-erasable-syntax-only"));
+		erasableSyntaxOnlyPlugin = erasableSyntaxOnly;
+		erasableSyntaxOnlyRules = erasableSyntaxOnly.configs.recommended.rules;
+	}
+	const tsconfigRootDir = getWorkspaceRoot(process.cwd(), process.cwd());
+	const defaultProject = getTsConfigFileName(tsconfigRootDir);
+	return tseslint.config({
+		name: "fabdeh/typescript/setup",
+		files: [GLOB_TS],
+		ignores: [`${GLOB_MARKDOWN}/**`],
+		languageOptions: {
+			parser: tseslint.parser,
+			parserOptions: {
+				sourceType: "module",
+				projectService: {
+					allowDefaultProject: ["*.js"],
+					defaultProject
+				},
+				tsconfigRootDir,
+				...parserOptions
+			}
+		}
+	}, {
+		name: "fabdeh/typescript/rules",
+		files: [GLOB_TS],
+		ignores: [`${GLOB_MARKDOWN}/**`],
+		plugins: {
+			"@typescript-eslint": tseslint.plugin,
+			"unused-imports": unusedImports,
+			...erasableSyntaxOnlyPlugin ? { "erasable-syntax-only": erasableSyntaxOnlyPlugin } : {}
+		},
+		rules: {
+			...tseslint.configs.strictTypeChecked.find((c) => c.name === "typescript-eslint/eslint-recommended")?.rules,
+			...tseslint.configs.strictTypeChecked.find((c) => c.name === "typescript-eslint/strict-type-checked")?.rules,
+			...stylistic$1 ? tseslint.configs.stylisticTypeChecked.find((c) => c.name === "typescript-eslint/stylistic-type-checked")?.rules : {},
+			"@typescript-eslint/array-type": ["error", { default: "array" }],
+			"@typescript-eslint/consistent-indexed-object-style": "error",
+			"@typescript-eslint/consistent-type-assertions": ["error", {
+				assertionStyle: "as",
+				objectLiteralTypeAssertions: "never"
+			}],
+			"@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+			"@typescript-eslint/consistent-type-exports": "error",
+			"@typescript-eslint/consistent-type-imports": ["error", {
+				disallowTypeAnnotations: false,
+				fixStyle: "separate-type-imports",
+				prefer: "type-imports"
+			}],
+			"@typescript-eslint/dot-notation": "error",
+			...type === "lib" ? { "@typescript-eslint/explicit-function-return-type": ["error", {
+				allowExpressions: true,
+				allowIIFEs: true
+			}] } : { "@typescript-eslint/explicit-module-boundary-types": "error" },
+			"@typescript-eslint/explicit-member-accessibility": ["error", { accessibility: "no-public" }],
+			"@typescript-eslint/member-ordering": ["error", MEMBER_ORDERING_OPTIONS],
+			"@typescript-eslint/method-signature-style": "error",
+			"@typescript-eslint/naming-convention": ["error", ...namingConvention(!useRelaxedNamingConventionForCamelAndPascalCases)],
+			"@typescript-eslint/no-base-to-string": "error",
+			"@typescript-eslint/no-confusing-non-null-assertion": "error",
+			"@typescript-eslint/no-confusing-void-expression": ["error", { ignoreArrowShorthand: true }],
+			"@typescript-eslint/no-empty-interface": "off",
+			"@typescript-eslint/no-extra-non-null-assertion": "error",
+			"@typescript-eslint/no-extraneous-class": ["error", {
+				allowStaticOnly: true,
+				allowWithDecorator: true
+			}],
+			"@typescript-eslint/no-invalid-void-type": "error",
+			"@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
+			"@typescript-eslint/only-throw-error": "error",
+			"@typescript-eslint/no-unnecessary-condition": "error",
+			"@typescript-eslint/no-unnecessary-type-arguments": "error",
+			"@typescript-eslint/no-unsafe-unary-minus": "error",
+			"@typescript-eslint/parameter-properties": "error",
+			"@typescript-eslint/prefer-enum-initializers": "error",
+			"@typescript-eslint/prefer-for-of": "error",
+			"@typescript-eslint/prefer-function-type": "error",
+			"@typescript-eslint/prefer-includes": "error",
+			"@typescript-eslint/prefer-literal-enum-member": "error",
+			"@typescript-eslint/prefer-nullish-coalescing": "error",
+			"@typescript-eslint/prefer-optional-chain": "error",
+			"@typescript-eslint/prefer-readonly": "error",
+			"@typescript-eslint/prefer-reduce-type-parameter": "error",
+			"@typescript-eslint/prefer-return-this-type": "error",
+			"@typescript-eslint/prefer-string-starts-ends-with": "error",
+			"@typescript-eslint/require-array-sort-compare": "error",
+			"@typescript-eslint/restrict-plus-operands": ["error", { skipCompoundAssignments: true }],
+			"@typescript-eslint/restrict-template-expressions": "off",
+			"@typescript-eslint/switch-exhaustiveness-check": "error",
+			"@typescript-eslint/unbound-method": ["error", { ignoreStatic: true }],
+			"@typescript-eslint/unified-signatures": "error",
+			"@typescript-eslint/no-unused-vars": "off",
+			...erasableSyntaxOnlyRules,
+			...overrides
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/unicorn.ts
+/**
+* Generates a configuration array for the Unicorn plugin with the specified options.
+*
+* @param [options] - The options to customize the Unicorn rules.
+* @returns The configuration array for the Unicorn plugin.
+*/
+function unicorn(options = {}) {
+	return tseslint.config({
+		name: "fabdeh/unicorn/rules",
+		files: [GLOB_SRC],
+		plugins: { unicorn: unicornPlugin },
+		rules: { ...options.allRecommended ? unicornPlugin.configs.recommended.rules : {
+			"unicorn/catch-error-name": "error",
+			"unicorn/consistent-date-clone": "error",
+			"unicorn/consistent-empty-array-spread": "error",
+			"unicorn/consistent-existence-index-check": "error",
+			"unicorn/consistent-function-scoping": ["error", { checkArrowFunctions: false }],
+			"unicorn/custom-error-definition": "error",
+			"unicorn/error-message": "error",
+			"unicorn/escape-case": "error",
+			"unicorn/explicit-length-check": "error",
+			"unicorn/filename-case": ["error", {
+				case: "kebabCase",
+				ignore: [/^[A-Z0-9_-]+\.md$/]
+			}],
+			"unicorn/new-for-builtins": "error",
+			"unicorn/no-abusive-eslint-disable": "error",
+			"unicorn/no-anonymous-default-export": "error",
+			"unicorn/no-array-for-each": "error",
+			"unicorn/no-array-method-this-argument": "error",
+			"unicorn/no-array-reduce": "error",
+			"unicorn/no-await-expression-member": "error",
+			"unicorn/no-await-in-promise-methods": "error",
+			"unicorn/no-document-cookie": "error",
+			"unicorn/no-empty-file": "error",
+			"unicorn/no-for-loop": "error",
+			"unicorn/no-hex-escape": "error",
+			"unicorn/no-instanceof-builtins": "error",
+			"unicorn/no-invalid-fetch-options": "error",
+			"unicorn/no-invalid-remove-event-listener": "error",
+			"unicorn/no-lonely-if": "error",
+			"unicorn/no-magic-array-flat-depth": "error",
+			"unicorn/no-negated-condition": "error",
+			"unicorn/no-negation-in-equality-check": "error",
+			"unicorn/no-new-array": "error",
+			"unicorn/no-new-buffer": "error",
+			"unicorn/no-null": "error",
+			"unicorn/no-process-exit": "error",
+			"unicorn/no-single-promise-in-promise-methods": "error",
+			"unicorn/no-thenable": "error",
+			"unicorn/no-this-assignment": "error",
+			"unicorn/no-typeof-undefined": "error",
+			"unicorn/no-unnecessary-await": "error",
+			"unicorn/no-unnecessary-array-flat-depth": "error",
+			"unicorn/no-unnecessary-array-splice-count": "error",
+			"unicorn/no-unnecessary-slice-end": "error",
+			"unicorn/no-unused-properties": "warn",
+			"unicorn/no-useless-fallback-in-spread": "error",
+			"unicorn/no-useless-length-check": "error",
+			"unicorn/no-useless-promise-resolve-reject": "error",
+			"unicorn/no-useless-spread": "error",
+			"unicorn/no-useless-switch-case": "error",
+			"unicorn/no-zero-fractions": "error",
+			"unicorn/number-literal-case": "error",
+			"unicorn/numeric-separators-style": "error",
+			"unicorn/prefer-array-find": "error",
+			"unicorn/prefer-array-flat": "error",
+			"unicorn/prefer-array-flat-map": "error",
+			"unicorn/prefer-array-index-of": "error",
+			"unicorn/prefer-array-some": "error",
+			"unicorn/prefer-at": "error",
+			"unicorn/prefer-blob-reading-methods": "error",
+			"unicorn/prefer-code-point": "error",
+			"unicorn/prefer-date-now": "error",
+			"unicorn/prefer-default-parameters": "error",
+			"unicorn/prefer-export-from": "error",
+			"unicorn/prefer-import-meta-properties": "error",
+			"unicorn/prefer-includes": "error",
+			"unicorn/prefer-keyboard-event-key": "error",
+			"unicorn/prefer-logical-operator-over-ternary": "error",
+			"unicorn/prefer-math-min-max": "error",
+			"unicorn/prefer-math-trunc": "error",
+			"unicorn/prefer-modern-math-apis": "error",
+			"unicorn/prefer-negative-index": "error",
+			"unicorn/prefer-node-protocol": "error",
+			"unicorn/prefer-number-properties": "error",
+			"unicorn/prefer-object-from-entries": "error",
+			"unicorn/prefer-optional-catch-binding": "error",
+			"unicorn/prefer-query-selector": "error",
+			"unicorn/prefer-regexp-test": "error",
+			"unicorn/prefer-set-has": "error",
+			"unicorn/prefer-set-size": "error",
+			"unicorn/prefer-single-call": "error",
+			"unicorn/prefer-spread": "error",
+			"unicorn/prefer-string-raw": "error",
+			"unicorn/prefer-string-replace-all": "error",
+			"unicorn/prefer-string-slice": "error",
+			"unicorn/prefer-string-starts-ends-with": "error",
+			"unicorn/prefer-string-trim-start-end": "error",
+			"unicorn/prefer-structured-clone": "error",
+			"unicorn/prefer-switch": "error",
+			"unicorn/prefer-ternary": "error",
+			"unicorn/prefer-type-error": "error",
+			"unicorn/require-array-join-separator": "error",
+			"unicorn/require-number-to-fixed-digits-argument": "error",
+			"unicorn/require-post-message-target-origin": "error",
+			"unicorn/throw-new-error": "error"
+		} }
+	});
+}
+
+//#endregion
+//#region src/configs/vitest.ts
+/**
+* Configures and returns an ESLint configuration array for Vitest.
+*
+* @param [options] - The options to customize the configuration.
+* @param [options.overrides] - Custom rule overrides.
+* @param [options.useJestDom] - Whether to use the `@testing-library/jest-dom` plugin.
+* @param [options.useTestingLibrary] - Whether to use the `@testing-library/angular` plugin.
+* @returns A promise that resolves to the ESLint configuration array.
+* @example
+* const config = await vitest({
+*   overrides: {
+*     'no-console': 'warn',
+*   },
+*   useJestDom: true,
+*   useTestingLibrary: false,
+* });
+*/
+async function vitest(options = {}) {
+	const { overrides = {}, useJestDom = isPackageExists("@testing-library/jest-dom"), useTestingLibrary = isPackageExists("@testing-library/angular") } = options;
+	const [vitestPlugin, jestDomPlugin, testingLibraryPlugin] = await Promise.all([
+		interopDefault(import("@vitest/eslint-plugin")),
+		useJestDom ? interopDefault(import("eslint-plugin-jest-dom")) : Promise.resolve(void 0),
+		useTestingLibrary ? interopDefault(import("eslint-plugin-testing-library")) : Promise.resolve(void 0)
+	]);
+	return tseslint.config({
+		name: "fabdeh/vitest/rules",
+		plugins: {
+			vitest: vitestPlugin,
+			...jestDomPlugin ? { "jest-dom": jestDomPlugin } : {},
+			...testingLibraryPlugin ? { "testing-library": testingLibraryPlugin } : {}
+		},
+		languageOptions: { globals: {
+			...globals.node,
+			...globals.vitest,
+			...vitestPlugin.environments.env.globals
+		} },
+		settings: { vitest: { typecheck: true } },
+		files: [...GLOB_TESTS],
+		rules: {
+			...vitestPlugin.configs.recommended.rules,
+			...jestDomPlugin?.configs["flat/recommended"].rules,
+			...testingLibraryPlugin?.configs["flat/angular"].rules,
+			"max-classes-per-file": "off",
+			"max-lines": "off",
+			"@typescript-eslint/consistent-type-assertions": "off",
+			"@typescript-eslint/no-empty-function": "off",
+			"@typescript-eslint/no-unsafe-assignment": "off",
+			"@typescript-eslint/no-unsafe-call": "off",
+			"@typescript-eslint/no-unsafe-member-access": "off",
+			"@typescript-eslint/unbound-method": "off",
+			"unicorn/no-null": "off",
+			"vitest/consistent-test-it": ["error", { fn: "test" }],
+			"vitest/no-standalone-expect": "error",
+			"vitest/no-test-return-statement": "error",
+			"vitest/prefer-hooks-in-order": "error",
+			"vitest/prefer-hooks-on-top": "error",
+			"vitest/prefer-lowercase-title": "error",
+			"vitest/prefer-spy-on": "error",
+			"vitest/prefer-to-be": "error",
+			"vitest/prefer-to-be-falsy": "error",
+			"vitest/prefer-to-be-object": "error",
+			"vitest/prefer-to-be-truthy": "error",
+			"vitest/prefer-to-contain": "error",
+			"vitest/prefer-to-have-length": "error",
+			"vitest/prefer-todo": "error",
+			"vitest/prefer-vi-mocked": "error",
+			"vitest/require-top-level-describe": "error",
+			...getJsDocRules("off", true, "both"),
+			...overrides
+		}
+	});
+}
+
+//#endregion
+//#region src/configs/yaml.ts
+/**
+* Generates an ESLint configuration for YAML files.
+*
+* @param options - Configuration options for the YAML setup.
+* @param options.files - An array of glob patterns to specify the YAML files to lint. Defaults to `[GLOB_YAML]`.
+* @param options.overrides - An object containing rule overrides.
+* @param options.stylistic - A boolean or object to specify stylistic rules. Defaults to `true`.
+* @param options.stylistic.indent - The number of spaces for indentation or 'tab'. Defaults to `2`.
+* @param options.stylistic.quotes - The type of quotes to use ('single', 'double', or 'backtick'). Defaults to `'single'`.
+* @returns A promise that resolves to a `TypedConfigArray` containing the ESLint configuration.
+*/
+async function yaml(options = {}) {
+	const { files = [GLOB_YAML], overrides = {}, stylistic: stylistic$1 = true } = options;
+	const { indent = 2, quotes = "single" } = typeof stylistic$1 === "object" ? stylistic$1 : {};
+	const [yamlPlugin, yamlParser] = await Promise.all([interopDefault(import("eslint-plugin-yml")), interopDefault(import("yaml-eslint-parser"))]);
+	return tseslint.config({
+		name: "fabdeh/yaml/setup",
+		plugins: { yaml: yamlPlugin }
+	}, {
+		name: "fabdeh/yaml/rules",
+		languageOptions: { parser: yamlParser },
+		files,
+		rules: {
+			"@stylistic/spaced-comment": "off",
+			"yaml/block-mapping": "error",
+			"yaml/block-sequence": "error",
+			"yaml/no-empty-key": "error",
+			"yaml/no-empty-sequence-entry": "error",
+			"yaml/no-irregular-whitespace": "error",
+			"yaml/plain-scalar": "error",
+			"yaml/vue-custom-block/no-parsing-error": "error",
+			...stylistic$1 ? {
+				"yaml/block-mapping-question-indicator-newline": "error",
+				"yaml/block-sequence-hyphen-indicator-newline": "error",
+				"yaml/flow-mapping-curly-newline": "error",
+				"yaml/flow-mapping-curly-spacing": "error",
+				"yaml/flow-sequence-bracket-newline": "error",
+				"yaml/flow-sequence-bracket-spacing": "error",
+				"yaml/indent": ["error", indent === "tab" ? 2 : indent],
+				"yaml/key-spacing": "error",
+				"yaml/no-tab-indent": "error",
+				"yaml/quotes": ["error", {
+					avoidEscape: true,
+					prefer: quotes === "backtick" ? "single" : quotes
+				}],
+				"yaml/spaced-comment": "error"
+			} : {},
+			...overrides
+		}
+	});
+}
+
+//#endregion
+//#region src/types.ts
+const OPTIONS_SYMBOL = Symbol("options");
+
+//#endregion
+//#region src/factory.ts
+const NGRX_PACKAGES = [
+	"@ngrx/store",
+	"@ngrx/effects",
+	"@ngrx/signals",
+	"@ngrx/operators"
+];
+/**
+* Creates an ESLint configuration array based on the provided options and user configurations.
+*
+* @param options - Configuration options that extend `ConfigWithExtends` and `CreateConfigOptions`.
+* @param userConfigs - Additional user configurations that can be awaited.
+* @returns A promise that resolves to a `ConfigArray`.
+* @example
+* ```typescript
+* const config = await createConfig({ vitest: true, typescript: { parserOptions: { project: './tsconfig.json' } } });
+* ```
+*/
+async function defineConfig(options = {}, ...userConfigs) {
+	const { angular: enableAngular = isPackageExists("@angular/core"), gitignore: enableGitignore = true, jsdoc: enableJsdoc = true, ngrx: enableNgrx = NGRX_PACKAGES.some((p) => isPackageExists(p)), pnpm: enableCatalogs = false, regexp: enableRegexp = true, tailwindcss: enableTailwind = false, typescript: enableTypescript = isPackageExists("typescript"), unicorn: enableUnicorn = true, vitest: enableVitest = isPackageExists("vitest") } = options;
+	if (enableNgrx && !enableAngular) throw new Error("NgRx rules can only be enabled if Angular rules are also enabled.");
+	const stylisticOptions = options.stylistic === false ? false : typeof options.stylistic === "object" ? options.stylistic : {};
+	const configs$1 = [];
+	if (enableGitignore) if (typeof enableGitignore === "object") configs$1.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => tseslint.config(r({
+		name: "fabdeh/gitignore",
+		...enableGitignore
+	}))));
+	else configs$1.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => tseslint.config(r({
+		name: "fabdeh/gitignore",
+		strict: true
+	}))));
+	configs$1.push(ignores(options.ignores), javascript({ overrides: options.javascript?.overrides }), comments(), node(), imports({ stylistic: stylisticOptions }), perfectionist());
+	if (enableJsdoc) configs$1.push(jsdoc({ stylistic: stylisticOptions }));
+	if (enableUnicorn) {
+		const unicornOptions = resolveSubOptions(options, "unicorn");
+		configs$1.push(unicorn(unicornOptions));
+	}
+	if (enableTypescript) {
+		const typescriptOptions = resolveSubOptions(options, "typescript");
+		configs$1.push(typescript({
+			...typescriptOptions,
+			stylistic: stylisticOptions,
+			type: options.type
+		}));
+	}
+	if (stylisticOptions) configs$1.push(stylistic({ stylistic: stylisticOptions }));
+	if (enableRegexp) {
+		const regexpOptions = resolveSubOptions(options, "regexp");
+		configs$1.push(regexp(regexpOptions));
+	}
+	if (enableAngular) {
+		const angularOptions = resolveSubOptions(options, "angular");
+		configs$1.push(angular(angularOptions));
+	}
+	if (enableNgrx) {
+		const typescriptOptions = resolveSubOptions(options, "typescript");
+		const ngrxOptions = resolveSubOptions(options, "ngrx");
+		configs$1.push(ngrx({
+			...ngrxOptions,
+			useRelaxedNamingConventionForCamelAndPascalCases: typescriptOptions.useRelaxedNamingConventionForCamelAndPascalCases
+		}));
+	}
+	if (enableVitest) {
+		const vitestOptions = resolveSubOptions(options, "vitest");
+		configs$1.push(vitest(vitestOptions));
+	}
+	if (enableTailwind) {
+		const tailwindcssOptions = resolveSubOptions(options, "tailwindcss");
+		configs$1.push(tailwindcss(tailwindcssOptions));
+	}
+	if (options.jsonc ?? true) {
+		const jsoncOptions = resolveSubOptions(options, "jsonc");
+		configs$1.push(jsonc({
+			...jsoncOptions,
+			stylistic: stylisticOptions
+		}), sortPackageJson(), sortTsConfig());
+	}
+	if (enableCatalogs) configs$1.push(pnpm());
+	if (options.yaml ?? true) {
+		const yamlOptions = resolveSubOptions(options, "yaml");
+		configs$1.push(yaml({
+			...yamlOptions,
+			stylistic: stylisticOptions
+		}));
+	}
+	if (options.toml ?? true) {
+		const tomlOptions = resolveSubOptions(options, "toml");
+		configs$1.push(toml({
+			...tomlOptions,
+			stylistic: stylisticOptions
+		}));
+	}
+	if (options.markdown ?? true) {
+		const markdownOptions = resolveSubOptions(options, "markdown");
+		configs$1.push(markdown(markdownOptions));
+	}
+	if (options.formatters) configs$1.push(formatters(options.formatters, typeof stylisticOptions === "boolean" ? {} : stylisticOptions, Boolean(enableAngular)));
+	const config = tseslint.config(...await Promise.all(configs$1), ...await Promise.all(userConfigs));
+	config[OPTIONS_SYMBOL] = options;
+	return config;
+}
+
+//#endregion
+export { GLOB_HTML, GLOB_JS, GLOB_SRC, GLOB_TESTS, GLOB_TS, STYLISTIC_CONFIG_DEFAULT, angular, comments, defineConfig, ensurePackages, findNearestPackageJsonName, formatters, getTsConfigFileName, getWorkspaceRoot, ignores, imports, interopDefault, isPackageInScope, javascript, jsdoc, jsonc, markdown, ngrx, node, perfectionist, pnpm, regexp, resolveSubOptions, sortPackageJson, sortTsConfig, stylistic, tailwindcss, toml, typescript, unicorn, vitest, yaml };