@brnshkr/config 0.0.1-alpha.2

package/dist/eslint/index.mjs

@@ -0,0 +1,2574 @@
+import { _ as resolvePackages, a as objectAssign, b as packageOrganizationUpper, c as objectFromEntries, g as isModuleEnabled, h as MODULES, i as isModuleEnabledByDefault, l as objectKeys, n as MAX_LEN, o as objectEntries, r as GLOB_IGNORES, s as objectFreeze, t as INDENT, v as setModuleEnabled, x as version, y as packageOrganization } from "../shared.mjs";
+import { FlatConfigComposer } from "eslint-flat-config-utils";
+import jsEslint from "@eslint/js";
+import confusingBrowserGlobals from "confusing-browser-globals";
+import globals from "globals";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+//#region src/js/eslint/types/scopes.ts
+const MAIN_SCOPES = {
+	[packageOrganizationUpper]: "builtin",
+	COMMENTS: "comments",
+	CSS: "css",
+	IGNORES: "ignores",
+	IMPORT: "import",
+	JAVASCRIPT: "javascript",
+	JSDOC: "jsdoc",
+	JSON: "json",
+	MARKDOWN: "markdown",
+	NODE: "node",
+	OVERRIDES: "overrides",
+	PERFECTIONIST: "perfectionist",
+	REGEXP: "regexp",
+	STYLE: "style",
+	SVELTE: "svelte",
+	TEST: "test",
+	TOML: "toml",
+	TYPESCRIPT: "typescript",
+	UNICORN: "unicorn",
+	USERLAND: "userland",
+	YAML: "yaml"
+};
+const SUB_SCOPES = {
+	BASE: "base",
+	DEVELOPMENT: "development",
+	EXAMPLES: "examples",
+	GIT: "git",
+	GLOBAL: "global",
+	PARSER: "parser",
+	PROCESSOR: "processor",
+	RULES: "rules",
+	SETUP: "setup",
+	UNNAMED: "unnamed"
+};
+
+//#endregion
+//#region src/js/eslint/utils/config.ts
+const buildConfigName = (mainScope, subScope) => [
+	packageOrganization,
+	mainScope,
+	subScope
+].filter(Boolean).join("/");
+const renameRules = (rules, map) => 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];
+}));
+const isValidGlobalAdditionalConfigKey = (key) => [
+	"name",
+	"languageOptions",
+	"linterOptions",
+	"processor",
+	"plugins",
+	"rules",
+	"settings"
+].includes(key);
+const getGlobalAdditionalConfig = (options) => {
+	const config = {};
+	for (const [key, value] of objectEntries(options)) if (isValidGlobalAdditionalConfigKey(key)) config[key] = value;
+	if (Object.keys(config).length === 0) return;
+	config.name ??= buildConfigName(MAIN_SCOPES.USERLAND, SUB_SCOPES.GLOBAL);
+	return config;
+};
+const ensureNamesForSyncAdditionalConfigs = (additionalConfigs) => {
+	const validConfigs = [];
+	let currentIndex = 1;
+	for (const config of additionalConfigs) {
+		if (config instanceof Promise || typeof config.name === "string" && config.name.trim().length > 0) {
+			validConfigs.push(config);
+			continue;
+		}
+		validConfigs.push(Object.keys(config).length > 0 ? config : void 0);
+		config.name = buildConfigName(MAIN_SCOPES.USERLAND, `${SUB_SCOPES.UNNAMED}-${String(currentIndex)}`);
+		currentIndex += 1;
+	}
+	return validConfigs;
+};
+const getUserConfigs = (resolvedOptions, additionalConfigs) => [getGlobalAdditionalConfig(resolvedOptions), ...ensureNamesForSyncAdditionalConfigs(additionalConfigs)];
+
+//#endregion
+//#region src/js/eslint/utils/globs.ts
+const GLOB_CJS = "**/*.cjs";
+const GLOB_TS = "**/*.?(c|m)ts?(x)";
+const GLOB_DTS = "**/*.d.?(c|m)ts";
+const GLOB_SVELTE = "**/*.svelte";
+const GLOB_SVELTE_SCRIPT = "**/*.svelte.[jt]s";
+const GLOB_JSON = "**/*.json";
+const GLOB_JSONC = "**/*.jsonc";
+const GLOB_JSON5 = "**/*.json5";
+const GLOB_YAML = "**/*.y?(a)ml";
+const GLOB_TOML = "**/*.toml";
+const GLOB_CSS = "**/*.css";
+const GLOB_MD = "**/*.md";
+const GLOB_EXAMPLES = "**/*.md/*.js";
+const GLOB_SCRIPT_FILES = [
+	"**/*.?(c|m)[jt]s?(x)",
+	GLOB_DTS,
+	GLOB_SVELTE,
+	GLOB_SVELTE_SCRIPT
+];
+const GLOB_SCRIPT_FILES_WITHOUT_TS = ["**/*.?(c|m)js?(x)", GLOB_DTS];
+const GLOB_DEVELOPMENT_FILES = [
+	"**/*.config.?(c|m)[jt]s",
+	"**/{conf,tests}/**",
+	"**/types/declarations/reset.d.ts"
+];
+const GLOB_TEST_FILES = [
+	"**/__tests__/**/*.?(c|m)[jt]s",
+	"**/*.spec.?(c|m)[jt]s",
+	"**/*.test.?(c|m)[jt]s",
+	"**/*.bench.?(c|m)[jt]s",
+	"**/*.benchmark.?(c|m)[jt]s"
+];
+
+//#endregion
+//#region src/js/eslint/configs/builtin.ts
+const FILE_TYPE_MAP = {
+	".json": "json",
+	".css": "css",
+	".svg": "svg",
+	".png": "image",
+	".jpg": "image",
+	".jpeg": "image",
+	".txt": "text",
+	".oct": "bytes",
+	".wasm": "webassembly"
+};
+const MESSAGE_ID_MISSING_WITH_KEYWORD = "missingWithKeyword";
+const MESSAGE_ID_MISSING_TYPE_PROPERTY = "missingTypeProperty";
+const MESSAGE_ID_WRONG_TYPE_VALUE = "wrongTypeValue";
+const requireImportAttributesRule = {
+	meta: {
+		type: "problem",
+		docs: { description: "Require non-JavaScript imports (e.g. .json and .css) to include import attributes." },
+		messages: {
+			[MESSAGE_ID_MISSING_WITH_KEYWORD]: "Non-JavaScript import ('{{ extension }}') requires an import attributes object with the 'type' property set to '{{ expectedValue }}'.",
+			[MESSAGE_ID_MISSING_TYPE_PROPERTY]: "Import attributes for non-JavaScript imports must include the 'type' property.",
+			[MESSAGE_ID_WRONG_TYPE_VALUE]: "Import attribute 'type' for '{{ file }}' must be '{{ expectedValue }}'."
+		}
+	},
+	create: (context) => ({ ImportDeclaration: (node$1) => {
+		const sourceValue = node$1.source.value;
+		const extensionIndex = sourceValue.lastIndexOf(".");
+		if (extensionIndex === -1) return;
+		const extension = sourceValue.slice(extensionIndex).toLowerCase();
+		const expectedValue = FILE_TYPE_MAP[extension];
+		if (expectedValue === void 0) return;
+		const { attributes } = node$1;
+		if (attributes.length === 0) {
+			context.report({
+				node: node$1,
+				messageId: MESSAGE_ID_MISSING_WITH_KEYWORD,
+				data: {
+					extension,
+					expectedValue
+				}
+			});
+			return;
+		}
+		const typeProperty = attributes.find((attribute) => attribute.key.type === "Identifier" && "name" in attribute.key && attribute.key.name === "type" || attribute.key.type === "Literal" && "value" in attribute.key && attribute.key.value === "type");
+		if (!typeProperty) {
+			context.report({
+				node: node$1,
+				messageId: MESSAGE_ID_MISSING_TYPE_PROPERTY
+			});
+			return;
+		}
+		if (typeProperty.value.value !== expectedValue) context.report({
+			node: node$1,
+			messageId: MESSAGE_ID_WRONG_TYPE_VALUE,
+			data: {
+				expectedValue,
+				file: sourceValue
+			}
+		});
+	} })
+};
+const RULE_DEFINITIONS = { "require-import-attributes": requireImportAttributesRule };
+const RULES = objectFreeze(objectFromEntries(objectKeys(RULE_DEFINITIONS).map((ruleName) => [`${packageOrganization}/${ruleName}`, "error"])));
+const builtin = () => [{
+	name: buildConfigName(MAIN_SCOPES[packageOrganizationUpper], SUB_SCOPES.SETUP),
+	plugins: { [packageOrganization]: {
+		meta: {
+			name: packageOrganization,
+			version
+		},
+		rules: RULE_DEFINITIONS
+	} }
+}, {
+	name: buildConfigName(MAIN_SCOPES[packageOrganizationUpper], SUB_SCOPES.RULES),
+	files: GLOB_SCRIPT_FILES,
+	rules: RULES
+}];
+const builtinConfig = { [packageOrganization]: builtin };
+
+//#endregion
+//#region src/js/eslint/configs/comments.ts
+const comments = async () => {
+	const { requiredAll: [pluginComments] } = await resolvePackages(MODULES.comments);
+	if (!pluginComments) return [];
+	const recommendedConfig = pluginComments.configs.recommended;
+	const recommendedRules = "rules" in recommendedConfig ? recommendedConfig.rules : void 0;
+	return [{
+		name: buildConfigName(MAIN_SCOPES.COMMENTS, SUB_SCOPES.SETUP),
+		plugins: { comments: pluginComments }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.COMMENTS, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			...renameRules(recommendedRules, { "@eslint-community/eslint-comments": "comments" }),
+			"comments/no-unused-disable": "error",
+			"comments/require-description": "error"
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/css.ts
+const css = async () => {
+	const { requiredAll: [pluginCss] } = await resolvePackages(MODULES.css);
+	if (!pluginCss) return [];
+	return [{
+		name: buildConfigName(MAIN_SCOPES.CSS, SUB_SCOPES.SETUP),
+		plugins: { css: pluginCss }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.CSS, SUB_SCOPES.RULES),
+		files: [GLOB_CSS],
+		language: "css/css",
+		rules: {
+			...pluginCss.configs.recommended.rules,
+			"css/prefer-logical-properties": "error",
+			"css/relative-font-units": ["error", { allowUnits: ["em", "rem"] }],
+			"css/use-baseline": "error"
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/gitignore.ts
+const gitignore = async (options) => {
+	const { requiredAll: [pluginGitignore] } = await resolvePackages(MODULES.gitignore);
+	if (!pluginGitignore) return [];
+	return [pluginGitignore({
+		name: buildConfigName(MAIN_SCOPES.IGNORES, SUB_SCOPES.GIT),
+		...options
+	})];
+};
+
+//#endregion
+//#region src/js/eslint/configs/ignores.ts
+const ignores = (customIgnores = []) => [{
+	name: buildConfigName(MAIN_SCOPES.IGNORES, SUB_SCOPES.BASE),
+	ignores: [...GLOB_IGNORES, ...customIgnores]
+}];
+
+//#endregion
+//#region src/js/eslint/configs/import.ts
+const imports = async () => {
+	const { requiredAny: [pluginImport, pluginAntfu], optional: [importResovlerTypescript] } = await resolvePackages(MODULES.import);
+	const plugins = {};
+	const settings = {};
+	let pluginImportRules = {};
+	let pluginAntfuRules = {};
+	if (pluginImport) {
+		plugins["import"] = pluginImport;
+		settings["import-x/resolver-next"] = [pluginImport.createNodeResolver(), importResovlerTypescript === void 0 ? void 0 : importResovlerTypescript.createTypeScriptImportResolver({ bun: true })].filter(Boolean);
+		const pluginImportTsRules = isModuleEnabled(MODULES.typescript) ? renameRules(pluginImport.flatConfigs.typescript.rules, { "import-x": "import" }) : {};
+		pluginImportRules = {
+			...renameRules(pluginImport.flatConfigs.recommended.rules, { "import-x": "import" }),
+			...pluginImportTsRules,
+			"import/consistent-type-specifier-style": ["error", "prefer-top-level"],
+			"import/extensions": [
+				"error",
+				"ignorePackages",
+				{
+					js: "never",
+					ts: "never",
+					cts: "never",
+					mts: "never"
+				}
+			],
+			"import/first": "error",
+			"import/max-dependencies": ["error", { max: 15 }],
+			"import/newline-after-import": "error",
+			"import/no-absolute-path": "error",
+			"import/no-amd": "error",
+			"import/no-cycle": "error",
+			"import/no-default-export": "error",
+			"import/no-deprecated": "error",
+			"import/no-duplicates": "error",
+			"import/no-dynamic-require": "error",
+			"import/no-empty-named-blocks": "error",
+			"import/no-extraneous-dependencies": ["error", { devDependencies: GLOB_DEVELOPMENT_FILES }],
+			"import/no-import-module-exports": "error",
+			"import/no-mutable-exports": "error",
+			"import/no-named-as-default-member": "error",
+			"import/no-named-as-default": "error",
+			"import/no-named-default": "error",
+			"import/no-namespace": "error",
+			"import/no-relative-packages": "error",
+			"import/no-rename-default": "error",
+			"import/no-self-import": "error",
+			"import/no-unassigned-import": ["error", { allow: ["**/*.{css,scss}"] }],
+			"import/no-useless-path-segments": ["error", { noUselessIndex: true }],
+			"import/no-unresolved": ["error", {
+				commonjs: true,
+				caseSensitive: true
+			}],
+			"import/no-webpack-loader-syntax": "error",
+			"import/order": ["error", {
+				warnOnUnassignedImports: true,
+				sortTypesGroup: true,
+				consolidateIslands: "inside-groups",
+				"newlines-between": "always-and-inside-groups",
+				"newlines-between-types": "never",
+				named: {
+					enabled: true,
+					types: "types-last"
+				},
+				alphabetize: {
+					order: "asc",
+					caseInsensitive: true
+				},
+				groups: [
+					"builtin",
+					"external",
+					"unknown",
+					"internal",
+					"parent",
+					"sibling",
+					"index",
+					"object",
+					"type"
+				],
+				pathGroups: [{
+					pattern: "**/*.{css,scss}",
+					group: "object"
+				}]
+			}],
+			"import/unambiguous": "error"
+		};
+	}
+	if (pluginAntfu) {
+		plugins["antfu"] = pluginAntfu;
+		pluginAntfuRules = {
+			"antfu/import-dedupe": "error",
+			"antfu/no-import-dist": "error",
+			"antfu/no-import-node-modules-by-path": "error"
+		};
+	}
+	if (Object.keys(plugins).length === 0) return [];
+	const setupConfig = {
+		name: buildConfigName(MAIN_SCOPES.IMPORT, SUB_SCOPES.SETUP),
+		plugins
+	};
+	if (Object.keys(settings).length > 0) setupConfig.settings = settings;
+	return [setupConfig, {
+		name: buildConfigName(MAIN_SCOPES.IMPORT, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			...pluginImportRules,
+			...pluginAntfuRules
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/javascript.ts
+const javascript = async () => {
+	const { optional: [pluginAntfu, pluginUnusedImports] } = await resolvePackages(MODULES.javascript);
+	const plugins = {};
+	const pluginRules = {};
+	if (pluginAntfu) {
+		plugins["antfu"] = pluginAntfu;
+		pluginRules["antfu/consistent-chaining"] = "error";
+		pluginRules["antfu/no-ts-export-equal"] = "error";
+	}
+	if (pluginUnusedImports) {
+		plugins["unused"] = pluginUnusedImports;
+		pluginRules["unused/no-unused-imports"] = "error";
+		pluginRules["unused/no-unused-vars"] = isModuleEnabled(MODULES.typescript) ? "off" : "error";
+	}
+	return [{
+		name: buildConfigName(MAIN_SCOPES.JAVASCRIPT, SUB_SCOPES.SETUP),
+		plugins,
+		languageOptions: {
+			ecmaVersion: "latest",
+			globals: {
+				...globals.browser,
+				...globals.es2025,
+				...globals.node
+			},
+			sourceType: "module",
+			parserOptions: {
+				sourceType: "module",
+				ecmaVersion: "latest",
+				ecmaFeatures: { jsx: true }
+			}
+		},
+		linterOptions: { reportUnusedDisableDirectives: "error" }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.JAVASCRIPT, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			...jsEslint.configs.recommended.rules,
+			...pluginUnusedImports ? { "no-unused-vars": "off" } : void 0,
+			"accessor-pairs": "error",
+			"array-callback-return": ["error", { checkForEach: true }],
+			"arrow-body-style": ["error", "as-needed"],
+			"block-scoped-var": "error",
+			"capitalized-comments": [
+				"error",
+				"always",
+				{
+					block: { ignoreInlineComments: true },
+					line: { ignorePattern: ".*" }
+				}
+			],
+			"class-methods-use-this": ["error", { ignoreOverrideMethods: true }],
+			complexity: ["error", {
+				max: 10,
+				variant: "modified"
+			}],
+			"consistent-return": "error",
+			"consistent-this": "error",
+			curly: "error",
+			"default-case": "error",
+			"default-case-last": "error",
+			"default-param-last": "error",
+			"dot-notation": "error",
+			eqeqeq: "error",
+			"func-name-matching": ["error", {
+				considerPropertyDescriptor: true,
+				includeCommonJSModuleExports: true
+			}],
+			"func-names": "error",
+			"func-style": ["error", "expression"],
+			"grouped-accessor-pairs": "error",
+			"guard-for-in": "error",
+			"init-declarations": "error",
+			"logical-assignment-operators": "error",
+			"max-classes-per-file": "error",
+			"max-depth": "error",
+			"max-lines": ["error", {
+				max: 300,
+				skipBlankLines: true,
+				skipComments: true
+			}],
+			"max-lines-per-function": ["error", {
+				IIFEs: true,
+				max: 50,
+				skipBlankLines: true,
+				skipComments: true
+			}],
+			"max-nested-callbacks": ["error", { max: 3 }],
+			"max-params": ["error", { max: 4 }],
+			"max-statements": ["error", { max: 30 }],
+			"new-cap": "error",
+			"no-alert": "error",
+			"no-array-constructor": "error",
+			"no-await-in-loop": "error",
+			"no-bitwise": "error",
+			"no-caller": "error",
+			"no-cond-assign": ["error", "always"],
+			"no-console": "error",
+			"no-constructor-return": "error",
+			"no-div-regex": "error",
+			"no-duplicate-imports": isModuleEnabled(MODULES.import) ? "off" : ["error", { allowSeparateTypeImports: true }],
+			"no-else-return": ["error", { allowElseIf: false }],
+			"no-empty-function": "error",
+			"no-eq-null": "error",
+			"no-eval": "error",
+			"no-extend-native": "error",
+			"no-extra-bind": "error",
+			"no-extra-label": "error",
+			"no-implicit-coercion": ["error", { boolean: false }],
+			"no-implicit-globals": "error",
+			"no-implied-eval": "error",
+			"no-inline-comments": "error",
+			"no-inner-declarations": "error",
+			"no-invalid-this": "error",
+			"no-iterator": "error",
+			"no-label-var": "error",
+			"no-labels": "error",
+			"no-lone-blocks": "error",
+			"no-lonely-if": "error",
+			"no-loop-func": "error",
+			"no-magic-numbers": ["error", { ignore: [
+				-1,
+				0,
+				1,
+				100,
+				42069
+			] }],
+			"no-multi-assign": "error",
+			"no-multi-str": "error",
+			"no-negated-condition": "error",
+			"no-nested-ternary": "error",
+			"no-new": "error",
+			"no-new-func": "error",
+			"no-new-wrappers": "error",
+			"no-object-constructor": "error",
+			"no-octal-escape": "error",
+			"no-param-reassign": ["error", { props: false }],
+			"no-plusplus": "error",
+			"no-promise-executor-return": "error",
+			"no-proto": "error",
+			"no-restricted-exports": ["error", { restrictedNamedExports: ["default"] }],
+			"no-restricted-globals": [
+				"error",
+				"global",
+				...confusingBrowserGlobals
+			],
+			"no-restricted-properties": [
+				"error",
+				{
+					message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
+					property: "__proto__"
+				},
+				{
+					message: "Use the `get` syntax or `Object.defineProperty` instead.",
+					property: "__defineGetter__"
+				},
+				{
+					message: "Use the `set` syntax or `Object.defineProperty` instead.",
+					property: "__defineSetter__"
+				},
+				{
+					message: "Use `Object.getOwnPropertyDescriptor` instead.",
+					property: "__lookupGetter__"
+				},
+				{
+					message: "Use `Object.getOwnPropertyDescriptor` instead.",
+					property: "__lookupSetter__"
+				}
+			],
+			"no-restricted-syntax": [
+				"error",
+				{
+					selector: "ForInStatement",
+					message: "`for..in` loops include inherited properties, leading to unexpected behavior. Use Object.{keys, values, entries} for safe iteration or explicitly disable this rule to make the intent clear."
+				},
+				{
+					selector: "TSEnumDeclaration",
+					message: "TypeScript enums can lead to less predictable type behavior. Use a constant object literal (`const MY_ENUM = <const>{ VALUE1: 1, VALUE2: 2 };`) and add a type for it (`type MyEnum = typeof MY_ENUM[keyof typeof MY_ENUM];`) instead to ensure stricter typing control and better code clarity."
+				},
+				{
+					selector: "TSExportAssignment",
+					message: "TypeScript export assignments should be avoided for consistency and maintainability. Use a default export instead to align with modern module standards and to avoid potential import/export issues."
+				}
+			],
+			"no-return-assign": ["error", "always"],
+			"no-script-url": "error",
+			"no-self-compare": "error",
+			"no-sequences": "error",
+			"no-shadow": "error",
+			"no-template-curly-in-string": "error",
+			"no-throw-literal": "error",
+			"no-unassigned-vars": "error",
+			"no-underscore-dangle": "error",
+			"no-unmodified-loop-condition": "error",
+			"no-unneeded-ternary": ["error", { defaultAssignment: false }],
+			"no-unreachable-loop": "error",
+			"no-unused-expressions": "error",
+			"no-use-before-define": "error",
+			"no-useless-assignment": "error",
+			"no-useless-call": "error",
+			"no-useless-computed-key": "error",
+			"no-useless-concat": "error",
+			"no-useless-constructor": "error",
+			"no-useless-rename": "error",
+			"no-useless-return": "error",
+			"no-var": "error",
+			"no-void": "error",
+			"no-warning-comments": "error",
+			"object-shorthand": [
+				"error",
+				"always",
+				{
+					avoidQuotes: true,
+					ignoreConstructors: false
+				}
+			],
+			"operator-assignment": "error",
+			"prefer-arrow-callback": "error",
+			"prefer-const": ["error", { ignoreReadBeforeAssign: true }],
+			"prefer-destructuring": "error",
+			"prefer-exponentiation-operator": "error",
+			"prefer-named-capture-group": "error",
+			"prefer-numeric-literals": "error",
+			"prefer-object-has-own": "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",
+			"preserve-caught-error": "error",
+			radix: "error",
+			"require-atomic-updates": "error",
+			"require-await": "error",
+			strict: "error",
+			"symbol-description": "error",
+			"unicode-bom": "error",
+			"use-isnan": ["error", { enforceForIndexOf: true }],
+			"valid-typeof": ["error", { requireStringLiterals: true }],
+			"vars-on-top": "error",
+			yoda: "error",
+			...pluginRules
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/typescript.ts
+const DEFAULT_TYPE_AWARE_IGNORES = [`${GLOB_MD}/**`];
+const getTsEslintParserIfExists = async () => {
+	const isTypescriptModuleEnabled = isModuleEnabled(MODULES.typescript);
+	let parser = void 0;
+	if (isTypescriptModuleEnabled) {
+		const { requiredAll: [, tsEslint] } = await resolvePackages(MODULES.typescript);
+		if (tsEslint) ({parser} = tsEslint);
+	}
+	return parser;
+};
+const resolveTypeAwareOptions = (resolvedOptions, files, ignores$1) => {
+	const typeAwareOptions = typeof resolvedOptions.typeAware === "object" ? resolvedOptions.typeAware : {
+		ignores: DEFAULT_TYPE_AWARE_IGNORES,
+		tsconfig: typeof resolvedOptions.typeAware === "string" ? resolvedOptions.typeAware : void 0
+	};
+	typeAwareOptions.files = [...new Set([...typeAwareOptions.files ?? [], ...files])];
+	typeAwareOptions.ignores = [...new Set([...typeAwareOptions.ignores ?? [], ...ignores$1])];
+	return typeAwareOptions;
+};
+const extractRelevantRules = (configs$1, key) => {
+	for (const config of configs$1) if (config.name === `typescript-eslint/${key}` && config.rules) return renameRules(config.rules, { "@typescript-eslint": "ts" });
+	throw new Error(`Expected key "${key}" to be contained in given config.`);
+};
+const getNamingConvention = (isTypeAware) => {
+	const ruleOptions = [
+		"error",
+		{
+			selector: "default",
+			format: [
+				"strictCamelCase",
+				"StrictPascalCase",
+				"UPPER_CASE"
+			],
+			leadingUnderscore: "forbid",
+			trailingUnderscore: "forbid"
+		},
+		{
+			selector: ["objectLiteralProperty", "variable"],
+			format: ["strictCamelCase", "UPPER_CASE"]
+		},
+		{
+			selector: "variable",
+			format: null,
+			modifiers: ["destructured"]
+		},
+		{
+			selector: "typeLike",
+			format: ["StrictPascalCase"]
+		},
+		{
+			selector: "parameter",
+			format: null,
+			filter: {
+				regex: "^_+$",
+				match: false
+			}
+		},
+		{
+			selector: [
+				"classProperty",
+				"objectLiteralProperty",
+				"typeProperty",
+				"classMethod",
+				"objectLiteralMethod",
+				"typeMethod",
+				"accessor",
+				"enumMember"
+			],
+			format: null,
+			modifiers: ["requiresQuotes"]
+		},
+		{
+			selector: "typeParameter",
+			format: ["StrictPascalCase"],
+			prefix: ["T"],
+			custom: {
+				regex: "^[A-Z]",
+				match: true
+			}
+		},
+		{
+			selector: "interface",
+			format: ["StrictPascalCase"],
+			custom: {
+				regex: "^I[A-Z]",
+				match: false
+			}
+		}
+	];
+	if (isTypeAware) ruleOptions.push({
+		selector: "variable",
+		types: ["boolean"],
+		format: ["StrictPascalCase"],
+		prefix: [
+			"is",
+			"do",
+			"does",
+			"did",
+			"has",
+			"was",
+			"can"
+		]
+	});
+	return ruleOptions;
+};
+const typescript = async (options) => {
+	const { requiredAll: [isTypescriptInstalled, tsEslint] } = await resolvePackages(MODULES.typescript);
+	if (!isTypescriptInstalled || !tsEslint) return [];
+	const cwd = process.cwd();
+	let hasTsConfig = false;
+	try {
+		await fs.access(path.resolve(cwd, "tsconfig.json"), fs.constants.R_OK);
+		hasTsConfig = true;
+	} catch {}
+	const resolvedOptions = {
+		extraFileExtensions: [],
+		parserOptions: {},
+		typeAware: hasTsConfig,
+		...options
+	};
+	const ignores$1 = resolvedOptions.ignores ?? [];
+	const files = [...new Set([...resolvedOptions.extraFileExtensions.map((extension) => `**/*.${extension}`), ...resolvedOptions.files ?? GLOB_SCRIPT_FILES])];
+	const hasEnabledTypeAwareness = resolvedOptions.typeAware !== false;
+	const typeAwareOptions = hasEnabledTypeAwareness ? resolveTypeAwareOptions(resolvedOptions, files, ignores$1) : {};
+	const createParserConfig = (isTypeAware) => ({
+		name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, `${SUB_SCOPES.PARSER}${isTypeAware ? "-type-aware" : ""}`),
+		files: isTypeAware ? typeAwareOptions.files : files,
+		ignores: isTypeAware ? typeAwareOptions.ignores : ignores$1,
+		languageOptions: {
+			parser: tsEslint.parser,
+			parserOptions: {
+				extraFileExtensions: resolvedOptions.extraFileExtensions.map((extension) => `.${extension}`),
+				...isTypeAware ? {
+					tsconfigRootDir: cwd,
+					projectService: { defaultProject: typeAwareOptions.tsconfig }
+				} : {},
+				...resolvedOptions.parserOptions
+			}
+		}
+	});
+	const createRulesConfig = (isTypeAware) => ({
+		name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, `${SUB_SCOPES.RULES}${isTypeAware ? "-type-aware" : ""}`),
+		files: isTypeAware ? typeAwareOptions.files : files,
+		ignores: isTypeAware ? typeAwareOptions.ignores : ignores$1,
+		rules: {
+			"ts/naming-convention": getNamingConvention(isTypeAware),
+			...isTypeAware ? {
+				...extractRelevantRules(tsEslint.configs.recommendedTypeCheckedOnly, "recommended-type-checked-only"),
+				...extractRelevantRules(tsEslint.configs.strictTypeCheckedOnly, "strict-type-checked-only"),
+				...extractRelevantRules(tsEslint.configs.stylisticTypeCheckedOnly, "stylistic-type-checked-only"),
+				"consistent-return": "off",
+				"ts/consistent-return": "error",
+				"ts/consistent-type-exports": "error",
+				"ts/no-unnecessary-qualifier": "error",
+				"prefer-destructuring": "off",
+				"ts/prefer-destructuring": "error",
+				"ts/no-unnecessary-type-conversion": "error",
+				"ts/promise-function-async": "error",
+				"ts/prefer-readonly": "error",
+				"ts/require-array-sort-compare": "error",
+				"ts/strict-boolean-expressions": "error",
+				"ts/strict-void-return": "error",
+				"ts/switch-exhaustiveness-check": ["error", { requireDefaultForNonUnion: true }]
+			} : {
+				...extractRelevantRules(tsEslint.configs.recommended, "recommended"),
+				...extractRelevantRules(tsEslint.configs.strict, "strict"),
+				...extractRelevantRules(tsEslint.configs.stylistic, "stylistic"),
+				"ts/consistent-type-assertions": ["error", { assertionStyle: "angle-bracket" }],
+				"ts/consistent-type-imports": "error",
+				"ts/member-ordering": "error",
+				"ts/method-signature-style": "error",
+				"ts/no-import-type-side-effects": "error",
+				"no-redeclare": "off",
+				"ts/no-redeclare": "error",
+				"ts/no-unnecessary-parameter-property-assignment": "error",
+				"no-unused-private-class-members": "off",
+				"ts/no-unused-private-class-members": "error",
+				"ts/no-useless-empty-export": "error",
+				"ts/prefer-enum-initializers": "error"
+			}
+		}
+	});
+	return [
+		{
+			name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, SUB_SCOPES.SETUP),
+			plugins: { ts: tsEslint.plugin }
+		},
+		createParserConfig(false),
+		hasEnabledTypeAwareness ? createParserConfig(true) : void 0,
+		createRulesConfig(false),
+		hasEnabledTypeAwareness ? createRulesConfig(true) : void 0,
+		{
+			name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, `${SUB_SCOPES.RULES}-typescript`),
+			files: [GLOB_TS],
+			ignores: typeAwareOptions.ignores ?? ignores$1,
+			rules: {
+				"ts/explicit-function-return-type": "error",
+				"ts/explicit-member-accessibility": "error"
+			}
+		}
+	].filter(Boolean);
+};
+
+//#endregion
+//#region src/js/eslint/configs/jsdoc.ts
+const jsdoc = async () => {
+	const { requiredAll: [pluginJsdoc], optional: [getJsdocProcessorPlugin] } = await resolvePackages(MODULES.jsdoc);
+	if (!pluginJsdoc) return [];
+	const createSetupConfig = (isForTypescript) => ({
+		name: buildConfigName(MAIN_SCOPES.JSDOC, `${SUB_SCOPES.SETUP}${isForTypescript ? "-typescript" : ""}`),
+		...isForTypescript ? void 0 : { plugins: { jsdoc: pluginJsdoc } },
+		settings: { jsdoc: { mode: isForTypescript ? "typescript" : "jsdoc" } }
+	});
+	const createRulesConfig = (isForTypescript) => ({
+		name: buildConfigName(MAIN_SCOPES.JSDOC, `${SUB_SCOPES.RULES}${isForTypescript ? "-typescript" : ""}`),
+		files: isForTypescript ? [GLOB_TS, GLOB_SCRIPT_FILES_WITHOUT_TS] : GLOB_SCRIPT_FILES_WITHOUT_TS,
+		rules: { ...isForTypescript ? {
+			...Object.fromEntries(objectEntries(pluginJsdoc.configs["flat/recommended-typescript-error"].rules ?? {}).map(([key, value]) => Object.is(pluginJsdoc.configs["flat/recommended-error"].rules?.[key], value) ? void 0 : [key, value]).filter(Boolean)),
+			"jsdoc/require-param": "off",
+			"jsdoc/require-returns": "off"
+		} : {
+			...pluginJsdoc.configs["flat/recommended-error"].rules,
+			"jsdoc/check-indentation": "error",
+			"jsdoc/check-line-alignment": "error",
+			"jsdoc/check-syntax": "error",
+			"jsdoc/check-template-names": "error",
+			"jsdoc/convert-to-jsdoc-comments": ["error", { lineOrBlockStyle: "block" }],
+			"jsdoc/imports-as-dependencies": "error",
+			"jsdoc/informative-docs": "error",
+			"jsdoc/match-description": "error",
+			"jsdoc/multiline-blocks": ["error", {
+				noSingleLineBlocks: true,
+				singleLineTags: []
+			}],
+			"jsdoc/no-bad-blocks": "error",
+			"jsdoc/no-blank-block-descriptions": "error",
+			"jsdoc/no-blank-blocks": "error",
+			"jsdoc/prefer-import-tag": "error",
+			"jsdoc/require-description-complete-sentence": "error",
+			"jsdoc/require-asterisk-prefix": "error",
+			"jsdoc/require-hyphen-before-param-description": "error",
+			"jsdoc/require-param-description": "off",
+			"jsdoc/require-property-description": "off",
+			"jsdoc/require-returns-description": "off",
+			"jsdoc/require-jsdoc": "off",
+			"jsdoc/require-template": "error",
+			"jsdoc/require-throws": "error",
+			"jsdoc/sort-tags": ["error", { tagSequence: [
+				{ tags: ["import"] },
+				{ tags: [
+					"deprecated",
+					"ignore",
+					"since",
+					"version",
+					["to", "do"].join("")
+				] },
+				{ tags: [
+					"author",
+					"copyright",
+					"license"
+				] },
+				{ tags: ["summary", "typeSummary"] },
+				{ tags: [
+					"desc",
+					"description",
+					"classdesc"
+				] },
+				{ tags: [
+					"internal",
+					"namespace",
+					"category",
+					"package",
+					"file",
+					"fileoverview",
+					"overview",
+					"module",
+					"override",
+					"requires",
+					"implements",
+					"mixes",
+					"mixin",
+					"mixinClass",
+					"mixinFunction",
+					"borrows",
+					"constructs",
+					"lends",
+					"final",
+					"global",
+					"readonly",
+					"abstract",
+					"virtual",
+					"static",
+					"private",
+					"protected",
+					"public",
+					"access",
+					"const",
+					"constant",
+					"variation",
+					"var",
+					"member",
+					"memberof",
+					"inner",
+					"instance",
+					"inheritdoc",
+					"inheritDoc",
+					"hideconstructor"
+				] },
+				{ tags: [
+					"this",
+					"interface",
+					"enum",
+					"event",
+					"augments",
+					"extends",
+					"name",
+					"kind",
+					"type",
+					"alias",
+					"external",
+					"host",
+					"async",
+					"callback",
+					"func",
+					"function",
+					"method",
+					"class",
+					"constructor",
+					"generator",
+					"fires",
+					"emits",
+					"listens"
+				] },
+				{ tags: ["template"] },
+				{ tags: ["typedef"] },
+				{ tags: [
+					"param",
+					"arg",
+					"argument",
+					"prop",
+					"property"
+				] },
+				{ tags: ["return", "returns"] },
+				{ tags: ["yield", "yields"] },
+				{ tags: ["throws", "exception"] },
+				{ tags: ["satisfies"] },
+				{ tags: ["default", "defaultvalue"] },
+				{ tags: ["exports"] },
+				{ tags: ["see", "tutorial"] },
+				{ tags: ["example"] }
+			] }],
+			"jsdoc/tag-lines": [
+				"error",
+				"any",
+				{
+					maxBlockLines: 1,
+					startLines: 1
+				}
+			],
+			"jsdoc/text-escaping": ["error", { escapeHTML: true }],
+			"jsdoc/ts-method-signature-style": "error",
+			"jsdoc/ts-no-unnecessary-template-expression": "error",
+			"jsdoc/ts-prefer-function-type": "error",
+			"jsdoc/type-formatting": ["error", {
+				objectFieldSeparatorOptionalLinebreak: false,
+				objectTypeBracketSpacing: " ",
+				separatorForSingleObjectField: true,
+				stringQuotes: "single",
+				trailingPunctuationMultilineOnly: true
+			}]
+		} }
+	});
+	const parser = await getTsEslintParserIfExists();
+	const examplePlugin = getJsdocProcessorPlugin ? getJsdocProcessorPlugin.getJsdocProcessorPlugin({
+		checkDefaults: true,
+		checkExamples: true,
+		checkParams: true,
+		checkProperties: true,
+		parser
+	}) : void 0;
+	return [
+		createSetupConfig(false),
+		parser ? createSetupConfig(true) : void 0,
+		createRulesConfig(false),
+		parser ? createRulesConfig(true) : void 0,
+		...examplePlugin ? [{
+			name: buildConfigName(MAIN_SCOPES.JSDOC, `${SUB_SCOPES.EXAMPLES}/${SUB_SCOPES.SETUP}`),
+			plugins: { examples: examplePlugin }
+		}, {
+			name: buildConfigName(MAIN_SCOPES.JSDOC, `${SUB_SCOPES.EXAMPLES}/${SUB_SCOPES.PROCESSOR}`),
+			files: GLOB_SCRIPT_FILES,
+			processor: examplePlugin.processors?.["examples"]
+		}] : []
+	].filter(Boolean);
+};
+
+//#endregion
+//#region src/js/eslint/configs/json.ts
+const TSCONFIG_FILES = ["**/tsconfig.json", "**/tsconfig.*.json"];
+const JSON_FILES_TO_TREAT_AS_JSONC = [...TSCONFIG_FILES, ".vscode/**/*.json"];
+const LANGUAGE_TO_GLOB_MAP = {
+	json: [GLOB_JSON],
+	jsonc: [GLOB_JSONC, ...JSON_FILES_TO_TREAT_AS_JSONC],
+	json5: [GLOB_JSON5]
+};
+const extractAllRules = (configs$1) => {
+	const rules = {};
+	for (const config of configs$1) if (config.rules) objectAssign(rules, config.rules);
+	return rules;
+};
+const getJsoncSortConfigs = () => [
+	{
+		name: buildConfigName(MAIN_SCOPES.JSON, `${SUB_SCOPES.RULES}-sort-package-json`),
+		files: ["**/package.json"],
+		rules: {
+			"jsonc/sort-array-values": ["error", {
+				pathPattern: "^files$",
+				order: { type: "asc" }
+			}],
+			"jsonc/sort-keys": [
+				"error",
+				{
+					pathPattern: "^$",
+					order: [
+						"$schema",
+						"jscpd",
+						"jspm",
+						"name",
+						"version",
+						"description",
+						"license",
+						"private",
+						"author",
+						"homepage",
+						"man",
+						"readme",
+						"repository",
+						"bugs",
+						"funding",
+						"type",
+						"packageManager",
+						"bundleDependencies",
+						"os",
+						"cpu",
+						"libc",
+						"engines",
+						"devEngines",
+						"scripts",
+						"esnext",
+						"module",
+						"pnpm",
+						"main",
+						"browser",
+						"dist",
+						"bin",
+						"types",
+						"typings",
+						"typesVersions",
+						"imports",
+						"exports",
+						"files",
+						"directories",
+						"dependencies",
+						"peerDependencies",
+						"peerDependenciesMeta",
+						"optionalDependencies",
+						"devDependencies",
+						"overrides",
+						"resolutions",
+						"workspaces",
+						"maintainers",
+						"contributors",
+						"keywords",
+						"config",
+						"publishConfig",
+						"release",
+						"husky",
+						"simple-git-hooks",
+						"lint-staged",
+						"eslintConfig",
+						"stylelint",
+						"prettier",
+						"ava",
+						"stackblitz",
+						"volta"
+					]
+				},
+				{
+					pathPattern: "^exports.*$",
+					order: [
+						"default",
+						"import",
+						"require",
+						"types"
+					]
+				},
+				{
+					pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$",
+					order: { type: "asc" }
+				},
+				{
+					pathPattern: "^(?:resolutions|overrides|pnpm.overrides)$",
+					order: { type: "asc" }
+				},
+				{
+					pathPattern: "^contributors.*$",
+					order: [
+						"name",
+						"email",
+						"url"
+					]
+				},
+				{
+					pathPattern: "^(?:husky|simple-git-hooks)$",
+					order: [
+						"pre-commit",
+						"prepare-commit-msg",
+						"commit-msg",
+						"post-commit",
+						"pre-rebase",
+						"post-rewrite",
+						"post-checkout",
+						"post-merge",
+						"pre-push",
+						"pre-auto-gc"
+					]
+				}
+			]
+		}
+	},
+	{
+		name: buildConfigName(MAIN_SCOPES.JSON, `${SUB_SCOPES.RULES}-sort-composer-json`),
+		files: ["**/composer.json"],
+		rules: { "jsonc/sort-keys": [
+			"error",
+			{
+				pathPattern: "^$",
+				order: [
+					"$schema",
+					"name",
+					"version",
+					"time",
+					"description",
+					"_comment",
+					"license",
+					"authors",
+					"abandoned",
+					"homepage",
+					"readme",
+					"support",
+					"funding",
+					"type",
+					"scripts",
+					"bin",
+					"require",
+					"require-dev",
+					"replace",
+					"provide",
+					"conflict",
+					"suggest",
+					"autoload",
+					"autoload-dev",
+					"include-path",
+					"target-dir",
+					"extra",
+					"minimum-stability",
+					"prefer-stable",
+					"config",
+					"repositories",
+					"archive",
+					"keywords"
+				]
+			},
+			{
+				pathPattern: "^authors.*$",
+				order: [
+					"name",
+					"role",
+					"email",
+					"homepage"
+				]
+			},
+			{
+				pathPattern: "^require|require-dev|replace|provide|conflict|suggest$",
+				order: [
+					{ keyPattern: "^php$" },
+					{ keyPattern: "^ext-(.+)$" },
+					{ order: { type: "asc" } }
+				]
+			},
+			{
+				pathPattern: "autoload(-dev)?",
+				order: [
+					"psr-0",
+					"psr-4",
+					"classmap",
+					"files",
+					"exclude-from-classmap"
+				]
+			},
+			{
+				pathPattern: "^extra$",
+				order: { type: "asc" }
+			},
+			{
+				pathPattern: "^config$",
+				order: [
+					"platform",
+					"platform-check",
+					"allow-missing-requirements",
+					"bin-compat",
+					"bump-after-update",
+					"classmap-authoritative",
+					"discard-changes",
+					"lock",
+					"notify-on-install",
+					"preferred-install",
+					"sort-packages",
+					"apcu-autoloader",
+					"autoloader-suffix",
+					"prepend-autoloader",
+					"optimize-autoloader",
+					"process-timeout",
+					"store-auths",
+					"allow-plugins",
+					"use-include-path",
+					"use-parent-dir",
+					"archive-format",
+					"archive-dir",
+					"vendor-dir",
+					"bin-dir",
+					"data-dir",
+					"cache-dir",
+					"cache-files-dir",
+					"cache-repo-dir",
+					"cache-vcs-dir",
+					"cache-files-ttl",
+					"cache-files-maxsize",
+					"cache-read-only",
+					"audit",
+					"htaccess-protect",
+					"disable-tls",
+					"secure-http",
+					"cafile",
+					"capath",
+					"http-basic",
+					"bearer",
+					"use-github-api",
+					"github-expose-hostname",
+					"github-protocols",
+					"bitbucket-oauth",
+					"secure-svn-domains",
+					"github-oauth",
+					"github-domains",
+					"gitlab-token",
+					"gitlab-protocol",
+					"gitlab-oauth",
+					"gitlab-domains"
+				]
+			}
+		] }
+	},
+	{
+		name: buildConfigName(MAIN_SCOPES.JSON, `${SUB_SCOPES.RULES}-sort-tsconfig-json`),
+		files: TSCONFIG_FILES,
+		rules: {
+			"jsonc/sort-array-values": ["error", {
+				pathPattern: "^(?:files|include|exclude)$",
+				order: { type: "asc" }
+			}],
+			"jsonc/sort-keys": [
+				"error",
+				{
+					pathPattern: "^$",
+					order: [
+						"$schema",
+						"extends",
+						"references",
+						"files",
+						"include",
+						"exclude",
+						"compilerOptions",
+						"watchOptions",
+						"typeAcquisition"
+					]
+				},
+				{
+					pathPattern: "^compilerOptions$",
+					order: [
+						"emitDecoratorMetadata",
+						"experimentalDecorators",
+						"jsx",
+						"jsxFactory",
+						"jsxFragmentFactory",
+						"jsxImportSource",
+						"lib",
+						"libReplacement",
+						"moduleDetection",
+						"noLib",
+						"reactNamespace",
+						"target",
+						"useDefineForClassFields",
+						"incremental",
+						"composite",
+						"tsBuildInfoFile",
+						"disableReferencedProjectLoad",
+						"disableSolutionSearching",
+						"disableSourceOfProjectReferenceRedirect",
+						"allowArbitraryExtensions",
+						"allowImportingTsExtensions",
+						"allowUmdGlobalAccess",
+						"baseUrl",
+						"customConditions",
+						"module",
+						"moduleResolution",
+						"moduleSuffixes",
+						"noResolve",
+						"noUncheckedSideEffectImports",
+						"paths",
+						"resolveJsonModule",
+						"resolvePackageJsonExports",
+						"resolvePackageJsonImports",
+						"rewriteRelativeImportExtensions",
+						"rootDir",
+						"rootDirs",
+						"typeRoots",
+						"types",
+						"declaration",
+						"declarationDir",
+						"declarationMap",
+						"downlevelIteration",
+						"emitBOM",
+						"emitDeclarationOnly",
+						"importHelpers",
+						"inlineSourceMap",
+						"inlineSources",
+						"mapRoot",
+						"newLine",
+						"noEmit",
+						"noEmitHelpers",
+						"noEmitOnError",
+						"outDir",
+						"outFile",
+						"preserveConstEnums",
+						"removeComments",
+						"sourceMap",
+						"sourceRoot",
+						"stripInternal",
+						"skipDefaultLibCheck",
+						"skipLibCheck",
+						"noErrorTruncation",
+						"preserveWatchOutput",
+						"pretty",
+						"assumeChangesOnlyAffectDirectDependencies",
+						"allowJs",
+						"checkJs",
+						"maxNodeModuleJsDepth",
+						"allowSyntheticDefaultImports",
+						"erasableSyntaxOnly",
+						"esModuleInterop",
+						"forceConsistentCasingInFileNames",
+						"isolatedDeclarations",
+						"isolatedModules",
+						"preserveSymlinks",
+						"verbatimModuleSyntax",
+						"allowUnreachableCode",
+						"allowUnusedLabels",
+						"alwaysStrict",
+						"exactOptionalPropertyTypes",
+						"noFallthroughCasesInSwitch",
+						"noImplicitAny",
+						"noImplicitOverride",
+						"noImplicitReturns",
+						"noImplicitThis",
+						"noPropertyAccessFromIndexSignature",
+						"noUncheckedIndexedAccess",
+						"noUnusedLocals",
+						"noUnusedParameters",
+						"strict",
+						"strictBindCallApply",
+						"strictBuiltinIteratorReturn",
+						"strictFunctionTypes",
+						"strictNullChecks",
+						"strictPropertyInitialization",
+						"useUnknownInCatchVariables",
+						"diagnostics",
+						"explainFiles",
+						"extendedDiagnostics",
+						"generateCpuProfile",
+						"generateTrace",
+						"listEmittedFiles",
+						"listFiles",
+						"noCheck",
+						"traceResolution",
+						"charset",
+						"importsNotUsedAsValues",
+						"keyofStringsOnly",
+						"noImplicitUseStrict",
+						"noStrictGenericChecks",
+						"out",
+						"preserveValueImports",
+						"suppressExcessPropertyErrors",
+						"suppressImplicitAnyIndexErrors",
+						"disableSizeLimit",
+						"plugins"
+					]
+				},
+				{
+					pathPattern: "^watchOptions$",
+					order: [
+						"watchFile",
+						"watchDirectory",
+						"fallbackPolling",
+						"synchronousWatchDirectory",
+						"excludeDirectories ",
+						"excludeFiles"
+					]
+				},
+				{
+					pathPattern: "^typeAcquisition$",
+					order: [
+						"enable",
+						"include",
+						"exclude",
+						"disableFilenameBasedTypeAcquisition"
+					]
+				}
+			]
+		}
+	}
+];
+const json = async () => {
+	const { requiredAll: [pluginJson], optional: [pluginJsonc, parserJsonc] } = await resolvePackages(MODULES.json);
+	if (!pluginJson) return [];
+	const createRulesConfig = (language) => ({
+		name: buildConfigName(MAIN_SCOPES.JSON, `${SUB_SCOPES.RULES}-${language}`),
+		language: `json/${language}`,
+		files: LANGUAGE_TO_GLOB_MAP[language],
+		...language === "json" ? { ignores: JSON_FILES_TO_TREAT_AS_JSONC } : void 0,
+		rules: {
+			...pluginJson.configs.recommended.rules,
+			...pluginJsonc ? extractAllRules(pluginJsonc.configs[`flat/recommended-with-${language}`]) : void 0,
+			...pluginJsonc ? {
+				"jsonc/array-bracket-newline": ["error", "consistent"],
+				"jsonc/array-bracket-spacing": "error",
+				"jsonc/comma-style": "error",
+				"jsonc/indent": ["error", INDENT],
+				"jsonc/key-spacing": "error",
+				"jsonc/no-irregular-whitespace": "error",
+				"jsonc/no-octal-escape": "error",
+				"jsonc/object-curly-newline": "error",
+				"jsonc/object-curly-spacing": ["error", "always"],
+				"jsonc/object-property-newline": "error",
+				"jsonc/quotes": ["error", "double"]
+			} : void 0
+		}
+	});
+	const plugins = { json: pluginJson };
+	let jsoncSortConfigs = [];
+	if (pluginJsonc) {
+		plugins["jsonc"] = pluginJsonc;
+		jsoncSortConfigs = getJsoncSortConfigs();
+	}
+	return [
+		{
+			name: buildConfigName(MAIN_SCOPES.JSON, SUB_SCOPES.SETUP),
+			plugins
+		},
+		parserJsonc ? {
+			name: buildConfigName(MAIN_SCOPES.JSON, SUB_SCOPES.PARSER),
+			files: [
+				GLOB_JSON,
+				GLOB_JSONC,
+				GLOB_JSON5
+			],
+			languageOptions: { parser: parserJsonc }
+		} : void 0,
+		createRulesConfig("json"),
+		createRulesConfig("jsonc"),
+		...jsoncSortConfigs,
+		createRulesConfig("json5")
+	].filter(Boolean);
+};
+
+//#endregion
+//#region src/js/eslint/configs/markdown.ts
+const extractRelevantValues = (identifier, configs$1, key) => {
+	for (const config of configs$1) if (config.name === `markdown/${key}` && config[identifier] !== void 0 && config[identifier] !== null) return config[identifier];
+	throw new Error(`Expected key "${key}" to be contained in given config.`);
+};
+const markdown = async (options) => {
+	const { requiredAll: [pluginMarkdown, eslintMergeProcessors] } = await resolvePackages(MODULES.markdown);
+	if (!pluginMarkdown || !eslintMergeProcessors) return [];
+	const language = options?.language ?? "markdown/commonmark";
+	const frontmatter = options?.frontmatter ?? false;
+	const { mergeProcessors, processorPassThrough } = eslintMergeProcessors;
+	return [
+		{
+			name: buildConfigName(MAIN_SCOPES.MARKDOWN, SUB_SCOPES.SETUP),
+			plugins: { markdown: pluginMarkdown }
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.MARKDOWN, SUB_SCOPES.PROCESSOR),
+			files: [GLOB_MD],
+			processor: mergeProcessors([pluginMarkdown.processors.markdown, processorPassThrough])
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.MARKDOWN, SUB_SCOPES.RULES),
+			files: [GLOB_MD],
+			language,
+			languageOptions: { frontmatter },
+			rules: {
+				...extractRelevantValues("rules", pluginMarkdown.configs.recommended, "recommended"),
+				"markdown/no-bare-urls": "error",
+				"markdown/no-duplicate-headings": ["error", { checkSiblingsOnly: true }],
+				"markdown/no-html": ["error", { allowed: [
+					"a",
+					"br",
+					"dd",
+					"del",
+					"details",
+					"div",
+					"dl",
+					"dt",
+					"h1",
+					"img",
+					"ins",
+					"kbd",
+					"p",
+					"q",
+					"rp",
+					"rt",
+					"ruby",
+					"samp",
+					"sub",
+					"summary",
+					"sup",
+					"var"
+				] }]
+			}
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.MARKDOWN, `${SUB_SCOPES.RULES}-code-blocks`),
+			files: extractRelevantValues("files", pluginMarkdown.configs.processor, "recommended/code-blocks"),
+			languageOptions: extractRelevantValues("languageOptions", pluginMarkdown.configs.processor, "recommended/code-blocks"),
+			rules: {
+				...extractRelevantValues("rules", pluginMarkdown.configs.processor, "recommended/code-blocks"),
+				"no-alert": "off",
+				"no-console": "off",
+				"no-inline-comments": "off",
+				"import/no-default-export": "off",
+				"import/unambiguous": "off",
+				"node/no-missing-import": "off",
+				"ts/no-redeclare": "off",
+				"ts/no-unused-vars": "off",
+				"unused/no-unused-imports": "off",
+				"unused/no-unused-vars": "off"
+			}
+		}
+	];
+};
+
+//#endregion
+//#region src/js/eslint/configs/node.ts
+const node = async (options) => {
+	const { requiredAll: [pluginNode] } = await resolvePackages(MODULES.node);
+	if (!pluginNode) return [];
+	return [{
+		name: buildConfigName(MAIN_SCOPES.NODE, SUB_SCOPES.SETUP),
+		plugins: { node: pluginNode },
+		settings: { n: { version: options?.version ?? process.versions.node } }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.NODE, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			...renameRules(pluginNode.configs["flat/recommended"].rules, { n: "node" }),
+			"node/exports-style": "error",
+			"node/global-require": "error",
+			"node/handle-callback-err": "error",
+			"node/no-missing-import": "error",
+			"node/no-mixed-requires": "error",
+			"node/no-new-require": "error",
+			"node/no-path-concat": "error",
+			"node/no-process-env": "error",
+			"node/no-sync": "error",
+			"node/prefer-global/buffer": "error",
+			"node/prefer-global/console": "error",
+			"node/prefer-global/process": "error",
+			"node/prefer-global/text-decoder": "error",
+			"node/prefer-global/text-encoder": "error",
+			"node/prefer-global/url-search-params": "error",
+			"node/prefer-global/url": "error",
+			"node/prefer-node-protocol": "error",
+			"node/prefer-promises/dns": "error",
+			"node/prefer-promises/fs": "error"
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/unicorn.ts
+const FILE_NAMES_TO_IGNORE = [
+	"ACKNOWLEDGMENTS.md",
+	"ADOPTERS.md",
+	"AGENTS.md",
+	"API_REFERENCE.md",
+	"ARCHITECTURE.md",
+	"AUTHORS.md",
+	"BUILD.md",
+	"CHANGELOG.md",
+	"CODE_OF_CONDUCT.md",
+	"CODEOWNERS.md",
+	"CODING_STANDARDS.md",
+	"COMMUNITY_GUIDELINES.md",
+	"CONFIGURATION.md",
+	"CONTRIBUTING.md",
+	"CONTRIBUTORS.md",
+	"DATA_CARD.md",
+	"DATA_MODEL.md",
+	"DATA_PRIVACY.md",
+	"DEPENDENCIES.md",
+	"DESIGN.md",
+	"DEVELOPMENT.md",
+	"ETHICS.md",
+	"EVALUATION.md",
+	"FAQ.md",
+	"GOVERNANCE.md",
+	"INSTALL.md",
+	"ISSUE_TEMPLATE.md",
+	"LICENSE.md",
+	"LLMS.md",
+	"LOCALIZATION.md",
+	"MAINTAINERS.md",
+	"MEETING_NOTES.md",
+	"MIGRATIONS.md",
+	"ML_LIFECYCLE.md",
+	"ML_PIPELINE.md",
+	"MLOPS.md",
+	"MODEL_CARD.md",
+	"MODEL_MONITORING.md",
+	"NFR.md",
+	"OVERVIEW.md",
+	"PERFORMANCE.md",
+	"PROJECT_METADATA.md",
+	"PULL_REQUEST_TEMPLATE.md",
+	"README.md",
+	"REFERENCES.md",
+	"RELEASE_PROCESS.md",
+	"RELEASING.md",
+	"RESEARCH.md",
+	"ROADMAP.md",
+	"SPEC.md",
+	"SECURITY_POLICY.md",
+	"SECURITY.md",
+	"STYLE_GUIDE.md",
+	"SUPPORT.md",
+	"TESTING.md",
+	"THIRD_PARTY.md",
+	"THREAT_MODEL.md",
+	"TROUBLESHOOTING.md",
+	"UPGRADE_NOTES.md",
+	"VERSIONING.md"
+];
+const unicorn = async () => {
+	const { requiredAll: [pluginUnicorn] } = await resolvePackages(MODULES.unicorn);
+	if (!pluginUnicorn) return [];
+	return [{
+		name: buildConfigName(MAIN_SCOPES.UNICORN, SUB_SCOPES.SETUP),
+		plugins: { unicorn: pluginUnicorn }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.UNICORN, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			...pluginUnicorn.configs.recommended.rules,
+			"unicorn/better-regex": "error",
+			"unicorn/consistent-destructuring": "error",
+			"unicorn/custom-error-definition": "error",
+			"unicorn/filename-case": ["error", {
+				case: "kebabCase",
+				ignore: FILE_NAMES_TO_IGNORE
+			}],
+			"unicorn/require-post-message-target-origin": "error",
+			"unicorn/no-keyword-prefix": "error",
+			"unicorn/no-nested-ternay": "off",
+			"no-nested-ternary": "error",
+			"unicorn/no-unused-properties": "error",
+			"unicorn/prefer-json-parse-buffer": "error",
+			"unicorn/prefer-switch": "off",
+			"unicorn/string-content": ["error", { patterns: {
+				"\\.\\.\\.": "…",
+				"^http:\\/\\/": String.raw`^https:\/\/`
+			} }]
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/overrides.ts
+const jsOverrides = [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.JAVASCRIPT}/scripts`),
+	files: GLOB_SCRIPT_FILES.map((glob) => `scripts/${glob}`),
+	languageOptions: {
+		sourceType: "script",
+		parserOptions: { sourceType: "script" }
+	},
+	rules: {
+		"no-console": "off",
+		strict: ["error", "global"]
+	}
+}, {
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.JAVASCRIPT}/cjs`),
+	files: [GLOB_CJS],
+	languageOptions: {
+		sourceType: "commonjs",
+		parserOptions: { sourceType: "commonjs" }
+	},
+	rules: {
+		strict: ["error", "global"],
+		"unicorn/prefer-module": "off",
+		"ts/no-require-imports": "off"
+	}
+}];
+const tsOverrides = isModuleEnabled(MODULES.typescript) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.TYPESCRIPT}/ts`),
+	files: [GLOB_TS],
+	rules: {
+		strict: "off",
+		"node/no-missing-import": "off"
+	}
+}, {
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.TYPESCRIPT}/dts`),
+	files: [GLOB_DTS],
+	rules: {
+		"max-lines": "off",
+		"no-restricted-syntax": "off",
+		"no-var": "off",
+		"vars-on-top": "off",
+		"comments/no-unlimited-disable": "off",
+		"import/no-extraneous-dependencies": "off",
+		"import/unambiguous": "off"
+	}
+}] : [];
+const testOverrides = isModuleEnabled(MODULES.test) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.TEST}/general`),
+	files: GLOB_TEST_FILES,
+	rules: { "node/no-sync": "off" }
+}] : [];
+const unicornOverrides = isModuleEnabled(MODULES.unicorn) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.UNICORN}/general`),
+	files: [...GLOB_SCRIPT_FILES.map((glob) => `**/classes/${glob}`), ...GLOB_SCRIPT_FILES.map((glob) => `**/errors/${glob}`)],
+	rules: { "unicorn/filename-case": ["error", {
+		case: "pascalCase",
+		ignore: FILE_NAMES_TO_IGNORE
+	}] }
+}] : [];
+const jsdocOverrides = isModuleEnabled(MODULES.jsdoc) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.JSDOC}/${SUB_SCOPES.EXAMPLES}`),
+	files: [GLOB_EXAMPLES],
+	rules: {
+		"no-console": "off",
+		"no-undef": "off",
+		"no-unused-expressions": "off",
+		"no-unused-vars": "off",
+		"node/no-missing-import": "off",
+		"node/no-missing-require": "off",
+		strict: "off",
+		"import/no-unresolved": "off",
+		"import/unambiguous": "off",
+		"style/eol-last": "off",
+		"style/no-multiple-empty-lines": "off",
+		"ts/no-unused-expressions": "off",
+		"ts/no-unused-vars": "off"
+	}
+}, {
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.JSDOC}/default-expressions`),
+	files: [
+		"**/*.jsdoc-defaults",
+		"**/*.jsdoc-params",
+		"**/*.jsdoc-properties"
+	],
+	rules: {
+		"no-empty-function": "off",
+		"no-new": "off",
+		strict: "off",
+		"import/unambiguous": "off",
+		"style/eol-last": "off",
+		"style/no-extra-parens": "off",
+		"style/semi": "off"
+	}
+}] : [];
+const svelteOverrides = isModuleEnabled(MODULES.svelte) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.SVELTE}/general`),
+	files: [GLOB_SVELTE],
+	rules: {
+		"no-inner-declarations": "off",
+		"no-self-assign": "off",
+		"import/no-rename-default": "off",
+		"import/unambiguous": "off",
+		"svelte/comment-directive": ["error", { reportUnusedDisableDirectives: true }],
+		"svelte/system": "error"
+	}
+}, {
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.SVELTE}/components`),
+	files: [`**/components/${GLOB_SVELTE}`],
+	rules: { "unicorn/filename-case": ["error", { case: "pascalCase" }] }
+}] : [];
+const tomlOverrides = isModuleEnabled(MODULES.toml) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.TOML}/general`),
+	files: [GLOB_TOML],
+	rules: { "no-irregular-whitespace": "off" }
+}] : [];
+const yamlOverrides = isModuleEnabled(MODULES.yaml) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.YAML}/general`),
+	files: [GLOB_YAML],
+	rules: {
+		"no-irregular-whitespace": "off",
+		"no-unused-vars": "off"
+	}
+}] : [];
+const overrides = () => [
+	...jsOverrides,
+	...tsOverrides,
+	...testOverrides,
+	...unicornOverrides,
+	...jsdocOverrides,
+	...svelteOverrides,
+	...tomlOverrides,
+	...yamlOverrides,
+	{
+		name: buildConfigName(MAIN_SCOPES.OVERRIDES, SUB_SCOPES.DEVELOPMENT),
+		files: GLOB_DEVELOPMENT_FILES,
+		rules: {
+			"max-lines": "off",
+			"max-lines-per-function": "off",
+			"no-irregular-whitespace": "off",
+			"no-restricted-exports": "off",
+			"import/max-dependencies": "off",
+			"import/no-default-export": "off",
+			"import/no-rename-default": "off",
+			"import/no-named-as-default-member": "off",
+			"node/no-sync": "off"
+		}
+	}
+];
+
+//#endregion
+//#region src/js/eslint/configs/perfectionist.ts
+const perfectionist = async () => {
+	const { requiredAll: [pluginPerfectionist] } = await resolvePackages(MODULES.perfectionist);
+	if (!pluginPerfectionist) return [];
+	return [{
+		name: buildConfigName(MAIN_SCOPES.PERFECTIONIST, SUB_SCOPES.SETUP),
+		plugins: { perfectionist: pluginPerfectionist }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.PERFECTIONIST, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			"perfectionist/sort-array-includes": "error",
+			"perfectionist/sort-heritage-clauses": "error",
+			"perfectionist/sort-maps": "error",
+			"perfectionist/sort-named-exports": "error",
+			"perfectionist/sort-sets": "error",
+			"perfectionist/sort-switch-case": "error"
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/regexp.ts
+const regexp = async () => {
+	const { requiredAll: [pluginRegExp] } = await resolvePackages(MODULES.regexp);
+	if (!pluginRegExp) return [];
+	return [{
+		name: buildConfigName(MAIN_SCOPES.REGEXP, SUB_SCOPES.SETUP),
+		plugins: { regexp: pluginRegExp }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.REGEXP, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			...pluginRegExp.configs.recommended.rules,
+			"regexp/confusing-quantifier": "error",
+			"regexp/grapheme-string-literal": "error",
+			"regexp/letter-case": ["error", {
+				caseInsensitive: "lowercase",
+				unicodeEscape: "lowercase",
+				hexadecimalEscape: "lowercase",
+				controlEscape: "uppercase"
+			}],
+			"regexp/no-control-character": "error",
+			"regexp/no-empty-alternative": "error",
+			"regexp/no-lazy-ends": "error",
+			"regexp/no-octal": "error",
+			"regexp/no-potentially-useless-backreference": "error",
+			"regexp/no-standalone-backslash": "error",
+			"regexp/no-super-linear-move": "error",
+			"regexp/no-useless-flag": "error",
+			"regexp/optimal-lookaround-quantifier": "error",
+			"regexp/prefer-escape-replacement-dollar-char": "error",
+			"regexp/prefer-lookaround": "error",
+			"regexp/prefer-named-backreference": "error",
+			"regexp/prefer-named-capture-group": "error",
+			"regexp/prefer-named-replacement": "error",
+			"regexp/prefer-quantifier": "error",
+			"regexp/prefer-regexp-exec": "error",
+			"regexp/prefer-regexp-test": "error",
+			"regexp/prefer-result-array-groups": "error",
+			"regexp/require-unicode-sets-regexp": "error",
+			"regexp/sort-alternatives": "error",
+			"regexp/sort-character-class-elements": "error",
+			"regexp/unicode-escape": "error",
+			"regexp/unicode-property": ["error", {
+				generalCategory: "never",
+				key: "short",
+				property: "long"
+			}]
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/style.ts
+const style = async () => {
+	const { requiredAll: [pluginStyle] } = await resolvePackages(MODULES.style);
+	if (!pluginStyle) return [];
+	const styleConfig = pluginStyle.configs.customize({
+		jsx: true,
+		semi: true,
+		indent: INDENT,
+		quotes: "single",
+		quoteProps: "as-needed",
+		arrowParens: true,
+		blockSpacing: true,
+		braceStyle: "1tbs",
+		commaDangle: "always-multiline"
+	});
+	const indentRuleConfig = Array.isArray(styleConfig.rules?.["@stylistic/indent"]) && typeof styleConfig.rules["@stylistic/indent"][2] === "object" && styleConfig.rules["@stylistic/indent"][2] !== null ? styleConfig.rules["@stylistic/indent"][2] : void 0;
+	return [{
+		name: buildConfigName(MAIN_SCOPES.STYLE, SUB_SCOPES.SETUP),
+		plugins: { style: pluginStyle }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.STYLE, SUB_SCOPES.RULES),
+		files: GLOB_SCRIPT_FILES,
+		rules: {
+			...renameRules(styleConfig.rules, { "@stylistic": "style" }),
+			"style/array-bracket-newline": ["error", "consistent"],
+			"style/array-element-newline": ["error", "consistent"],
+			"style/function-call-argument-newline": ["error", "consistent"],
+			"style/function-call-spacing": "error",
+			"style/function-paren-newline": ["error", "multiline-arguments"],
+			"style/generator-star-spacing": ["error", {
+				before: false,
+				after: true,
+				method: "before",
+				shorthand: "neither"
+			}],
+			"style/implicit-arrow-linebreak": "error",
+			"style/indent": [
+				"error",
+				INDENT,
+				{
+					...indentRuleConfig,
+					offsetTernaryExpressions: false
+				}
+			],
+			"style/jsx-child-element-spacing": "error",
+			"style/jsx-pascal-case": "error",
+			"style/jsx-self-closing-comp": "error",
+			"style/line-comment-position": "error",
+			"style/linebreak-style": "error",
+			"style/lines-around-comment": ["error", {
+				beforeBlockComment: true,
+				afterHashbangComment: true,
+				allowBlockStart: true,
+				allowObjectStart: true,
+				allowArrayStart: true,
+				allowClassStart: true,
+				allowEnumStart: true,
+				allowInterfaceStart: true,
+				allowModuleStart: true,
+				allowTypeStart: true
+			}],
+			"style/max-len": ["error", {
+				code: MAX_LEN,
+				tabWidth: INDENT,
+				ignoreUrls: true,
+				ignoreStrings: true,
+				ignoreComments: true
+			}],
+			"style/newline-per-chained-call": "error",
+			"style/no-confusing-arrow": "error",
+			"style/no-extra-parens": [
+				"error",
+				"all",
+				{
+					ignoredNodes: [
+						"ArrowFunctionExpression[body.type=ConditionalExpression]",
+						"SpreadElement[argument.type=ConditionalExpression]",
+						"SpreadElement[argument.type=LogicalExpression]",
+						"SpreadElement[argument.type=AwaitExpression]"
+					],
+					nestedBinaryExpressions: false,
+					nestedConditionalExpressions: false,
+					ternaryOperandBinaryExpressions: false
+				}
+			],
+			"style/no-extra-semi": "error",
+			"style/no-mixed-operators": ["error", {
+				allowSamePrecedence: false,
+				groups: [
+					[
+						"+",
+						"-",
+						"*",
+						"/",
+						"%",
+						"**",
+						"??"
+					],
+					[
+						"&",
+						"|",
+						"^",
+						"~",
+						"<<",
+						">>",
+						">>>",
+						"??"
+					],
+					[
+						"==",
+						"!=",
+						"===",
+						"!==",
+						">",
+						">=",
+						"<",
+						"<=",
+						"??"
+					],
+					[
+						"&&",
+						"||",
+						"?:",
+						"??"
+					],
+					[
+						"in",
+						"instanceof",
+						"??"
+					]
+				]
+			}],
+			"style/nonblock-statement-body-position": ["error", "below"],
+			"style/object-curly-newline": ["error", {
+				ObjectExpression: {
+					minProperties: 4,
+					multiline: true,
+					consistent: true
+				},
+				ObjectPattern: {
+					minProperties: 4,
+					multiline: true,
+					consistent: true
+				},
+				ImportDeclaration: {
+					minProperties: 4,
+					multiline: true,
+					consistent: true
+				},
+				ExportDeclaration: {
+					minProperties: 4,
+					multiline: true,
+					consistent: true
+				}
+			}],
+			"style/object-property-newline": ["error", { allowAllPropertiesOnSameLine: true }],
+			"style/one-var-declaration-per-line": ["error", "always"],
+			"style/operator-linebreak": [
+				"error",
+				"before",
+				{ overrides: { "=": "none" } }
+			],
+			"style/padding-line-between-statements": [
+				"error",
+				{
+					blankLine: "always",
+					prev: "*",
+					next: [
+						"block-like",
+						"block",
+						"break",
+						"class",
+						"continue",
+						"enum",
+						"expression",
+						"function-overload",
+						"interface",
+						"multiline-return",
+						"multiline-const",
+						"multiline-export",
+						"multiline-expression",
+						"multiline-let",
+						"multiline-var",
+						"return",
+						"singleline-const",
+						"singleline-export",
+						"singleline-let",
+						"singleline-var",
+						"throw",
+						"type"
+					]
+				},
+				{
+					blankLine: "always",
+					next: "*",
+					prev: [
+						"block-like",
+						"block",
+						"class",
+						"directive",
+						"enum",
+						"expression",
+						"interface",
+						"multiline-const",
+						"multiline-export",
+						"multiline-expression",
+						"multiline-let",
+						"multiline-var",
+						"singleline-const",
+						"singleline-export",
+						"singleline-let",
+						"singleline-var"
+					]
+				},
+				{
+					blankLine: "never",
+					prev: [
+						"singleline-const",
+						"singleline-let",
+						"singleline-var"
+					],
+					next: [
+						"singleline-const",
+						"singleline-let",
+						"singleline-var"
+					]
+				},
+				{
+					blankLine: "never",
+					prev: ["singleline-export"],
+					next: ["singleline-export"]
+				},
+				{
+					blankLine: "never",
+					prev: "function-overload",
+					next: ["function", "function-overload"]
+				},
+				{
+					blankLine: "never",
+					prev: "directive",
+					next: "directive"
+				},
+				{
+					blankLine: "any",
+					prev: "expression",
+					next: "expression"
+				},
+				{
+					blankLine: "always",
+					prev: "*",
+					next: "multiline-expression"
+				},
+				{
+					blankLine: "always",
+					prev: "multiline-expression",
+					next: "*"
+				},
+				{
+					blankLine: "never",
+					prev: "type",
+					next: "type"
+				},
+				{
+					blankLine: "always",
+					prev: "multiline-type",
+					next: "type"
+				},
+				{
+					blankLine: "always",
+					prev: "type",
+					next: "multiline-type"
+				},
+				{
+					blankLine: "always",
+					prev: "multiline-type",
+					next: "multiline-type"
+				},
+				{
+					blankLine: "always",
+					prev: "cjs-import",
+					next: ["*"]
+				},
+				{
+					blankLine: "any",
+					prev: "cjs-import",
+					next: "cjs-import"
+				},
+				{
+					blankLine: "always",
+					next: "*",
+					prev: "cjs-export"
+				}
+			],
+			"style/semi-style": "error",
+			"style/switch-colon-spacing": "error",
+			"style/yield-star-spacing": ["error", {
+				before: false,
+				after: true
+			}]
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/svelte.ts
+const extractRelevantConfig = (configs$1, key) => {
+	for (const config of configs$1) if (config.name === `svelte:${key}` && config.rules) return config;
+	throw new Error(`Expected key "${key}" to be contained in given config.`);
+};
+const svelte = async () => {
+	const { requiredAll: [isSvelteInstalled, pluginSvelte] } = await resolvePackages(MODULES.svelte);
+	if (!isSvelteInstalled || !pluginSvelte) return [];
+	return [
+		{
+			name: buildConfigName(MAIN_SCOPES.SVELTE, SUB_SCOPES.SETUP),
+			plugins: { svelte: pluginSvelte }
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.SVELTE, SUB_SCOPES.PARSER),
+			files: [GLOB_SVELTE, GLOB_SVELTE_SCRIPT],
+			languageOptions: {
+				parser: extractRelevantConfig(pluginSvelte.configs["flat/base"], "base:setup-for-svelte").languageOptions?.["parser"],
+				parserOptions: {
+					extraFileExtensions: [".svelte"],
+					parser: await getTsEslintParserIfExists()
+				}
+			}
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.SVELTE, SUB_SCOPES.PROCESSOR),
+			files: [GLOB_SVELTE],
+			processor: pluginSvelte.processors.svelte
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.SVELTE, SUB_SCOPES.RULES),
+			files: [GLOB_SVELTE, GLOB_SVELTE_SCRIPT],
+			rules: {
+				...extractRelevantConfig(pluginSvelte.configs["flat/recommended"], "recommended:rules").rules,
+				"svelte/block-lang": ["error", {
+					enforceScriptPresent: false,
+					enforceStylePresent: false,
+					script: ["ts", null],
+					style: ["scss", null]
+				}],
+				"svelte/button-has-type": "error",
+				"svelte/consistent-selector-style": ["error", {
+					checkGlobal: false,
+					style: [
+						"type",
+						"class",
+						"id"
+					]
+				}],
+				"svelte/derived-has-same-inputs-outputs": "error",
+				"svelte/experimental-require-strict-events": "error",
+				"svelte/experimental-require-slot-types": "error",
+				"svelte/first-attribute-linebreak": "error",
+				"svelte/html-closing-bracket-new-line": "error",
+				"svelte/html-closing-bracket-spacing": ["error", { selfClosingTag: "never" }],
+				"svelte/html-quotes": "error",
+				"svelte/html-self-closing": ["error", {
+					normal: "ignore",
+					void: "never"
+				}],
+				"style/indent": "off",
+				"svelte/indent": ["error", { indent: INDENT }],
+				"svelte/max-attributes-per-line": ["error", {
+					multiline: 1,
+					singleline: 3
+				}],
+				"svelte/mustache-spacing": "error",
+				"svelte/no-add-event-listener": "error",
+				"svelte/no-at-debug-tags": "error",
+				"svelte/no-extra-reactive-curlies": "error",
+				"svelte/no-ignored-unsubscribe": "error",
+				"svelte/no-inline-styles": "error",
+				"svelte/no-inspect": "error",
+				"svelte/no-spaces-around-equal-signs-in-attribute": "error",
+				"svelte/no-target-blank": "error",
+				"svelte/no-top-level-browser-globals": "error",
+				"style/no-trailing-spaces": "off",
+				"svelte/no-trailing-spaces": "error",
+				"svelte/prefer-class-directive": "error",
+				"prefer-const": "off",
+				"svelte/prefer-const": "error",
+				"svelte/prefer-destructured-store-props": "error",
+				"svelte/prefer-style-directive": "error",
+				"svelte/require-event-prefix": "error",
+				"svelte/require-optimized-style-attribute": "error",
+				"svelte/require-store-callbacks-use-set-param": "error",
+				"svelte/require-stores-init": "error",
+				"svelte/shorthand-attribute": "error",
+				"svelte/shorthand-directive": "error",
+				"svelte/sort-attributes": "error",
+				"svelte/spaced-html-comment": "error",
+				"svelte/valid-compile": "error",
+				"svelte/valid-style-parse": "error"
+			}
+		}
+	];
+};
+
+//#endregion
+//#region src/js/eslint/configs/test.ts
+const test = async () => {
+	const { requiredAll: [pluginVitest] } = await resolvePackages(MODULES.test);
+	if (!pluginVitest) return [];
+	return [{
+		name: buildConfigName(MAIN_SCOPES.TEST, SUB_SCOPES.SETUP),
+		plugins: { test: pluginVitest }
+	}, {
+		name: buildConfigName(MAIN_SCOPES.TEST, SUB_SCOPES.RULES),
+		files: GLOB_TEST_FILES,
+		rules: {
+			...renameRules(pluginVitest.configs.recommended.rules, { vitest: "test" }),
+			"test/consistent-each-for": ["error", {
+				test: "each",
+				it: "each",
+				describe: "each",
+				suite: "each"
+			}],
+			"test/consistent-test-filename": "error",
+			"test/consistent-test-it": "error",
+			"test/consistent-vitest-vi": "error",
+			"test/hoisted-apis-on-top": "error",
+			"test/no-alias-methods": "error",
+			"test/no-conditional-in-test": "error",
+			"test/no-conditional-tests": "error",
+			"test/no-duplicate-hooks": "error",
+			"test/no-test-prefixes": "error",
+			"test/no-test-return-statement": "error",
+			"test/padding-around-all": "error",
+			"test/prefer-called-once": "error",
+			"test/prefer-called-with": "error",
+			"test/prefer-comparison-matcher": "error",
+			"test/prefer-each": "error",
+			"test/prefer-equality-matcher": "error",
+			"test/prefer-expect-resolves": "error",
+			"test/prefer-expect-type-of": "error",
+			"test/prefer-hooks-in-order": "error",
+			"test/prefer-hooks-on-top": "error",
+			"test/prefer-import-in-mock": "error",
+			"test/prefer-importing-vitest-globals": "error",
+			"test/prefer-lowercase-title": "error",
+			"test/prefer-mock-promise-shorthand": "error",
+			"test/prefer-snapshot-hint": "error",
+			"test/prefer-spy-on": "error",
+			"test/prefer-strict-boolean-matchers": "error",
+			"test/prefer-strict-equal": "error",
+			"test/prefer-to-be-object": "error",
+			"test/prefer-to-be": "error",
+			"test/prefer-to-contain": "error",
+			"test/prefer-to-have-length": "error",
+			"test/prefer-todo": "error",
+			"test/prefer-vi-mocked": "error",
+			"test/require-awaited-expect-poll": "error",
+			"test/require-hook": "error",
+			"test/require-mock-type-parameters": "error",
+			"test/warn-todo": "error"
+		}
+	}];
+};
+
+//#endregion
+//#region src/js/eslint/configs/toml.ts
+const toml = async () => {
+	const { requiredAll: [pluginToml, parserToml] } = await resolvePackages(MODULES.toml);
+	if (!pluginToml || !parserToml) return [];
+	return [
+		{
+			name: buildConfigName(MAIN_SCOPES.TOML, SUB_SCOPES.SETUP),
+			plugins: { toml: pluginToml }
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.TOML, SUB_SCOPES.PARSER),
+			files: [GLOB_TOML],
+			languageOptions: { parser: parserToml }
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.TOML, SUB_SCOPES.RULES),
+			files: [GLOB_TOML],
+			language: "toml/toml",
+			rules: {
+				...pluginToml.configs.standard[2]?.rules,
+				"toml/array-bracket-spacing": ["error", "never"],
+				"toml/indent": ["error", INDENT],
+				"toml/no-mixed-type-in-array": "error"
+			}
+		}
+	];
+};
+
+//#endregion
+//#region src/js/eslint/configs/yaml.ts
+const yaml = async () => {
+	const { requiredAll: [pluginYaml, parserYaml] } = await resolvePackages(MODULES.yaml);
+	if (!pluginYaml || !parserYaml) return [];
+	return [
+		{
+			name: buildConfigName(MAIN_SCOPES.YAML, SUB_SCOPES.SETUP),
+			plugins: { yaml: pluginYaml }
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.YAML, SUB_SCOPES.PARSER),
+			files: [GLOB_YAML],
+			languageOptions: { parser: parserYaml }
+		},
+		{
+			name: buildConfigName(MAIN_SCOPES.YAML, SUB_SCOPES.RULES),
+			files: [GLOB_YAML],
+			language: "yaml/yaml",
+			rules: {
+				...renameRules(pluginYaml.configs.standard[2]?.rules, { yml: "yaml" }),
+				"yaml/block-mapping-colon-indicator-newline": ["error", "never"],
+				"yaml/file-extension": "error",
+				"yaml/flow-mapping-curly-spacing": ["error", "always"],
+				"yaml/indent": ["error", INDENT],
+				"yaml/no-multiple-empty-lines": "error",
+				"yaml/no-trailing-zeros": "error",
+				"yaml/quotes": ["error", {
+					avoidEscape: true,
+					prefer: "single"
+				}],
+				"yaml/require-string-key": "error"
+			}
+		}
+	];
+};
+
+//#endregion
+//#region src/js/eslint/configs/index.ts
+const configs = {
+	[packageOrganization]: builtinConfig[packageOrganization],
+	comments,
+	css,
+	gitignore,
+	ignores,
+	import: imports,
+	javascript,
+	jsdoc,
+	json,
+	markdown,
+	node,
+	overrides,
+	perfectionist,
+	regexp,
+	style,
+	svelte,
+	test,
+	toml,
+	typescript,
+	unicorn,
+	yaml
+};
+
+//#endregion
+//#region src/js/eslint/index.ts
+const getConfig = (optionsAndGlobalConfig, ...additionalConfigs) => {
+	const resolvedOptions = {
+		[packageOrganization]: isModuleEnabledByDefault(MODULES[packageOrganization]),
+		comments: isModuleEnabledByDefault(MODULES.comments),
+		css: isModuleEnabledByDefault(MODULES.css),
+		gitignore: isModuleEnabledByDefault(MODULES.gitignore),
+		import: isModuleEnabledByDefault(MODULES.import),
+		jsdoc: isModuleEnabledByDefault(MODULES.jsdoc),
+		json: isModuleEnabledByDefault(MODULES.json),
+		markdown: isModuleEnabledByDefault(MODULES.markdown),
+		node: isModuleEnabledByDefault(MODULES.node),
+		perfectionist: isModuleEnabledByDefault(MODULES.perfectionist),
+		regexp: isModuleEnabledByDefault(MODULES.regexp),
+		style: isModuleEnabledByDefault(MODULES.style),
+		svelte: isModuleEnabledByDefault(MODULES.svelte),
+		test: isModuleEnabledByDefault(MODULES.test),
+		toml: isModuleEnabledByDefault(MODULES.toml),
+		typescript: isModuleEnabledByDefault(MODULES.typescript),
+		unicorn: isModuleEnabledByDefault(MODULES.unicorn),
+		yaml: isModuleEnabledByDefault(MODULES.yaml),
+		...optionsAndGlobalConfig
+	};
+	setModuleEnabled(MODULES[packageOrganization], resolvedOptions[packageOrganization]);
+	setModuleEnabled(MODULES.comments, resolvedOptions.comments);
+	setModuleEnabled(MODULES.css, resolvedOptions.css);
+	setModuleEnabled(MODULES.gitignore, resolvedOptions.gitignore !== false);
+	setModuleEnabled(MODULES.import, resolvedOptions.import);
+	setModuleEnabled(MODULES.jsdoc, resolvedOptions.jsdoc);
+	setModuleEnabled(MODULES.json, resolvedOptions.json);
+	setModuleEnabled(MODULES.markdown, resolvedOptions.markdown !== false);
+	setModuleEnabled(MODULES.node, resolvedOptions.node !== false);
+	setModuleEnabled(MODULES.perfectionist, resolvedOptions.perfectionist);
+	setModuleEnabled(MODULES.regexp, resolvedOptions.regexp);
+	setModuleEnabled(MODULES.style, resolvedOptions.style);
+	setModuleEnabled(MODULES.svelte, resolvedOptions.svelte);
+	setModuleEnabled(MODULES.test, resolvedOptions.test);
+	setModuleEnabled(MODULES.toml, resolvedOptions.toml);
+	setModuleEnabled(MODULES.typescript, resolvedOptions.typescript !== false);
+	setModuleEnabled(MODULES.unicorn, resolvedOptions.unicorn);
+	setModuleEnabled(MODULES.yaml, resolvedOptions.yaml);
+	const composer = new FlatConfigComposer();
+	const appendToComposer = (...configsToAppend) => {
+		composer.append(...configsToAppend);
+	};
+	appendToComposer(configs.ignores(resolvedOptions.ignores));
+	if (isModuleEnabled(MODULES.gitignore)) appendToComposer(configs.gitignore(typeof resolvedOptions.gitignore === "object" ? resolvedOptions.gitignore : { strict: false }));
+	appendToComposer(configs.javascript());
+	if (isModuleEnabled(MODULES.typescript)) appendToComposer(configs.typescript(typeof resolvedOptions.typescript === "object" ? resolvedOptions.typescript : void 0));
+	if (isModuleEnabled(MODULES.test)) appendToComposer(configs.test());
+	if (isModuleEnabled(MODULES.jsdoc)) appendToComposer(configs.jsdoc());
+	if (isModuleEnabled(MODULES.node)) appendToComposer(configs.node(typeof resolvedOptions.node === "object" ? resolvedOptions.node : void 0));
+	if (isModuleEnabled(MODULES[packageOrganization])) appendToComposer(configs[packageOrganization]());
+	if (isModuleEnabled(MODULES.comments)) appendToComposer(configs.comments());
+	if (isModuleEnabled(MODULES.regexp)) appendToComposer(configs.regexp());
+	if (isModuleEnabled(MODULES.unicorn)) appendToComposer(configs.unicorn());
+	if (isModuleEnabled(MODULES.import)) appendToComposer(configs.import());
+	if (isModuleEnabled(MODULES.style)) appendToComposer(configs.style());
+	if (isModuleEnabled(MODULES.perfectionist)) appendToComposer(configs.perfectionist());
+	if (isModuleEnabled(MODULES.svelte)) appendToComposer(configs.svelte());
+	if (isModuleEnabled(MODULES.json)) appendToComposer(configs.json());
+	if (isModuleEnabled(MODULES.toml)) appendToComposer(configs.toml());
+	if (isModuleEnabled(MODULES.yaml)) appendToComposer(configs.yaml());
+	if (isModuleEnabled(MODULES.css)) appendToComposer(configs.css());
+	if (isModuleEnabled(MODULES.markdown)) appendToComposer(configs.markdown(typeof resolvedOptions.markdown === "object" ? resolvedOptions.markdown : void 0));
+	appendToComposer(configs.overrides());
+	appendToComposer(...getUserConfigs(resolvedOptions, additionalConfigs));
+	return composer;
+};
+const getDefaultConfig = async () => getConfig();
+var eslint_default = getDefaultConfig;
+
+//#endregion
+export { eslint_default as default, getConfig };