@brnshkr/config 0.0.1-beta.2 → 0.0.1-beta.4

package/dist/eslint/index.mjs

@@ -1,11 +1,15 @@
-import { c as objectAssign, d as objectFromEntries, f as objectKeys, h as version, i as resolvePackagesSharedAsynchronously, l as objectEntries, m as packageOrganizationUpper, n as GLOB_IGNORES, o as ESLINT_PACKAGES, p as packageOrganization, r as isModuleEnabledByDefault, t as QUOTES, u as objectFreeze } from "../shared.mjs";
+import { C as objectAssign, D as objectValues, E as objectKeys, O as packageOrganization, S as isPlainObject, T as objectFromEntries, a as getMtime, c as toPosix$1, d as GLOB_TEST_FILES$1, f as createModuleState, h as resolvePackagesSharedAsynchronously, i as findNearestPackageJson, j as version, k as packageOrganizationUpper, l as GLOB_BENCHMARK_FILES, m as isModuleEnabledByDefault, n as QUOTES, o as readJsonObjectFile, p as doAllPackagesExist, r as doesFileExist, s as readTextFile, u as GLOB_IGNORES, v as ESLINT_PACKAGES, w as objectEntries } from "../shared.mjs";
 import { FlatConfigComposer } from "eslint-flat-config-utils";
+import fs from "node:fs";
+import path from "node:path";
+import { includeIgnoreFile } from "eslint/config";
 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
+/**
+* @internal @brnshkr/config/eslint
+*/
 const MAIN_SCOPES = {
 	[packageOrganizationUpper]: "builtin",
 	COMMENTS: "comments",
@@ -33,7 +37,7 @@ const SUB_SCOPES = {
 	BASE: "base",
 	DEVELOPMENT: "development",
 	EXAMPLES: "examples",
-	GIT: "git",
+	FILES: "files",
 	GLOBAL: "global",
 	PARSER: "parser",
 	PROCESSOR: "processor",
@@ -43,13 +47,16 @@ const SUB_SCOPES = {
 };
 //#endregion
 //#region ../src/js/eslint/utils/config.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 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];
+const renameRules = (rules, map) => objectFromEntries(objectEntries(rules ?? {}).map(([key, value]) => {
+	for (const [from, to] of objectEntries(map)) if (key.startsWith(`${from}/`)) return [to + key.slice(from.length), value];
 	return [key, value];
 }));
 const isValidGlobalAdditionalConfigKey = (key) => [
@@ -64,7 +71,7 @@ const isValidGlobalAdditionalConfigKey = (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;
+	if (objectKeys(config).length === 0) return;
 	config.name ??= buildConfigName(MAIN_SCOPES.USERLAND, SUB_SCOPES.GLOBAL);
 	return config;
 };
@@ -76,7 +83,7 @@ const ensureNamesForSyncAdditionalConfigs = (additionalConfigs) => {
 			validConfigs.push(config);
 			continue;
 		}
-		validConfigs.push(Object.keys(config).length > 0 ? config : void 0);
+		validConfigs.push(objectKeys(config).length > 0 ? config : void 0);
 		config.name = buildConfigName(MAIN_SCOPES.USERLAND, `${SUB_SCOPES.UNNAMED}-${String(currentIndex)}`);
 		currentIndex += 1;
 	}
@@ -85,6 +92,9 @@ const ensureNamesForSyncAdditionalConfigs = (additionalConfigs) => {
 const getUserConfigs = (resolvedOptions, additionalConfigs) => [getGlobalAdditionalConfig(resolvedOptions), ...ensureNamesForSyncAdditionalConfigs(additionalConfigs)];
 //#endregion
 //#region ../src/js/eslint/utils/globs.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const GLOB_CJS = "**/*.cjs";
 const GLOB_TS = "**/*.?(c|m)ts?(x)";
 const GLOB_DTS = "**/*.d.?(c|m)ts";
@@ -107,18 +117,1711 @@ const GLOB_SCRIPT_FILES = [
 const GLOB_SCRIPT_FILES_WITHOUT_TS = ["**/*.?(c|m)js?(x)", GLOB_DTS];
 const GLOB_DEVELOPMENT_FILES = [
 	"**/*.config.?(c|m)[jt]s",
+	"**/__mocks__/**",
 	"**/{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"
+const GLOB_YAML_FIXED_EXTENSION_FILES = [
+	"**/.circleci/**/*.yml",
+	"**/.github/**/*.yml",
+	"**/.gitlab-ci.yml",
+	"**/.gitlab/**/*.yml",
+	"**/.travis.yml",
+	"**/appveyor.yml"
+];
+const GLOB_TEST_FILES = [...GLOB_TEST_FILES$1, ...GLOB_BENCHMARK_FILES];
+//#endregion
+//#region ../src/js/eslint/utils/tsconfig.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const DEFAULT_TSCONFIG_FILENAME = "tsconfig.json";
+const JSONC_TOKEN_PATTERN = /"(?:[^"\\]|\\.)*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//gv;
+const TRAILING_COMMA_PATTERN = /,(?=\s*[\]\}])/gv;
+const stripJsonc = (input) => input.replaceAll(JSONC_TOKEN_PATTERN, (match) => match.startsWith("\"") ? match : "").replaceAll(TRAILING_COMMA_PATTERN, "");
+const parseTsConfigFile = (filePath) => {
+	try {
+		const content = fs.readFileSync(filePath, "utf-8");
+		return JSON.parse(stripJsonc(content));
+	} catch {
+		return;
+	}
+};
+const resolveExtends = (parentConfig, fromDirectory) => {
+	if (parentConfig.startsWith(".") || path.isAbsolute(parentConfig)) {
+		const resolved = path.resolve(fromDirectory, parentConfig);
+		return path.extname(resolved) === "" ? `${resolved}.json` : resolved;
+	}
+	return path.resolve(fromDirectory, "node_modules", parentConfig);
+};
+const normalizeExtends = (raw) => {
+	if (raw.extends === void 0) return [];
+	return Array.isArray(raw.extends) ? raw.extends : [raw.extends];
+};
+const loadInternal = (filePath, visitedPaths) => {
+	if (visitedPaths.has(filePath)) return;
+	visitedPaths.add(filePath);
+	const parsedConfig = parseTsConfigFile(filePath);
+	if (!parsedConfig) return;
+	const fromDirectory = path.dirname(filePath);
+	let compilerOptions = {};
+	for (const value of normalizeExtends(parsedConfig)) compilerOptions = {
+		...compilerOptions,
+		...loadInternal(resolveExtends(value, fromDirectory), visitedPaths)?.compilerOptions
+	};
+	return { compilerOptions: {
+		...compilerOptions,
+		...parsedConfig.compilerOptions
+	} };
+};
+const cache = /* @__PURE__ */ new Map();
+const toPosix = (filePath) => filePath.replaceAll("\\", "/");
+const loadTsConfigPaths = (tsConfigPath) => {
+	const absolutePath = path.resolve(tsConfigPath);
+	if (cache.has(absolutePath)) return cache.get(absolutePath);
+	const mergedConfig = loadInternal(absolutePath, /* @__PURE__ */ new Set());
+	const paths = mergedConfig?.compilerOptions?.paths;
+	if (!paths) {
+		cache.set(absolutePath, void 0);
+		return;
+	}
+	const baseUrl = path.resolve(path.dirname(absolutePath), mergedConfig.compilerOptions?.baseUrl ?? ".");
+	const result = objectFromEntries(objectEntries(paths).map(([pattern, targets]) => [pattern, targets.map((target) => toPosix(path.resolve(baseUrl, target)))]));
+	cache.set(absolutePath, result);
+	return result;
+};
+const doesTsConfigExist = (tsConfigPath) => {
+	try {
+		fs.accessSync(tsConfigPath, fs.constants.R_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const resolveTsConfigPath = (typescriptOptions) => {
+	let tsconfig = DEFAULT_TSCONFIG_FILENAME;
+	if (typescriptOptions) {
+		if (typeof typescriptOptions.typeAware === "string") tsconfig = typescriptOptions.typeAware;
+		else if (typeof typescriptOptions.typeAware === "object") tsconfig = typescriptOptions.typeAware.tsconfig ?? DEFAULT_TSCONFIG_FILENAME;
+	}
+	return path.resolve(process.cwd(), tsconfig);
+};
+//#endregion
+//#region ../src/js/eslint/utils/ast.ts
+const isFluentReturn = (returnType) => returnType?.typeAnnotation.type === "TSThisType";
+const isVoidLikeReturn = (returnType) => returnType === void 0 || returnType.typeAnnotation.type === "TSVoidKeyword" || returnType.typeAnnotation.type === "TSNeverKeyword";
+const resolveParameterIdentifier = (parameter) => {
+	if (parameter.type === "Identifier") return parameter;
+	if (parameter.type === "AssignmentPattern" && parameter.left.type === "Identifier") return parameter.left;
+	if (parameter.type === "RestElement" && parameter.argument.type === "Identifier") return parameter.argument;
+	if (parameter.type === "TSParameterProperty") return resolveParameterIdentifier(parameter.parameter);
+};
+const getParameterName = (parameter) => resolveParameterIdentifier(parameter)?.name;
+const isAccessibleMethod = (method) => method.accessibility !== "private" && method.accessibility !== "protected" && method.key.type !== "PrivateIdentifier";
+const isAbstractMethod = (method) => method.type === "TSAbstractMethodDefinition";
+const isClassMethodLike = (node) => node.type === "MethodDefinition" || node.type === "TSAbstractMethodDefinition";
+const getNamedKeyText = (key) => {
+	if (key.type === "Identifier" || key.type === "PrivateIdentifier") return key.name;
+	if (key.type === "Literal") return String(key.value);
+	return "<computed>";
+};
+const isFunctionInitializer = (candidate) => candidate?.type === "ArrowFunctionExpression" || candidate?.type === "FunctionExpression";
+const resolveFunctionShape = (declaration) => {
+	if (declaration.type === "VariableDeclarator") {
+		if (!isFunctionInitializer(declaration.init)) return;
+		return {
+			parameters: declaration.init.params,
+			returnType: declaration.init.returnType
+		};
+	}
+	return {
+		parameters: declaration.params,
+		returnType: declaration.returnType
+	};
+};
+const TAG_INTERNAL = "internal";
+const escapeRegExp = (value) => value.replaceAll(/[$\(\)*+.?\[\\\]^\{\|\}]/gv, String.raw`\$&`);
+const hasProseAfter = (pattern, comment) => {
+	const prose = pattern.exec(comment)?.groups?.["prose"];
+	return typeof prose === "string" && /[A-Za-z]/v.test(prose);
+};
+const isBlockComment = (comment) => comment?.type === "Block" && comment.value.startsWith("*");
+const extractBlockComment = (comments, node) => {
+	let expectedEndLine = node.loc.start.line - 1;
+	for (const comment of comments.toReversed()) {
+		if (comment.loc.end.line !== expectedEndLine) return;
+		expectedEndLine = comment.loc.start.line - 1;
+		if (isBlockComment(comment)) return `/*${comment.value}*/`;
+	}
+};
+const hasTag = (comment, tag) => comment !== void 0 && new RegExp(String.raw`@${tag}\b`, "v").test(comment);
+const hasDescription = (comment) => {
+	if (comment === void 0) return false;
+	const beforeTags = /\/\*\*(?<body>.*?)(?:\n[\t ]*\*[\t ]+@|\*\/)/sv.exec(comment)?.groups?.["body"] ?? "";
+	return /^[\t ]*\*[\t ]+[[^\s*\/]--@][^\n]*/mv.test(beforeTags);
+};
+const hasParameterProse = (comment, parameterName) => hasProseAfter(new RegExp(String.raw`@param\b[^\n]*?\b${escapeRegExp(parameterName)}\b(?<prose>[^\n]*)`, "v"), comment);
+const hasReturnsWithProse = (comment) => hasProseAfter(/@returns?\s+\S+\s+(?<prose>\S[^\n]*)/v, comment);
+const getVisibilityTag = (comment) => {
+	if (hasTag(comment, "internal")) return TAG_INTERNAL;
+	if (hasTag(comment, "api")) return "api";
+};
+const hasConflictingVisibilityTags = (comment) => hasTag(comment, "api") && hasTag(comment, "internal");
+const hasModuleSource = (node) => "source" in node && (node.source ?? void 0) !== void 0;
+const findFileLevelComment$1 = (sourceCode) => {
+	const [firstStatement] = sourceCode.ast.body;
+	if (firstStatement === void 0) return;
+	const leadingComments = sourceCode.getCommentsBefore(firstStatement).filter(isBlockComment);
+	const [fileComment] = leadingComments;
+	if (fileComment === void 0) return;
+	if (leadingComments.length > 1 || hasModuleSource(firstStatement)) return fileComment;
+	return firstStatement.loc.start.line - fileComment.loc.end.line > 1 ? fileComment : void 0;
+};
+const getFileLevelBlockComment = (sourceCode) => {
+	const comment = findFileLevelComment$1(sourceCode);
+	return comment === void 0 ? void 0 : `/*${comment.value}*/`;
+};
+const getEffectiveVisibilityTag = (symbolComment, fileComment) => getVisibilityTag(symbolComment) ?? getVisibilityTag(fileComment);
+//#endregion
+//#region ../src/js/eslint/utils/exports.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const DEFAULT_NAME = "default";
+const ANONYMOUS_NAME = "<anonymous>";
+const ATOMIC_NAMED_KIND_MAP = {
+	ClassDeclaration: "Class",
+	FunctionDeclaration: "Function",
+	TSDeclareFunction: "Function",
+	TSEnumDeclaration: "Enum",
+	TSInterfaceDeclaration: "Interface",
+	TSTypeAliasDeclaration: "Type"
+};
+const DEFAULT_KIND_MAP = {
+	ArrowFunctionExpression: "Function",
+	CallExpression: "Constant",
+	FunctionExpression: "Function",
+	Identifier: "Constant",
+	NewExpression: "Constant",
+	ObjectExpression: "Constant"
+};
+const collectAtomicNamedDeclaration = (declaration, anchor, comment) => {
+	const kind = ATOMIC_NAMED_KIND_MAP[declaration.type];
+	if (kind === void 0) return;
+	return {
+		anchor,
+		declaration,
+		comment,
+		kind,
+		name: declaration.id?.name ?? ANONYMOUS_NAME
+	};
+};
+const collectVariableDeclaration = (declaration, anchor, comment) => declaration.declarations.filter((declarator) => declarator.id.type === "Identifier").map((declarator) => ({
+	anchor,
+	declaration: declarator,
+	comment,
+	kind: isFunctionInitializer(declarator.init) ? "Function" : "Constant",
+	name: declarator.id.name
+}));
+const collectNamedDeclaration = (declaration, anchor, comment) => {
+	const atomic = collectAtomicNamedDeclaration(declaration, anchor, comment);
+	if (atomic !== void 0) return [atomic];
+	if (declaration.type === "VariableDeclaration") return collectVariableDeclaration(declaration, anchor, comment);
+	return [];
+};
+const collectDefaultDeclaration = (declaration, anchor, comment) => {
+	if (declaration.type === "ClassDeclaration" || declaration.type === "FunctionDeclaration") return collectNamedDeclaration(declaration, anchor, comment);
+	const kind = DEFAULT_KIND_MAP[declaration.type];
+	if (kind === void 0) return [];
+	return [{
+		anchor,
+		declaration,
+		comment,
+		kind,
+		name: declaration.type === "Identifier" ? declaration.name : DEFAULT_NAME
+	}];
+};
+const buildExportVisitors = (sourceCode, onSymbol) => {
+	const emit = (node, collectDeclaration) => {
+		if (!node.declaration) return;
+		const comment = extractBlockComment(sourceCode.getCommentsBefore(node), node);
+		for (const symbol of collectDeclaration(node.declaration, node, comment)) onSymbol(symbol);
+	};
+	return {
+		ExportDefaultDeclaration: (node) => {
+			emit(node, collectDefaultDeclaration);
+		},
+		ExportNamedDeclaration: (node) => {
+			emit(node, collectNamedDeclaration);
+		}
+	};
+};
+//#endregion
+//#region ../src/js/eslint/utils/package-exports.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const DEFAULT_DIST_ROOT = "./dist";
+const DEFAULT_SRC_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".d.ts",
+	".d.mts",
+	".d.cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".svelte",
+	".svelte.ts",
+	".svelte.js"
+];
+const SRC_ROOT_CANDIDATES = [
+	"./src",
+	"./src/js",
+	"./src/main",
+	"./source",
+	"./sources",
+	"./lib",
+	"."
+];
+const REEXPORT_NAME_PART = String.raw`(?:\*(?:\s+as\s+[\p{ID_Start}$_][\p{ID_Continue}$]*)?|\{[^\}]*\})`;
+const normalizeRoot = (value) => toPosix$1(value).replace(/^\.\//v, "").replace(/\/$/v, "");
+const collectStringEntries = (node, accumulator) => {
+	if (typeof node === "string") {
+		accumulator.push(node);
+		return;
+	}
+	if (Array.isArray(node)) {
+		for (const value of node) collectStringEntries(value, accumulator);
+		return;
+	}
+	if (!isPlainObject(node)) return;
+	for (const value of objectValues(node)) collectStringEntries(value, accumulator);
+};
+const findFirstExistingFile = (candidates) => {
+	for (const candidate of candidates) if (doesFileExist(candidate)) return toPosix$1(candidate);
+};
+const buildSourceCandidates = (baseAbsolute, sourceExtensions) => [...sourceExtensions.map((extension) => `${baseAbsolute}${extension}`), ...sourceExtensions.map((extension) => path.resolve(baseAbsolute, `index${extension}`))];
+const resolveSourceForDistributionFile = (distributionRelativePath, packageRoot, sourceRoot, sourceExtensions) => {
+	const baseAbsolute = path.resolve(packageRoot, sourceRoot, distributionRelativePath.replace(/(?:\.d\.[cm]?ts|\.[cm]?jsx?)$/v, ""));
+	return findFirstExistingFile(buildSourceCandidates(baseAbsolute, sourceExtensions));
+};
+const resolveImportSpecifier = (fromFilePath, specifier, sourceExtensions) => {
+	if (!specifier.startsWith(".")) return;
+	const absoluteBase = path.resolve(path.dirname(fromFilePath), specifier);
+	const candidates = buildSourceCandidates(absoluteBase, sourceExtensions);
+	return findFirstExistingFile(path.extname(absoluteBase) === "" ? candidates : [absoluteBase, ...candidates]);
+};
+const collectReexports = (entryPath, sourceExtensions, visitedPaths) => {
+	if (visitedPaths.has(entryPath)) return;
+	visitedPaths.add(entryPath);
+	const content = readTextFile(entryPath);
+	if (content === void 0) return;
+	const reexportPattern = new RegExp(String.raw`\bexport\s+(?:type\s+)?${REEXPORT_NAME_PART}\s+from\s+["'](?<specifier>[^"']+)["']`, "gv");
+	for (const match of content.matchAll(reexportPattern)) {
+		const specifier = match.groups?.["specifier"];
+		if (specifier === void 0) continue;
+		const resolvedPath = resolveImportSpecifier(entryPath, specifier, sourceExtensions);
+		if (resolvedPath !== void 0) collectReexports(resolvedPath, sourceExtensions, visitedPaths);
+	}
+};
+const stripPrefix = (filePath, normalizedPrefix) => {
+	const normalizedFile = toPosix$1(filePath).replace(/^\.\//v, "");
+	if (!normalizedFile.startsWith(normalizedPrefix)) return;
+	return normalizedFile.slice(normalizedPrefix.length);
+};
+const collectApiSourceFiles = (distributionRelativePaths, packageRoot, sourceRoots, sourceExtensions) => {
+	const apiSourceFiles = /* @__PURE__ */ new Set();
+	for (const distributionRelativePath of distributionRelativePaths) {
+		const resolvedPath = sourceRoots.values().map((sourceRoot) => resolveSourceForDistributionFile(distributionRelativePath, packageRoot, sourceRoot, sourceExtensions)).find((candidatePath) => candidatePath !== void 0);
+		if (resolvedPath !== void 0) collectReexports(resolvedPath, sourceExtensions, apiSourceFiles);
+	}
+	return apiSourceFiles;
+};
+const resolvePackageApiSources = (options) => {
+	const packageJsonPath = path.resolve(options.packageJsonPath);
+	const manifest = readJsonObjectFile(packageJsonPath);
+	if (manifest?.["exports"] === void 0) return;
+	const packageRoot = path.dirname(packageJsonPath);
+	const distributionRoot = options.distRoot ?? DEFAULT_DIST_ROOT;
+	const sourceExtensions = options.srcExtensions ?? DEFAULT_SRC_EXTENSIONS;
+	const sourceRoots = options.srcRoot === void 0 ? SRC_ROOT_CANDIDATES : [options.srcRoot];
+	const normalizedDistribution = `${normalizeRoot(distributionRoot)}/`;
+	const exportEntries = [];
+	collectStringEntries(manifest["exports"], exportEntries);
+	const distributionRelativePaths = exportEntries.filter((value) => value.startsWith("./") && !value.includes("*")).map((value) => stripPrefix(value, normalizedDistribution)).filter((value) => value !== void 0);
+	if (distributionRelativePaths.length === 0) return;
+	const apiSourceFiles = collectApiSourceFiles(distributionRelativePaths, packageRoot, sourceRoots, sourceExtensions);
+	if (apiSourceFiles.size === 0) return;
+	return {
+		packageJsonPath: toPosix$1(packageJsonPath),
+		packageRoot: toPosix$1(packageRoot),
+		distRoot: distributionRoot,
+		srcRoots: sourceRoots,
+		apiSourceFiles
+	};
+};
+//#endregion
+//#region ../src/js/eslint/utils/public-api.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const resolutionCache = /* @__PURE__ */ new Map();
+const getCacheKey = (options, cwd) => JSON.stringify({
+	cwd,
+	packageJsonPath: options.packageJsonPath,
+	distRoot: options.distRoot,
+	srcRoot: options.srcRoot,
+	srcExtensions: options.srcExtensions
+});
+const loadPublicApiResolution = (options, cwd) => {
+	const cacheKey = getCacheKey(options, cwd);
+	const packageJsonPath = options.packageJsonPath ?? findNearestPackageJson(cwd);
+	const mtime = packageJsonPath === void 0 ? void 0 : getMtime(packageJsonPath);
+	const cacheEntry = resolutionCache.get(cacheKey);
+	if (cacheEntry !== void 0 && cacheEntry.mtime === mtime) return cacheEntry.resolution;
+	const resolution = packageJsonPath === void 0 ? void 0 : resolvePackageApiSources({
+		packageJsonPath,
+		distRoot: options.distRoot,
+		srcRoot: options.srcRoot,
+		srcExtensions: options.srcExtensions
+	});
+	resolutionCache.set(cacheKey, {
+		mtime,
+		resolution
+	});
+	return resolution;
+};
+const isPublicApiFile = (options, cwd, filename) => {
+	const resolution = loadPublicApiResolution(options, cwd);
+	return resolution === void 0 ? false : resolution.apiSourceFiles.has(toPosix$1(path.resolve(filename)));
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/api-or-internal-tag.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const MESSAGE_ID_MISSING_TAG = "missingTag";
+const MESSAGE_ID_UNEXPECTED_TAG_CONFLICT = "unexpectedTagConflict";
+const MESSAGE_ID_UNEXPECTED_FILE_TAG_CONFLICT = "unexpectedFileTagConflict";
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/api-or-internal-tag.md
+*/
+const apiOrInternalTagRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require every exported declaration in a public-API source file to carry either an `@api` or an `@internal` tag, and never both; a file-level docblock carrying either tag covers all symbols below it.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/api-or-internal-tag.md"
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				packageJsonPath: { type: "string" },
+				distRoot: { type: "string" },
+				srcRoot: { type: "string" },
+				srcExtensions: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: {
+			[MESSAGE_ID_MISSING_TAG]: "{{ kind }} `{{ name }}` is exported from a public-API source file and must carry an `@api` or `@internal` JSDoc tag.",
+			[MESSAGE_ID_UNEXPECTED_TAG_CONFLICT]: "{{ kind }} `{{ name }}` must declare exactly one visibility, but carries both `@api` and `@internal`.",
+			[MESSAGE_ID_UNEXPECTED_FILE_TAG_CONFLICT]: "The file-level docblock must declare exactly one visibility, but carries both `@api` and `@internal`."
+		}
+	},
+	create: (context) => {
+		const options = context.options[0] ?? {};
+		const sourceCode = context.sourceCode;
+		const fileCommentNode = findFileLevelComment$1(sourceCode);
+		const fileComment = fileCommentNode === void 0 ? void 0 : `/*${fileCommentNode.value}*/`;
+		const isInPublicApiFile = isPublicApiFile(options, context.cwd, context.filename);
+		return {
+			...buildExportVisitors(sourceCode, (symbol) => {
+				if (hasConflictingVisibilityTags(symbol.comment)) {
+					context.report({
+						node: symbol.anchor,
+						messageId: MESSAGE_ID_UNEXPECTED_TAG_CONFLICT,
+						data: {
+							kind: symbol.kind,
+							name: symbol.name
+						}
+					});
+					return;
+				}
+				if (!isInPublicApiFile || getEffectiveVisibilityTag(symbol.comment, fileComment) !== void 0) return;
+				context.report({
+					node: symbol.anchor,
+					messageId: MESSAGE_ID_MISSING_TAG,
+					data: {
+						kind: symbol.kind,
+						name: symbol.name
+					}
+				});
+			}),
+			"Program:exit": () => {
+				if (fileCommentNode !== void 0 && hasConflictingVisibilityTags(fileComment)) context.report({
+					loc: fileCommentNode.loc,
+					messageId: MESSAGE_ID_UNEXPECTED_FILE_TAG_CONFLICT
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region ../src/js/eslint/utils/boolish-classification.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const TYPE_CLASSIFICATIONS = {
+	BOOL: "bool",
+	NON_BOOL: "non-bool",
+	UNKNOWN: "unknown"
+};
+const BOOLEAN_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"boolean",
+	"false",
+	"true"
+]);
+const NULLISH_TYPE_NAMES = /* @__PURE__ */ new Set(["null", "undefined"]);
+const UNRESOLVED_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"any",
+	"error",
+	"never",
+	"unknown"
+]);
+const BOOLEAN_TYPE_NODES = /* @__PURE__ */ new Set(["TSBooleanKeyword", "TSTypePredicate"]);
+const NULLISH_TYPE_NODES = /* @__PURE__ */ new Set(["TSNullKeyword", "TSUndefinedKeyword"]);
+const UNRESOLVED_TYPE_NODES = /* @__PURE__ */ new Set([
+	"TSAnyKeyword",
+	"TSConditionalType",
+	"TSImportType",
+	"TSIndexedAccessType",
+	"TSInferType",
+	"TSIntersectionType",
+	"TSMappedType",
+	"TSNeverKeyword",
+	"TSThisType",
+	"TSTypeOperator",
+	"TSTypeQuery",
+	"TSTypeReference",
+	"TSUnknownKeyword"
+]);
+const NON_BOOLEAN_EXPRESSIONS = /* @__PURE__ */ new Set([
+	"ArrayExpression",
+	"NewExpression",
+	"ObjectExpression",
+	"TemplateLiteral"
+]);
+const UNWRAPPED_EXPRESSIONS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion"
+]);
+const BOOLEAN_BINARY_OPERATORS = /* @__PURE__ */ new Set([
+	"!=",
+	"!==",
+	"<",
+	"<=",
+	"==",
+	"===",
+	">",
+	">=",
+	"in",
+	"instanceof"
+]);
+const BOOLEAN_CONSTRUCTOR_NAME = "Boolean";
+const PROMISE_TYPE_NAME = "Promise";
+const EXTERNAL_PATH_SEGMENT = "/node_modules/";
+const combineClassifications = (classifications) => {
+	if (classifications.length === 0) return TYPE_CLASSIFICATIONS.UNKNOWN;
+	if (classifications.every((classification) => classification === TYPE_CLASSIFICATIONS.BOOL)) return TYPE_CLASSIFICATIONS.BOOL;
+	return classifications.every((classification) => classification === TYPE_CLASSIFICATIONS.NON_BOOL) ? TYPE_CLASSIFICATIONS.NON_BOOL : TYPE_CLASSIFICATIONS.UNKNOWN;
+};
+const getTypeName = (checker, type) => checker.typeToString(checker.getBaseTypeOfLiteralType(type));
+const classifyPlainType = (checker, type) => {
+	const symbol = type.getSymbol();
+	if (type.isTypeParameter()) return TYPE_CLASSIFICATIONS.UNKNOWN;
+	if (symbol !== void 0) return TYPE_CLASSIFICATIONS.NON_BOOL;
+	const typeName = getTypeName(checker, type);
+	if (BOOLEAN_TYPE_NAMES.has(typeName)) return TYPE_CLASSIFICATIONS.BOOL;
+	return UNRESOLVED_TYPE_NAMES.has(typeName) ? TYPE_CLASSIFICATIONS.UNKNOWN : TYPE_CLASSIFICATIONS.NON_BOOL;
+};
+const classifyType = (checker, type) => {
+	if (!type.isUnion()) return classifyPlainType(checker, type);
+	return combineClassifications(type.types.filter((member) => !NULLISH_TYPE_NAMES.has(getTypeName(checker, member))).map((member) => classifyPlainType(checker, member)));
+};
+const unwrapPromiseType = (checker, type) => type.getSymbol()?.getName() === PROMISE_TYPE_NAME ? checker.getTypeArguments(type)[0] ?? type : type;
+const resolveReturnType = (checker, type) => {
+	const [signature] = type.getCallSignatures();
+	return signature === void 0 ? void 0 : unwrapPromiseType(checker, signature.getReturnType());
+};
+const isExternalSymbol = (symbol) => symbol.declarations?.some((declaration) => toPosix$1(declaration.getSourceFile().fileName).includes(EXTERNAL_PATH_SEGMENT)) ?? true;
+const resolveInstanceType = (type) => type.getConstructSignatures()[0]?.getReturnType() ?? type;
+const hasExternalUpstreamMember = (services, enclosingClass, name) => [...enclosingClass.superClass ? [enclosingClass.superClass] : [], ...enclosingClass.implements].some((heritageNode) => {
+	const member = resolveInstanceType(services.getTypeAtLocation(heritageNode)).getProperty(name);
+	return member !== void 0 && isExternalSymbol(member);
+});
+const classifyTypeAnnotation = (node) => {
+	if (node.type === "TSUnionType") return combineClassifications(node.types.filter((member) => !NULLISH_TYPE_NODES.has(member.type)).map((member) => classifyTypeAnnotation(member)));
+	if (node.type === "TSLiteralType") return node.literal.type === "Literal" && typeof node.literal.value === "boolean" ? TYPE_CLASSIFICATIONS.BOOL : TYPE_CLASSIFICATIONS.NON_BOOL;
+	if (BOOLEAN_TYPE_NODES.has(node.type)) return TYPE_CLASSIFICATIONS.BOOL;
+	return UNRESOLVED_TYPE_NODES.has(node.type) ? TYPE_CLASSIFICATIONS.UNKNOWN : TYPE_CLASSIFICATIONS.NON_BOOL;
+};
+const classifyBooleanOperator = (node) => {
+	if (node.type === "UnaryExpression") return node.operator === "!" ? TYPE_CLASSIFICATIONS.BOOL : TYPE_CLASSIFICATIONS.NON_BOOL;
+	if (node.type === "BinaryExpression") return BOOLEAN_BINARY_OPERATORS.has(node.operator) ? TYPE_CLASSIFICATIONS.BOOL : TYPE_CLASSIFICATIONS.NON_BOOL;
+	if (node.type === "CallExpression" && node.callee.type === "Identifier") return node.callee.name === BOOLEAN_CONSTRUCTOR_NAME ? TYPE_CLASSIFICATIONS.BOOL : void 0;
+};
+const classifyExpression = (node) => {
+	if (node.type === "Literal") return typeof node.value === "boolean" ? TYPE_CLASSIFICATIONS.BOOL : TYPE_CLASSIFICATIONS.NON_BOOL;
+	if (UNWRAPPED_EXPRESSIONS.has(node.type)) return classifyExpression(node.expression);
+	return NON_BOOLEAN_EXPRESSIONS.has(node.type) ? TYPE_CLASSIFICATIONS.NON_BOOL : classifyBooleanOperator(node) ?? TYPE_CLASSIFICATIONS.UNKNOWN;
+};
+//#endregion
+//#region ../src/js/eslint/utils/boolish-prefixes.ts
+/**
+* Auxiliary, modal, and copula verbs.
+* Boolish in either direction, on any kind.
+*/
+const AUXILIARY_PREFIXES = [
+	"are",
+	"can",
+	"did",
+	"does",
+	"has",
+	"is",
+	"may",
+	"should",
+	"was",
+	"will"
+];
+/**
+* Capability and need verbs.
+* Read as boolean value flags too, so boolish in either direction, on any kind.
+*/
+const CAPABILITY_PREFIXES = [
+	"expects",
+	"needs",
+	"prefers",
+	"requires",
+	"supports",
+	"wants"
+];
+/**
+* Object-relation predicate verbs.
+* Boolish in either direction, on any kind — `allowsNull` reads as a flag, `equals()` as a predicate.
+*/
+const RELATIONAL_PREFIXES = [
+	"accepts",
+	"allows",
+	"belongs",
+	"contains",
+	"covers",
+	"denies",
+	"depends",
+	"disallows",
+	"equals",
+	"excludes",
+	"exists",
+	"extends",
+	"handles",
+	"ignores",
+	"implements",
+	"includes",
+	"intersects",
+	"owns",
+	"provides",
+	"rejects",
+	"satisfies",
+	"uses"
+];
+/**
+* Verbs whose third-person form is a canonical non-boolean value (`matches`, `startsAt`, `endsAt`)
+* — reserved on methods and functions only, never on value-holders.
+*/
+const COLLIDER_PREFIXES = [
+	"ends",
+	"matches",
+	"starts"
+];
+/**
+* Command verbs — allowed on a boolean return, never reserved, since `doReset(): void` and the like
+* legitimately return a non-boolean.
+*/
+const DIRECTIVE_PREFIXES = ["do"];
+/**
+* Prefixes a non-boolean value-holder must not start with.
+* The auxiliary, capability, and object-relation verbs — each reads as a boolean flag on a value.
+*/
+const RESERVED_VALUE_PREFIXES = [
+	...AUXILIARY_PREFIXES,
+	...CAPABILITY_PREFIXES,
+	...RELATIONAL_PREFIXES
+];
+/**
+* Prefixes a non-boolean method or function must not start with.
+* The value-reserved set plus the colliders — they read as a predicate on a method, data on a value.
+*/
+const RESERVED_METHOD_PREFIXES = [...RESERVED_VALUE_PREFIXES, ...COLLIDER_PREFIXES];
+/**
+* Prefixes a boolean-returning method or function may start with.
+* The method-reserved set plus the `do` directive, which commands may also use on non-boolean returns.
+*/
+const PREDICATE_PREFIXES = [...RESERVED_METHOD_PREFIXES, ...DIRECTIVE_PREFIXES];
+/**
+* Prefixes a boolean value-holder may start with.
+* The value-reserved set plus the `do` directive and the representation flag `as`.
+*/
+const FLAG_PREFIXES = [
+	...RESERVED_VALUE_PREFIXES,
+	...DIRECTIVE_PREFIXES,
+	"as"
+];
+const KIND_CONSTANT = "Constant";
+const KIND_FUNCTION = "Function";
+const KIND_METHOD$1 = "Method";
+const KIND_PARAMETER = "Parameter";
+const KIND_PROPERTY = "Property";
+const KIND_VARIABLE = "Variable";
+const CALLABLE_KINDS = /* @__PURE__ */ new Set([KIND_FUNCTION, KIND_METHOD$1]);
+const isCallableKind = (kind) => CALLABLE_KINDS.has(kind);
+const getFirstWord = (name) => (/^(?:[0-9a-z]+|[0-9A-Z]+)/v.exec(name)?.[0] ?? "").toLowerCase();
+const getBooleanConverterToken = (name, kind) => isCallableKind(kind) ? /^(?:as|to)bool(?:ean)?/iv.exec(name)?.[0] : void 0;
+const getPrefixesForKind = (kind) => isCallableKind(kind) ? PREDICATE_PREFIXES : FLAG_PREFIXES;
+const isBoolishName = (name, kind) => getPrefixesForKind(kind).includes(getFirstWord(name)) || getBooleanConverterToken(name, kind) !== void 0;
+const getReservedToken = (name, kind) => {
+	const converterToken = getBooleanConverterToken(name, kind);
+	if (converterToken !== void 0) return converterToken;
+	const firstWord = getFirstWord(name);
+	return (isCallableKind(kind) ? RESERVED_METHOD_PREFIXES : RESERVED_VALUE_PREFIXES).includes(firstWord) ? firstWord : void 0;
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/boolish-prefix.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const MESSAGE_ID_MISSING_PREFIX = "missingPrefix";
+const MESSAGE_ID_UNEXPECTED_PREFIX = "unexpectedPrefix";
+const CLASS_MEMBER_NODES = /* @__PURE__ */ new Set([
+	"MethodDefinition",
+	"PropertyDefinition",
+	"TSAbstractMethodDefinition",
+	"TSAbstractPropertyDefinition"
+]);
+const CALLABLE_INITIALIZERS = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+const RETURN_OWNER_NODES = /* @__PURE__ */ new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+]);
+const PARAMETER_OWNER_SELECTOR = `${[
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression",
+	"TSFunctionType",
+	"TSMethodSignature"
+].join(", ")}:exit`;
+const resolveNameNode = (node) => node.type === "Identifier" || node.type === "PrivateIdentifier" ? node : void 0;
+const isSetterMember = (node) => {
+	if (node.type !== "MethodDefinition" && node.type !== "TSAbstractMethodDefinition") return false;
+	return node.kind === "set";
+};
+const isSkippedMember = (ruleContext, node) => {
+	if (!CLASS_MEMBER_NODES.has(node.type)) return false;
+	const member = node;
+	const nameNode = resolveNameNode(member.key);
+	if (nameNode === void 0 || isSetterMember(member)) return true;
+	return ruleContext.services !== void 0 && hasExternalUpstreamMember(ruleContext.services, member.parent.parent, nameNode.name);
+};
+const findEnclosingCallable = (node) => {
+	let current = node.parent;
+	while (current !== void 0 && !RETURN_OWNER_NODES.has(current.type)) current = current.parent;
+	return current;
+};
+const resolveCallableResult = (ruleContext, callable) => {
+	if (callable.returnType) return classifyTypeAnnotation(callable.returnType.typeAnnotation);
+	if (callable.type === "ArrowFunctionExpression" && callable.body.type !== "BlockStatement") return classifyExpression(callable.body);
+	return combineClassifications(ruleContext.returnClassifications.get(callable) ?? []);
+};
+const resolveSyntacticCallable = (target, annotation) => {
+	if (target.callable !== void 0) return target.callable;
+	if (annotation?.type === "TSFunctionType") return annotation;
+	return CALLABLE_INITIALIZERS.has(target.initializer?.type ?? "") ? target.initializer : void 0;
+};
+const resolveHeldClassification = (target, annotation) => {
+	if (annotation !== void 0) return classifyTypeAnnotation(annotation);
+	return target.initializer ? classifyExpression(target.initializer) : TYPE_CLASSIFICATIONS.UNKNOWN;
+};
+const resolveFromSyntax = (ruleContext, target) => {
+	const annotation = target.typeAnnotation?.typeAnnotation;
+	const callable = resolveSyntacticCallable(target, annotation);
+	if (callable === void 0) return {
+		classification: resolveHeldClassification(target, annotation),
+		isCallable: false
+	};
+	return {
+		classification: resolveCallableResult(ruleContext, callable),
+		isCallable: true
+	};
+};
+const resolveFromTypes = (services, checker, nameNode) => {
+	const type = services.getTypeAtLocation(nameNode);
+	const returnType = resolveReturnType(checker, type);
+	return {
+		classification: classifyType(checker, returnType ?? type),
+		isCallable: returnType !== void 0
+	};
+};
+const checkTarget = (ruleContext, target) => {
+	const { checker, services } = ruleContext;
+	const { classification, isCallable } = services === void 0 || checker === void 0 ? resolveFromSyntax(ruleContext, target) : resolveFromTypes(services, checker, target.nameNode);
+	const kind = isCallable ? target.callableKind : target.valueKind;
+	const { name } = target.nameNode;
+	if (classification === TYPE_CLASSIFICATIONS.BOOL) {
+		if (!isBoolishName(name, kind)) ruleContext.report(target.nameNode, MESSAGE_ID_MISSING_PREFIX, {
+			kind,
+			name,
+			prefixes: getPrefixesForKind(kind).join(", ")
+		});
+		return;
+	}
+	const reservedToken = classification === TYPE_CLASSIFICATIONS.NON_BOOL ? getReservedToken(name, kind) : void 0;
+	if (reservedToken !== void 0) ruleContext.report(target.nameNode, MESSAGE_ID_UNEXPECTED_PREFIX, {
+		kind,
+		name,
+		prefix: reservedToken
+	});
+};
+const checkParameters = (ruleContext, node) => {
+	if (isSkippedMember(ruleContext, node.parent)) return;
+	for (const parameter of node.params) {
+		const nameNode = resolveParameterIdentifier(parameter);
+		if (nameNode !== void 0) checkTarget(ruleContext, {
+			nameNode,
+			valueKind: parameter.type === "TSParameterProperty" ? KIND_PROPERTY : KIND_PARAMETER,
+			callableKind: KIND_FUNCTION,
+			typeAnnotation: nameNode.typeAnnotation,
+			initializer: parameter.type === "AssignmentPattern" ? parameter.right : void 0
+		});
+	}
+};
+const checkClassMember = (ruleContext, node) => {
+	const nameNode = resolveNameNode(node.key);
+	if (nameNode === void 0 || isSkippedMember(ruleContext, node)) return;
+	if (node.type === "PropertyDefinition" || node.type === "TSAbstractPropertyDefinition") {
+		checkTarget(ruleContext, {
+			nameNode,
+			valueKind: KIND_PROPERTY,
+			callableKind: KIND_METHOD$1,
+			typeAnnotation: node.typeAnnotation,
+			initializer: node.value
+		});
+		return;
+	}
+	if (node.kind !== "constructor") checkTarget(ruleContext, {
+		nameNode,
+		valueKind: KIND_PROPERTY,
+		callableKind: node.kind === "get" ? KIND_PROPERTY : KIND_METHOD$1,
+		callable: node.value
+	});
+};
+const collectReturnClassification = (ruleContext, node) => {
+	const callable = ruleContext.services === void 0 ? findEnclosingCallable(node) : void 0;
+	if (callable === void 0) return;
+	ruleContext.returnClassifications.set(callable, [...ruleContext.returnClassifications.get(callable) ?? [], node.argument ? classifyExpression(node.argument) : TYPE_CLASSIFICATIONS.NON_BOOL]);
+};
+const buildVisitors = (ruleContext) => ({
+	[PARAMETER_OWNER_SELECTOR]: (node) => {
+		checkParameters(ruleContext, node);
+	},
+	"FunctionDeclaration, TSDeclareFunction:exit": (node) => {
+		if (node.id) checkTarget(ruleContext, {
+			nameNode: node.id,
+			valueKind: KIND_FUNCTION,
+			callableKind: KIND_FUNCTION,
+			callable: node
+		});
+	},
+	"MethodDefinition, PropertyDefinition, TSAbstractMethodDefinition, TSAbstractPropertyDefinition:exit": (node) => {
+		checkClassMember(ruleContext, node);
+	},
+	"ReturnStatement:exit": (node) => {
+		collectReturnClassification(ruleContext, node);
+	},
+	"TSEnumMember:exit": (node) => {
+		const nameNode = resolveNameNode(node.id);
+		if (nameNode !== void 0) checkTarget(ruleContext, {
+			nameNode,
+			valueKind: KIND_CONSTANT,
+			callableKind: KIND_CONSTANT,
+			initializer: node.initializer
+		});
+	},
+	"TSMethodSignature:exit": (node) => {
+		const nameNode = resolveNameNode(node.key);
+		if (nameNode !== void 0) checkTarget(ruleContext, {
+			nameNode,
+			valueKind: KIND_METHOD$1,
+			callableKind: KIND_METHOD$1,
+			callable: node
+		});
+	},
+	"TSPropertySignature:exit": (node) => {
+		const nameNode = resolveNameNode(node.key);
+		if (nameNode !== void 0) checkTarget(ruleContext, {
+			nameNode,
+			valueKind: KIND_PROPERTY,
+			callableKind: KIND_METHOD$1,
+			typeAnnotation: node.typeAnnotation
+		});
+	},
+	"VariableDeclarator:exit": (node) => {
+		if (node.id.type === "Identifier") checkTarget(ruleContext, {
+			nameNode: node.id,
+			valueKind: KIND_VARIABLE,
+			callableKind: KIND_FUNCTION,
+			typeAnnotation: node.id.typeAnnotation,
+			initializer: node.init
+		});
+	}
+});
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/boolish-prefix.md
+*/
+const boolishPrefixRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Keep boolean-ness and names aligned in both directions.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/boolish-prefix.md"
+		},
+		messages: {
+			[MESSAGE_ID_MISSING_PREFIX]: "{{ kind }} name `{{ name }}` must have one of the following prefixes: {{ prefixes }}.",
+			[MESSAGE_ID_UNEXPECTED_PREFIX]: "{{ kind }} name `{{ name }}` must not start with the boolish prefix `{{ prefix }}` because it is not boolean."
+		}
+	},
+	create: (context) => {
+		const { parserServices } = context.sourceCode;
+		const services = parserServices;
+		const program = services?.program;
+		return buildVisitors({
+			report: (nameNode, messageId, data) => {
+				context.report({
+					node: nameNode,
+					messageId,
+					data
+				});
+			},
+			services: program === void 0 ? void 0 : services,
+			checker: program?.getTypeChecker(),
+			returnClassifications: /* @__PURE__ */ new Map()
+		});
+	}
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/interface-suffix.ts
+const MESSAGE_ID_MISSING_SUFFIX = "missingSuffix";
+const getImplementedName = (expression) => {
+	if (expression.type === "Identifier") return expression.name;
+	if (expression.type === "MemberExpression" && expression.property.type === "Identifier") return expression.property.name;
+	return "";
+};
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/interface-suffix.md
+*/
+const interfaceSuffixRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require classes that implement a single `*Interface` to end with the matching suffix.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/interface-suffix.md"
+		},
+		messages: { [MESSAGE_ID_MISSING_SUFFIX]: "Class `{{ name }}` implements `{{ interfaceName }}` and must end with suffix `{{ suffix }}`." }
+	},
+	create: (context) => {
+		const checkHeritage = (node) => {
+			if (!node.id) return;
+			const implementedNames = node.implements.map((implemented) => getImplementedName(implemented.expression)).filter((name) => name.length > 9 && name.endsWith("Interface"));
+			if (implementedNames.length !== 1) return;
+			const [interfaceName = ""] = implementedNames;
+			const suffix = interfaceName.slice(0, -9);
+			if (node.id.name.endsWith(suffix)) return;
+			context.report({
+				node: node.id,
+				messageId: MESSAGE_ID_MISSING_SUFFIX,
+				data: {
+					name: node.id.name,
+					interfaceName,
+					suffix
+				}
+			});
+		};
+		return {
+			ClassDeclaration: checkHeritage,
+			ClassExpression: checkHeritage
+		};
+	}
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/internal-usage.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const MESSAGE_ID_UNEXPECTED_INTERNAL_USAGE = "unexpectedInternalUsage";
+const MESSAGE_ID_UNEXPECTED_TARGETED_INTERNAL_USAGE = "unexpectedTargetedInternalUsage";
+const PLAIN_INTERNAL = "@internal";
+const PUBLIC_API = "@api";
+const NAMESPACE_SEPARATORS = [
+	"/",
+	"#",
+	"."
+];
+const LAYOUT_SEGMENTS = /* @__PURE__ */ new Set([
+	"dist",
+	"js",
+	"lib",
+	"src"
+]);
+const WILDCARD_SUFFIX$1 = "/*";
+const MODULE_SPECIFIER_SEARCH_DEPTH = 4;
+const DELIMITED_PATTERN = /^(?<delimiter>[^\w\\])(?<source>.*)\k<delimiter>(?<flags>[A-Za-z]*)$/sv;
+const OPTION_NAMES = ["allowedInternals", "allowedCallers"];
+const MODULE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".d.ts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
 ];
+const IMPORT_SPECIFIER_TYPES = /* @__PURE__ */ new Set([
+	"ImportDefaultSpecifier",
+	"ImportNamespaceSpecifier",
+	"ImportSpecifier"
+]);
+const packageCache = /* @__PURE__ */ new Map();
+const packageJsonPathCache = /* @__PURE__ */ new Map();
+const moduleVisibilityCache = /* @__PURE__ */ new Map();
+const internalMarkerCache = /* @__PURE__ */ new WeakMap();
+const fileVisibilityCache = /* @__PURE__ */ new WeakMap();
+const trimSeparators = (value) => {
+	let start = 0;
+	let end = value.length;
+	while (start < end && value.startsWith("/", start)) start += 1;
+	while (end > start && value.endsWith("/", end)) end -= 1;
+	return value.slice(start, end);
+};
+const isInSubtree = (value, prefix) => value === prefix || NAMESPACE_SEPARATORS.some((separator) => value.startsWith(`${prefix}${separator}`));
+const resolveInternalTarget = (comment) => {
+	const target = /\*\s+@internal(?=\s|$)(?<target>[^\n]*)/v.exec(comment)?.groups?.["target"];
+	if (target === void 0) return;
+	const trimmedTarget = target.replace(/\*\/\s*$/v, "").trim();
+	return /^[\w\-.\/@]+$/v.test(trimmedTarget) ? trimSeparators(trimmedTarget) : PLAIN_INTERNAL;
+};
+const findPackageJsonPath = (directory) => {
+	if (packageJsonPathCache.has(directory)) return packageJsonPathCache.get(directory);
+	const packageJsonPath = findNearestPackageJson(directory);
+	packageJsonPathCache.set(directory, packageJsonPath);
+	return packageJsonPath;
+};
+const loadPackageIdentity = (directory) => {
+	const packageJsonPath = findPackageJsonPath(directory);
+	if (packageJsonPath === void 0) return;
+	const mtime = getMtime(packageJsonPath);
+	const cacheEntry = packageCache.get(packageJsonPath);
+	if (cacheEntry !== void 0 && cacheEntry.mtime === mtime) return cacheEntry.identity;
+	const declaredName = readJsonObjectFile(packageJsonPath)?.["name"];
+	const packageName = typeof declaredName === "string" ? declaredName : "";
+	const identity = packageName.length === 0 ? void 0 : {
+		packageName,
+		packageRoot: toPosix$1(path.dirname(packageJsonPath))
+	};
+	packageCache.set(packageJsonPath, {
+		mtime,
+		identity
+	});
+	return identity;
+};
+const dropModuleExtension = (modulePath) => modulePath.replace(/(?:\.d)?\.[cm]?[jt]sx?$/v, "");
+const stripLayoutSegments = (modulePath) => {
+	const segments = modulePath.split("/");
+	let start = 0;
+	while (start < segments.length - 1 && LAYOUT_SEGMENTS.has(segments[start] ?? "")) start += 1;
+	return segments.slice(start).join("/");
+};
+const toNamespace = (moduleId) => {
+	const lastSeparator = moduleId.lastIndexOf("/");
+	return lastSeparator === -1 ? moduleId : moduleId.slice(0, lastSeparator);
+};
+const toAliasModuleId = (pattern, target, absolutePath) => {
+	if (!pattern.endsWith(WILDCARD_SUFFIX$1) || !target.endsWith(WILDCARD_SUFFIX$1)) return dropModuleExtension(target) === dropModuleExtension(absolutePath) ? pattern : void 0;
+	const targetRoot = target.slice(0, -2);
+	if (!absolutePath.startsWith(`${targetRoot}/`)) return;
+	const relativePath = stripLayoutSegments(dropModuleExtension(absolutePath.slice(targetRoot.length + 1)));
+	return `${pattern.slice(0, -2)}/${relativePath}`;
+};
+const buildAliasNamespaces = (absolutePath, aliasPaths) => {
+	const namespaces = [];
+	const aliasEntries = objectEntries(aliasPaths ?? {});
+	for (const [pattern, targets] of aliasEntries) for (const target of targets) {
+		const aliasModuleId = toAliasModuleId(pattern, target, absolutePath);
+		if (aliasModuleId !== void 0) namespaces.push(toNamespace(aliasModuleId));
+	}
+	return namespaces;
+};
+const buildModuleIdentity = (filePath, aliasPaths) => {
+	const absolutePath = toPosix$1(path.resolve(filePath));
+	const identity = loadPackageIdentity(path.dirname(absolutePath));
+	if (identity === void 0 || !absolutePath.startsWith(`${identity.packageRoot}/`)) return;
+	const relativePath = stripLayoutSegments(dropModuleExtension(absolutePath.slice(identity.packageRoot.length + 1)));
+	const moduleId = `${identity.packageName}/${relativePath}`;
+	const namespace = toNamespace(moduleId);
+	return {
+		moduleId,
+		namespace,
+		namespaces: [namespace, ...buildAliasNamespaces(absolutePath, aliasPaths)]
+	};
+};
+const createExportPattern = () => new RegExp(String.raw`^\s*export\s+(?<defaultKeyword>default\s+)?` + String.raw`(?:(?:abstract|async|declare)\s+)*` + String.raw`(?<keyword>class|const|enum|function|interface|let|type|var)\s+` + String.raw`(?<name>[\p{ID_Start}$_][\p{ID_Continue}$]*)`, "v");
+const readExportName = (following) => {
+	const match = createExportPattern().exec(following);
+	if (!match) return;
+	return match.groups?.["defaultKeyword"] === void 0 ? match.groups?.["name"] : "default";
+};
+const hasInternalMarker = (sourceFile) => {
+	if (internalMarkerCache.has(sourceFile)) return internalMarkerCache.get(sourceFile) === true;
+	const hasMarker = sourceFile.text.includes(`@${TAG_INTERNAL}`);
+	internalMarkerCache.set(sourceFile, hasMarker);
+	return hasMarker;
+};
+const resolveVisibility = (comment) => resolveInternalTarget(comment) ?? (hasTag(comment, "api") ? PUBLIC_API : void 0);
+const isCallableExport = (following) => createExportPattern().exec(following)?.groups?.["keyword"] === "function";
+const startsWithBlankLine = (following) => /^[^\n]*\n[^\S\n]*\n/v.test(following);
+const isFileLevelComment = (following) => {
+	const trimmed = following.trimStart();
+	const [firstLine = ""] = trimmed.split("\n", 1);
+	return startsWithBlankLine(following) || trimmed.startsWith("/**") || firstLine.startsWith("import ") || firstLine.startsWith("export ") && firstLine.includes(" from ");
+};
+const resolveLexicalFileVisibility = (content, docblockMatches) => {
+	const [fileComment] = docblockMatches;
+	if (fileComment === void 0 || !isFileLevelComment(content.slice(fileComment.index + fileComment[0].length))) return;
+	return resolveVisibility(fileComment[0]);
+};
+const buildModuleVisibility = (filePath) => {
+	const content = readTextFile(filePath) ?? "";
+	const docblockMatches = content.matchAll(/\/\*\*(?:[^*]|\*(?!\/))*\*\//gv).toArray();
+	const visibilityByExportName = /* @__PURE__ */ new Map();
+	const callableExportNames = /* @__PURE__ */ new Set();
+	for (const match of docblockMatches) {
+		const visibility = resolveVisibility(match[0]);
+		const following = content.slice(match.index + match[0].length);
+		const exportName = readExportName(following);
+		if (exportName === void 0) continue;
+		if (visibility !== void 0) visibilityByExportName.set(exportName, visibility);
+		if (isCallableExport(following)) callableExportNames.add(exportName);
+	}
+	return {
+		fileVisibility: resolveLexicalFileVisibility(content, docblockMatches),
+		visibilityByExportName,
+		callableExportNames
+	};
+};
+const loadModuleVisibility = (filePath) => {
+	const mtime = getMtime(filePath);
+	const cacheEntry = moduleVisibilityCache.get(filePath);
+	if (cacheEntry !== void 0 && cacheEntry.mtime === mtime) return cacheEntry.visibility;
+	const visibility = buildModuleVisibility(filePath);
+	moduleVisibilityCache.set(filePath, {
+		mtime,
+		visibility
+	});
+	return visibility;
+};
+const resolveRelativeModulePath = (fromFilePath, specifier) => {
+	if (!specifier.startsWith(".")) return;
+	const base = path.resolve(path.dirname(fromFilePath), specifier);
+	return [...MODULE_EXTENSIONS.map((extension) => `${base}${extension}`), ...MODULE_EXTENSIONS.map((extension) => path.join(base, `index${extension}`))].find((candidate) => doesFileExist(candidate));
+};
+const toPattern = (entry) => {
+	const groups = DELIMITED_PATTERN.exec(entry)?.groups;
+	if (groups === void 0) return;
+	const source = groups["source"] ?? "";
+	const flags = (groups["flags"] ?? "").replaceAll(/[gy]/gv, "");
+	try {
+		return new RegExp(source, flags);
+	} catch {
+		return;
+	}
+};
+const buildMatcher = (optionName, entries) => {
+	const prefixes = [];
+	const patterns = [];
+	for (const entry of entries) {
+		if (entry instanceof RegExp) {
+			patterns.push(new RegExp(entry.source, entry.flags.replaceAll(/[gy]/gv, "")));
+			continue;
+		}
+		const text = typeof entry === "string" ? entry : "";
+		const pattern = toPattern(text);
+		if (pattern !== void 0) {
+			patterns.push(pattern);
+			continue;
+		}
+		const prefix = trimSeparators(text);
+		if (prefix.length === 0 || !/^[\w@]/v.test(prefix)) throw new Error(`Entry "${entry}" for option "${optionName}" is neither a namespace prefix nor a regular expression.`);
+		prefixes.push(prefix);
+	}
+	return {
+		prefixes,
+		patterns
+	};
+};
+const isMappedEntry = (entry) => typeof entry === "object" && (entry ?? void 0) !== void 0 && !Array.isArray(entry) && !(entry instanceof RegExp);
+const buildAllowList = (optionName, entries) => {
+	const bare = [];
+	const bounded = [];
+	const allowEntries = entries ?? [];
+	for (const entry of allowEntries) {
+		if (!isMappedEntry(entry)) {
+			bare.push(entry);
+			continue;
+		}
+		for (const [subject, counterparts] of objectEntries(entry)) {
+			if (!Array.isArray(counterparts)) throw new TypeError(`Entry "${subject}" for option "${optionName}" must map to a list of namespace prefixes or regular expressions.`);
+			bounded.push({
+				subject: buildMatcher(optionName, [subject]),
+				counterparts: buildMatcher(optionName, counterparts)
+			});
+		}
+	}
+	return {
+		bare: buildMatcher(optionName, bare),
+		bounded
+	};
+};
+const matches = (values, matcher) => values.some((value) => matcher.prefixes.some((prefix) => isInSubtree(value, prefix)) || matcher.patterns.some((pattern) => pattern.test(value)));
+const isAllowedBy = (values, counterparts, allowList) => matches(values, allowList.bare) || allowList.bounded.some((entry) => matches(values, entry.subject) && matches(counterparts, entry.counterparts));
+const hasModuleSpecifierAbove = (node) => {
+	let current = node;
+	for (let depth = 0; current !== void 0 && depth < MODULE_SPECIFIER_SEARCH_DEPTH; depth += 1) {
+		if (current.moduleSpecifier !== void 0) return true;
+		current = current.parent;
+	}
+	return false;
+};
+const findDeclaredVisibility = (declaration) => {
+	let current = declaration;
+	while (current !== void 0) {
+		const commentNodes = (current.jsDoc ?? []).toReversed();
+		for (const commentNode of commentNodes) {
+			const visibility = resolveVisibility(commentNode.getText());
+			if (visibility !== void 0) return visibility;
+		}
+		current = current.parent;
+	}
+};
+const isSeparatedByBlankLine = (sourceFile, commentNode, statement) => startsWithBlankLine(sourceFile.text.slice(commentNode.end, statement.getStart()));
+const findFileLevelComment = (sourceFile) => {
+	const statement = sourceFile.statements?.[0];
+	const commentNodes = statement?.jsDoc ?? [];
+	const [fileCommentNode] = commentNodes;
+	if (statement === void 0 || fileCommentNode === void 0) return;
+	if (commentNodes.length > 1 || statement.moduleSpecifier !== void 0) return fileCommentNode.getText();
+	return isSeparatedByBlankLine(sourceFile, fileCommentNode, statement) ? fileCommentNode.getText() : void 0;
+};
+const findFileVisibility = (sourceFile) => {
+	if (fileVisibilityCache.has(sourceFile)) return fileVisibilityCache.get(sourceFile);
+	const fileComment = findFileLevelComment(sourceFile);
+	const visibility = fileComment === void 0 ? void 0 : resolveVisibility(fileComment);
+	fileVisibilityCache.set(sourceFile, visibility);
+	return visibility;
+};
+const toInternalTarget = (visibility) => visibility === PUBLIC_API ? void 0 : visibility;
+const buildSymbolId = (moduleId, symbolName, declaration) => {
+	const names = [symbolName];
+	let current = declaration.parent;
+	while (current !== void 0) {
+		const name = current.name?.getText?.();
+		if (name !== void 0 && name.length > 0) names.push(name);
+		current = current.parent;
+	}
+	return `${moduleId}#${names.toReversed().join(".")}${declaration.parameters === void 0 ? "" : "()"}`;
+};
+const isPublicExportName = (node) => "exported" in node.parent && node.parent.exported === node;
+const getImportedName = (specifier) => {
+	if ("imported" in specifier) return "name" in specifier.imported ? specifier.imported.name : void 0;
+	return specifier.type === "ImportDefaultSpecifier" ? "default" : void 0;
+};
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/internal-usage.md
+*/
+const internalUsageRule = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid usage of an `@internal` symbol from outside the namespace it is internal to.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/internal-usage.md"
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				...objectFromEntries(OPTION_NAMES.map((optionName) => [optionName, {
+					type: "array",
+					tsType: "(string | RegExp | Record<string, (string | RegExp)[]>)[]"
+				}])),
+				tsConfigPath: { type: "string" }
+			}
+		}],
+		messages: {
+			[MESSAGE_ID_UNEXPECTED_INTERNAL_USAGE]: "`{{ symbol }}` is internal and must not be used from `{{ caller }}`.",
+			[MESSAGE_ID_UNEXPECTED_TARGETED_INTERNAL_USAGE]: "`{{ symbol }}` is internal to `{{ target }}` and must not be used from `{{ caller }}`."
+		}
+	},
+	create: (context) => {
+		const options = context.options[0] ?? {};
+		const allowLists = {
+			allowedCallers: buildAllowList("allowedCallers", options.allowedCallers),
+			allowedInternals: buildAllowList("allowedInternals", options.allowedInternals)
+		};
+		const sourceCode = context.sourceCode;
+		const services = sourceCode.parserServices;
+		const typeChecker = (services?.program)?.getTypeChecker();
+		const aliasPaths = options.tsConfigPath === void 0 ? void 0 : loadTsConfigPaths(options.tsConfigPath);
+		const resolveIdentity = (filePath) => buildModuleIdentity(filePath, aliasPaths);
+		const callerIdentity = resolveIdentity(context.filename);
+		if (callerIdentity === void 0) return {};
+		const callerNamespace = callerIdentity.namespace;
+		const callerNamespaces = callerIdentity.namespaces;
+		const isReachable = (internal) => {
+			const roots = internal.target === PLAIN_INTERNAL ? internal.namespaces : [internal.target];
+			return callerNamespaces.some((namespace) => roots.some((root) => isInSubtree(namespace, root)));
+		};
+		const isUsageAllowed = (internal) => {
+			const internalValues = [
+				internal.target,
+				...internal.namespaces,
+				internal.symbolId
+			];
+			return isAllowedBy(internalValues, callerNamespaces, allowLists.allowedInternals) || isAllowedBy(callerNamespaces, internalValues, allowLists.allowedCallers) || isReachable(internal);
+		};
+		const reportUsage = (node, internal) => {
+			if (isUsageAllowed(internal)) return;
+			context.report({
+				node,
+				messageId: internal.target === PLAIN_INTERNAL ? MESSAGE_ID_UNEXPECTED_INTERNAL_USAGE : MESSAGE_ID_UNEXPECTED_TARGETED_INTERNAL_USAGE,
+				data: {
+					caller: callerNamespace,
+					symbol: internal.symbolId,
+					target: internal.target
+				}
+			});
+		};
+		const buildInternalSymbol = (identity, symbolId, visibility) => {
+			const target = toInternalTarget(visibility);
+			return target === void 0 ? void 0 : {
+				namespace: identity.namespace,
+				namespaces: identity.namespaces,
+				symbolId,
+				target
+			};
+		};
+		const checkResolvedSymbol = (node, symbol, currentSourceFile) => {
+			const declaration = symbol.declarations?.[0];
+			if (declaration === void 0) return;
+			const sourceFile = declaration.getSourceFile();
+			if (sourceFile === currentSourceFile || !hasInternalMarker(sourceFile)) return;
+			const target = toInternalTarget(findDeclaredVisibility(declaration) ?? findFileVisibility(sourceFile));
+			const identity = target === void 0 ? void 0 : resolveIdentity(sourceFile.fileName);
+			if (identity === void 0 || target === void 0) return;
+			reportUsage(node, {
+				namespace: identity.namespace,
+				namespaces: identity.namespaces,
+				symbolId: buildSymbolId(identity.moduleId, symbol.getName(), declaration),
+				target
+			});
+		};
+		const checkTypedIdentifier = (node, checker) => {
+			const tsNode = services?.esTreeNodeToTSNodeMap.get(node);
+			const symbol = tsNode === void 0 ? void 0 : checker.getSymbolAtLocation(tsNode);
+			const declaration = symbol?.declarations?.[0];
+			if (tsNode === void 0 || symbol === void 0 || declaration === void 0) return;
+			checkResolvedSymbol(node, hasModuleSpecifierAbove(declaration) ? checker.getAliasedSymbol(symbol) : symbol, tsNode.getSourceFile());
+		};
+		const checkTypedModule = (node, checker) => {
+			const tsNode = services?.esTreeNodeToTSNodeMap.get(node);
+			const sourceFile = (tsNode === void 0 ? void 0 : checker.getSymbolAtLocation(tsNode))?.declarations?.[0];
+			if (sourceFile === void 0 || !hasInternalMarker(sourceFile)) return;
+			const identity = resolveIdentity(sourceFile.fileName);
+			const internal = identity === void 0 ? void 0 : buildInternalSymbol(identity, identity.moduleId, findFileVisibility(sourceFile));
+			if (internal !== void 0) reportUsage(node, internal);
+		};
+		const resolveScannedSymbol = (specifier, importedName) => {
+			const modulePath = resolveRelativeModulePath(context.filename, specifier);
+			const identity = modulePath === void 0 ? void 0 : resolveIdentity(modulePath);
+			if (modulePath === void 0 || identity === void 0) return;
+			const moduleVisibility = loadModuleVisibility(modulePath);
+			return buildInternalSymbol(identity, importedName === void 0 ? identity.moduleId : `${identity.moduleId}#${importedName}${moduleVisibility.callableExportNames.has(importedName) ? "()" : ""}`, (importedName === void 0 ? void 0 : moduleVisibility.visibilityByExportName.get(importedName)) ?? moduleVisibility.fileVisibility);
+		};
+		const checkScannedImport = (node) => {
+			for (const specifier of node.specifiers) {
+				const internal = resolveScannedSymbol(node.source.value, getImportedName(specifier));
+				if (internal === void 0) continue;
+				const references = sourceCode.getDeclaredVariables(node).filter((variable) => variable.name === specifier.local.name).flatMap((variable) => variable.references);
+				for (const reference of references) reportUsage(reference.identifier, internal);
+			}
+		};
+		const checkScannedReexport = (node) => {
+			for (const specifier of node.specifiers) {
+				const localName = "name" in specifier.local ? specifier.local.name : void 0;
+				const internal = node.source ? resolveScannedSymbol(node.source.value, localName) : void 0;
+				if (internal !== void 0) reportUsage(specifier, internal);
+			}
+		};
+		if (services === void 0 || typeChecker === void 0) return {
+			ExportAllDeclaration: (node) => {
+				const internal = resolveScannedSymbol(node.source.value);
+				if (internal !== void 0) reportUsage(node, internal);
+			},
+			ExportNamedDeclaration: (node) => {
+				checkScannedReexport(node);
+			},
+			ImportDeclaration: (node) => {
+				checkScannedImport(node);
+			},
+			ImportExpression: (node) => {
+				const specifier = "value" in node.source && typeof node.source.value === "string" ? node.source.value : void 0;
+				const internal = specifier === void 0 ? void 0 : resolveScannedSymbol(specifier);
+				if (internal !== void 0) reportUsage(node, internal);
+			}
+		};
+		return {
+			ExportAllDeclaration: (node) => {
+				checkTypedModule(node.source, typeChecker);
+			},
+			Identifier: (node) => {
+				if (!IMPORT_SPECIFIER_TYPES.has(node.parent.type) && !isPublicExportName(node)) checkTypedIdentifier(node, typeChecker);
+			},
+			ImportExpression: (node) => {
+				checkTypedModule(node.source, typeChecker);
+			}
+		};
+	}
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/public-api-documentation.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const MESSAGE_ID_MISSING_DESCRIPTION = "missingDescription";
+const MESSAGE_ID_MISSING_PARAM = "missingParam";
+const MESSAGE_ID_MISSING_RETURNS = "missingReturns";
+const MESSAGE_ID_MISSING_EXAMPLE = "missingExample";
+const KIND_METHOD = "Method";
+const KIND_CONSTRUCTOR = "Constructor";
+const readCommentText = (declaration) => {
+	const [comment] = (declaration?.jsDoc ?? []).toReversed();
+	return comment?.getText();
+};
+const hasInheritDocTag = (comment) => /\*\s+@inheritdoc\b/iv.test(comment ?? "");
+const isDocumentedByAncestor = (services, node, memberName) => {
+	const program = services?.program;
+	const declaration = services?.esTreeNodeToTSNodeMap.get(node);
+	if (!program || declaration?.name === void 0) return false;
+	const checker = program.getTypeChecker();
+	return (declaration.heritageClauses ?? []).some((clause) => clause.types.some((typeNode) => hasDescription(readCommentText(checker.getTypeAtLocation(typeNode).getProperty(memberName)?.declarations?.[0]))));
+};
+const reportMissingDescription = (ruleContext, anchor, kind, name) => {
+	ruleContext.context.report({
+		node: anchor,
+		messageId: MESSAGE_ID_MISSING_DESCRIPTION,
+		data: {
+			kind,
+			name
+		}
+	});
+};
+const checkFunctionParameters = (ruleContext, functionLike, text) => {
+	for (const parameter of functionLike.parameters) {
+		const parameterName = getParameterName(parameter);
+		if (parameterName !== void 0 && !hasParameterProse(text, parameterName)) ruleContext.context.report({
+			node: functionLike.anchor,
+			messageId: MESSAGE_ID_MISSING_PARAM,
+			data: {
+				kind: functionLike.kind,
+				name: functionLike.name,
+				parameterName
+			}
+		});
+	}
+};
+const checkFunctionReturns = (ruleContext, functionLike, text, isFluent) => {
+	if (isFluent || isVoidLikeReturn(functionLike.returnType) || hasReturnsWithProse(text)) return;
+	ruleContext.context.report({
+		node: functionLike.anchor,
+		messageId: MESSAGE_ID_MISSING_RETURNS,
+		data: {
+			kind: functionLike.kind,
+			name: functionLike.name
+		}
+	});
+};
+const checkFunctionExample = (ruleContext, functionLike, text, isFluent) => {
+	if (isFluent || functionLike.parameters.length === 0 || functionLike.isAbstract === true || hasTag(text, "example")) return;
+	ruleContext.context.report({
+		node: functionLike.anchor,
+		messageId: MESSAGE_ID_MISSING_EXAMPLE,
+		data: {
+			kind: functionLike.kind,
+			name: functionLike.name
+		}
+	});
+};
+const checkFunctionLike = (ruleContext, functionLike) => {
+	const text = functionLike.comment ?? "";
+	if (functionLike.kind !== KIND_CONSTRUCTOR && !hasDescription(functionLike.comment)) reportMissingDescription(ruleContext, functionLike.anchor, functionLike.kind, functionLike.name);
+	checkFunctionParameters(ruleContext, functionLike, text);
+	const isFluent = isFluentReturn(functionLike.returnType);
+	checkFunctionReturns(ruleContext, functionLike, text, isFluent);
+	checkFunctionExample(ruleContext, functionLike, text, isFluent);
+};
+const checkClassMembers = (ruleContext, node) => {
+	for (const member of node.body.body) {
+		if (!isClassMethodLike(member) || !isAccessibleMethod(member)) continue;
+		const methodComment = extractBlockComment(ruleContext.sourceCode.getCommentsBefore(member), member);
+		if (getEffectiveVisibilityTag(methodComment, ruleContext.fileComment) === "internal" || hasInheritDocTag(methodComment) || isDocumentedByAncestor(ruleContext.services, node, getNamedKeyText(member.key))) continue;
+		checkFunctionLike(ruleContext, {
+			anchor: member,
+			kind: member.kind === "constructor" ? KIND_CONSTRUCTOR : KIND_METHOD,
+			name: getNamedKeyText(member.key),
+			comment: methodComment,
+			parameters: member.value.params,
+			returnType: member.value.returnType,
+			isAbstract: isAbstractMethod(member)
+		});
+	}
+};
+const checkInterfaceMembers = (ruleContext, node) => {
+	for (const member of node.body.body) {
+		if (member.type !== "TSMethodSignature") continue;
+		const methodComment = extractBlockComment(ruleContext.sourceCode.getCommentsBefore(member), member);
+		if (getEffectiveVisibilityTag(methodComment, ruleContext.fileComment) === "internal" || hasInheritDocTag(methodComment) || isDocumentedByAncestor(ruleContext.services, node, getNamedKeyText(member.key))) continue;
+		checkFunctionLike(ruleContext, {
+			anchor: member,
+			kind: KIND_METHOD,
+			name: getNamedKeyText(member.key),
+			comment: methodComment,
+			parameters: member.params,
+			returnType: member.returnType,
+			isAbstract: true
+		});
+	}
+};
+const checkSymbol = (ruleContext, symbol) => {
+	if (symbol.kind === "Function") {
+		const shape = resolveFunctionShape(symbol.declaration);
+		if (shape === void 0) return;
+		checkFunctionLike(ruleContext, {
+			anchor: symbol.anchor,
+			kind: symbol.kind,
+			name: symbol.name,
+			comment: symbol.comment,
+			parameters: shape.parameters,
+			returnType: shape.returnType
+		});
+		return;
+	}
+	if (!hasDescription(symbol.comment)) reportMissingDescription(ruleContext, symbol.anchor, symbol.kind, symbol.name);
+	if (symbol.kind === "Class") checkClassMembers(ruleContext, symbol.declaration);
+	else if (symbol.kind === "Interface") checkInterfaceMembers(ruleContext, symbol.declaration);
+};
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/public-api-documentation.md
+*/
+const publicApiDocumentationRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Hold every `@api` symbol in a public-API source file to a consistent docblock standard.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/public-api-documentation.md"
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				packageJsonPath: { type: "string" },
+				distRoot: { type: "string" },
+				srcRoot: { type: "string" },
+				srcExtensions: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: {
+			[MESSAGE_ID_MISSING_DESCRIPTION]: "{{ kind }} `{{ name }}` is `@api` and must carry a description before the first JSDoc tag.",
+			[MESSAGE_ID_MISSING_PARAM]: "{{ kind }} `{{ name }}` is `@api`; parameter `{{ parameterName }}` must have a `@param` tag with a description.",
+			[MESSAGE_ID_MISSING_RETURNS]: "{{ kind }} `{{ name }}` is `@api` and returns a non-void type; a `@returns` tag with a description is required.",
+			[MESSAGE_ID_MISSING_EXAMPLE]: "{{ kind }} `{{ name }}` is `@api` and accepts parameters; an `@example` tag is required."
+		}
+	},
+	create: (context) => {
+		const options = context.options[0] ?? {};
+		if (!isPublicApiFile(options, context.cwd, context.filename)) return {};
+		const sourceCode = context.sourceCode;
+		const fileComment = getFileLevelBlockComment(sourceCode);
+		const ruleContext = {
+			context,
+			sourceCode,
+			fileComment,
+			services: sourceCode.parserServices
+		};
+		return buildExportVisitors(sourceCode, (symbol) => {
+			if (getEffectiveVisibilityTag(symbol.comment, fileComment) !== "api") return;
+			checkSymbol(ruleContext, symbol);
+		});
+	}
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/require-import-alias.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const MESSAGE_ID_EXPECTED_ALIAS = "expectedAlias";
+const MESSAGE_ID_MISSING_ALIAS = "missingAlias";
+const WILDCARD_SUFFIX = "/*";
+const RELATIVE_SPECIFIER_PREFIXES = ["./", "../"];
+const resolveAliases = (options) => options.aliases ?? loadTsConfigPaths(options.tsConfigPath ?? resolveTsConfigPath()) ?? {};
+const buildAliasMappings = (aliases) => objectEntries(aliases).filter(([pattern]) => pattern.endsWith(WILDCARD_SUFFIX)).flatMap(([pattern, targets]) => {
+	const prefix = pattern.slice(0, -2);
+	return targets.filter((target) => target.endsWith(WILDCARD_SUFFIX)).map((target) => ({
+		prefix,
+		baseDirectory: toPosix$1(target).slice(0, -2)
+	}));
+});
+const buildAliasedSpecifier = ({ prefix, baseDirectory }, absolutePath) => {
+	if (absolutePath === baseDirectory) return prefix;
+	return absolutePath.startsWith(`${baseDirectory}/`) ? `${prefix}/${absolutePath.slice(baseDirectory.length + 1)}` : void 0;
+};
+const compareSpecifiers = (left, right) => {
+	const segmentDifference = left.split("/").length - right.split("/").length;
+	if (segmentDifference !== 0) return segmentDifference;
+	const lengthDifference = left.length - right.length;
+	return lengthDifference === 0 ? left.localeCompare(right) : lengthDifference;
+};
+const findAliasReplacement = (mappings, absolutePath) => mappings.map((mapping) => buildAliasedSpecifier(mapping, absolutePath)).filter((specifier) => specifier !== void 0).toSorted(compareSpecifiers)[0];
+const resolveAliasedPath = (mappings, source) => {
+	for (const { prefix, baseDirectory } of mappings) {
+		if (source === prefix) return baseDirectory;
+		if (source.startsWith(`${prefix}/`)) return `${baseDirectory}/${source.slice(prefix.length + 1)}`;
+	}
+};
+const isRelativeSpecifier = (source) => RELATIVE_SPECIFIER_PREFIXES.some((prefix) => source.startsWith(prefix));
+const isFileIgnored = (filename, patterns) => {
+	const absoluteFilename = toPosix$1(filename);
+	const relativeFilename = toPosix$1(path.relative(process.cwd(), filename));
+	return patterns.some((pattern) => path.matchesGlob(absoluteFilename, pattern) || path.matchesGlob(relativeFilename, pattern));
+};
+const getQuote = (sourceNode) => "raw" in sourceNode && typeof sourceNode.raw === "string" && sourceNode.raw.startsWith("\"") ? "\"" : "'";
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/require-import-alias.md
+*/
+const requireImportAliasRule = {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			description: "Require imports to use the TypeScript path alias with the fewest path segments when the target file is reachable through one.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/require-import-alias.md"
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				aliases: {
+					type: "object",
+					additionalProperties: {
+						type: "array",
+						items: { type: "string" }
+					}
+				},
+				tsConfigPath: { type: "string" },
+				ignoredPaths: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: {
+			[MESSAGE_ID_EXPECTED_ALIAS]: "Import path '{{ source }}' must use the configured alias '{{ alias }}'.",
+			[MESSAGE_ID_MISSING_ALIAS]: "Import path '{{ source }}' resolves outside any configured TypeScript path alias. Add an alias for this location, remove all other aliases, or disable this rule."
+		}
+	},
+	create: (context) => {
+		const options = context.options[0] ?? {};
+		const ignoredPaths = options.ignoredPaths ?? [];
+		const mappings = buildAliasMappings(resolveAliases(options));
+		if (mappings.length === 0 || isFileIgnored(context.filename, ignoredPaths)) return {};
+		const fileDirectory = toPosix$1(path.dirname(context.filename));
+		const checkSource = (sourceNode) => {
+			if (sourceNode?.type !== "Literal" || typeof sourceNode.value !== "string") return;
+			const source = sourceNode.value;
+			const absolutePath = isRelativeSpecifier(source) ? path.posix.normalize(`${fileDirectory}/${source}`) : resolveAliasedPath(mappings, source);
+			if (absolutePath === void 0) return;
+			const replacement = findAliasReplacement(mappings, absolutePath);
+			if (replacement === source) return;
+			if (replacement === void 0) {
+				context.report({
+					node: sourceNode,
+					messageId: MESSAGE_ID_MISSING_ALIAS,
+					data: { source }
+				});
+				return;
+			}
+			context.report({
+				node: sourceNode,
+				messageId: MESSAGE_ID_EXPECTED_ALIAS,
+				data: {
+					source,
+					alias: replacement
+				},
+				fix: (fixer) => fixer.replaceText(sourceNode, `${getQuote(sourceNode)}${replacement}${getQuote(sourceNode)}`)
+			});
+		};
+		return {
+			ImportDeclaration: (node) => {
+				checkSource(node.source);
+			},
+			ExportNamedDeclaration: (node) => {
+				checkSource(node.source);
+			},
+			ExportAllDeclaration: (node) => {
+				checkSource(node.source);
+			},
+			ImportExpression: (node) => {
+				checkSource(node.source);
+			}
+		};
+	}
+};
 //#endregion
-//#region ../src/js/eslint/configs/builtin.ts
+//#region ../src/js/eslint/configs/builtin/require-import-attributes.ts
+const MESSAGE_ID_MISSING_WITH_KEYWORD = "missingWithKeyword";
+const MESSAGE_ID_MISSING_TYPE_PROPERTY = "missingTypeProperty";
+const MESSAGE_ID_UNEXPECTED_TYPE_VALUE = "unexpectedTypeValue";
 const FILE_TYPE_MAP = {
 	".json": "json",
 	".css": "css",
@@ -130,17 +1833,20 @@ const FILE_TYPE_MAP = {
 	".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 RULE_DEFINITIONS = { "require-import-attributes": {
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/require-import-attributes.md
+*/
+const requireImportAttributesRule = {
 	meta: {
 		type: "problem",
-		docs: { description: "Require non-JavaScript imports (e.g. .json and .css) to include import attributes." },
+		docs: {
+			description: "Require non-JavaScript imports (e.g. .json and .css) to include import attributes.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/require-import-attributes.md"
+		},
 		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 }}'."
+			[MESSAGE_ID_UNEXPECTED_TYPE_VALUE]: "Import attribute 'type' for '{{ file }}' must be '{{ expectedValue }}'."
 		}
 	},
 	create: (context) => ({ ImportDeclaration: (node) => {
@@ -172,32 +1878,285 @@ const RULE_DEFINITIONS = { "require-import-attributes": {
 		}
 		if (typeProperty.value.value !== expectedValue) context.report({
 			node,
-			messageId: MESSAGE_ID_WRONG_TYPE_VALUE,
+			messageId: MESSAGE_ID_UNEXPECTED_TYPE_VALUE,
 			data: {
 				expectedValue,
 				file: sourceValue
 			}
 		});
 	} })
-} };
-const RULES = objectFreeze(objectFromEntries(objectKeys(RULE_DEFINITIONS).map((ruleName) => [`${packageOrganization}/${ruleName}`, "error"])));
-const builtin = () => [{
-	name: buildConfigName(MAIN_SCOPES[packageOrganizationUpper], SUB_SCOPES.SETUP),
-	plugins: { [packageOrganization]: {
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/resolvable-doc-reference.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const MESSAGE_ID_MISSING_REFERENCE = "missingReference";
+const createReferencePattern = () => /(?:\{@|\*\s+@)(?:link(?:code|plain)?|see)\s+(?<target>[^\s\}]+)/gv;
+const startsUpperCase = (value) => /\p{Uppercase_Letter}/v.test(value.slice(0, 1));
+const isCheckableTarget = (target) => !target.includes("/") && !target.includes("~") && !target.includes(":");
+const startsContinuation = (trailingText) => trailingText.startsWith("(") || trailingText.startsWith(":");
+const getHeadIdentifier = (target) => target.split(/[#.]/v, 1)[0] ?? "";
+const getLeftmostNameNode = (nameNode) => {
+	let leftmost = nameNode;
+	while (leftmost.left !== void 0) leftmost = leftmost.left;
+	return leftmost;
+};
+const collectInlineReferences = (docComment) => (Array.isArray(docComment.comment) ? docComment.comment : []).filter((part) => part.name !== void 0).map((part) => ({
+	nameNode: part.name,
+	isInlineTag: true,
+	trailingText: part.text ?? ""
+}));
+const collectBlockReferences = (docComment) => (docComment.tags ?? []).filter((tag) => tag.name?.name !== void 0).map((tag) => ({
+	nameNode: tag.name?.name,
+	isInlineTag: false,
+	trailingText: ""
+}));
+const collectNameReferences = (node) => (node.jsDoc ?? []).flatMap((docComment) => [...collectInlineReferences(docComment), ...collectBlockReferences(docComment)]);
+const resolveNameNodeType = (checker, nameNode) => {
+	if (nameNode.left === void 0 || nameNode.right === void 0) {
+		const symbol = checker.getSymbolAtLocation(nameNode);
+		return symbol === void 0 ? void 0 : checker.getDeclaredTypeOfSymbol(symbol);
+	}
+	const property = resolveNameNodeType(checker, nameNode.left)?.getProperty(nameNode.right.getText());
+	return property === void 0 ? void 0 : checker.getTypeOfSymbolAtLocation(property, nameNode);
+};
+const isMemberNameResolved = (checker, nameNode) => resolveNameNodeType(checker, nameNode) !== void 0;
+const collectDeclaredNames = (sourceCode) => {
+	const declaredNames = /* @__PURE__ */ new Set();
+	const scopes = sourceCode.scopeManager?.scopes ?? [];
+	for (const scope of scopes) for (const variable of scope.variables) declaredNames.add(variable.name);
+	return declaredNames;
+};
+const collectLexicalReferences = (comment) => {
+	const references = [];
+	const lines = `/*${comment.value}*/`.split("\n");
+	for (const [offset, line] of lines.entries()) for (const match of line.matchAll(createReferencePattern())) {
+		const rawTarget = match.groups?.["target"] ?? "";
+		const target = rawTarget.split("|", 1)[0] ?? "";
+		const targetColumn = match.index + (match[0].length - rawTarget.length);
+		references.push({
+			target,
+			headIdentifier: getHeadIdentifier(target),
+			loc: {
+				line: comment.loc.start.line + offset,
+				column: offset === 0 ? comment.loc.start.column + targetColumn : targetColumn
+			}
+		});
+	}
+	return references;
+};
+/**
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/resolvable-doc-reference.md
+*/
+const resolvableDocReferenceRule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Require every `@see` and `@link` target in a JSDoc comment to name a symbol that exists.",
+			url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/resolvable-doc-reference.md"
+		},
+		messages: { [MESSAGE_ID_MISSING_REFERENCE]: "Reference `{{ name }}` does not exist." }
+	},
+	create: (context) => {
+		const sourceCode = context.sourceCode;
+		const services = sourceCode.parserServices;
+		const typeChecker = (services?.program)?.getTypeChecker();
+		const findings = /* @__PURE__ */ new Map();
+		const addFinding = (target, loc) => {
+			const key = `${String(loc.line)}:${String(loc.column)}:${target}`;
+			findings.set(key, findings.get(key) ?? {
+				target,
+				loc
+			});
+		};
+		const checkNameNode = (checker, reference) => {
+			const { isInlineTag, nameNode, trailingText } = reference;
+			const name = nameNode.getText();
+			const target = startsContinuation(trailingText) ? `${name}${trailingText}` : name;
+			if (!isCheckableTarget(target) || checker.getSymbolAtLocation(nameNode) !== void 0) return;
+			if (nameNode.right !== void 0 && isMemberNameResolved(checker, nameNode)) return;
+			const isHeadResolved = checker.getSymbolAtLocation(getLeftmostNameNode(nameNode)) !== void 0;
+			if (!isInlineTag && !isHeadResolved && !startsUpperCase(target)) return;
+			const position = nameNode.getSourceFile().getLineAndCharacterOfPosition(nameNode.getStart());
+			addFinding(target, {
+				line: position.line + 1,
+				column: position.character
+			});
+		};
+		return {
+			"*": (node) => {
+				if (services === void 0 || typeChecker === void 0) return;
+				const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+				if (tsNode === void 0) return;
+				for (const reference of collectNameReferences(tsNode)) checkNameNode(typeChecker, reference);
+			},
+			"Program:exit": () => {
+				const declaredNames = collectDeclaredNames(sourceCode);
+				for (const comment of sourceCode.getAllComments()) {
+					if (!isBlockComment(comment)) continue;
+					for (const reference of collectLexicalReferences(comment)) if (isCheckableTarget(reference.target) && startsUpperCase(reference.headIdentifier) && !declaredNames.has(reference.headIdentifier)) addFinding(reference.target, reference.loc);
+				}
+				for (const finding of findings.values()) context.report({
+					loc: finding.loc,
+					messageId: MESSAGE_ID_MISSING_REFERENCE,
+					data: { name: finding.target }
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/type-assertion-style.ts
+const MESSAGE_ID_EXPECTED_PARENTHESES = "expectedParentheses";
+const MESSAGE_ID_UNEXPECTED_PARENTHESES = "unexpectedParentheses";
+const MESSAGE_ID_EXPECTED_SPACE = "expectedSpace";
+const MESSAGE_ID_UNEXPECTED_SPACE = "unexpectedSpace";
+const ASSERTION_SELECTOR = "TSTypeAssertion, TSAsExpression";
+const OPERAND_KEYWORDS = /* @__PURE__ */ new Set([
+	"async",
+	"await",
+	"class",
+	"delete",
+	"function",
+	"new",
+	"super",
+	"this",
+	"typeof",
+	"void"
+]);
+const REQUIREMENT_SCHEMA = {
+	type: "string",
+	enum: ["always", "never"]
+};
+const isKeywordOperand = (sourceCode, operand) => {
+	const [firstToken, secondToken] = sourceCode.getTokens(operand);
+	if (firstToken === void 0 || !OPERAND_KEYWORDS.has(firstToken.value)) return false;
+	return firstToken.value !== "new" || secondToken?.value !== ".";
+};
+const isParenthesizedOperand = (sourceCode, node) => sourceCode.getTokenBefore(node)?.value === "(" && sourceCode.getTokenAfter(node)?.value === ")";
+const resolveOperandRange = (sourceCode, assertion, isAngleBracket) => {
+	const [start, end] = isAngleBracket ? [sourceCode.getTokenAfter(assertion.typeAnnotation)?.range[1], assertion.range[1]] : [assertion.range[0], sourceCode.getTokenBefore(assertion.typeAnnotation)?.range[0]];
+	return start === void 0 || end === void 0 ? void 0 : [start, end];
+};
+const hasCommentInAnyRange = (sourceCode, ranges) => sourceCode.getAllComments().some(({ range }) => ranges.some(([start, end]) => range[0] < end && range[1] > start));
+const resolveGapRange = (sourceCode, assertion) => {
+	const closingAngle = sourceCode.getTokenAfter(assertion.typeAnnotation) ?? void 0;
+	const operandStart = closingAngle === void 0 ? void 0 : sourceCode.getTokenAfter(closingAngle) ?? void 0;
+	const isUnparenthesizedKeyword = isKeywordOperand(sourceCode, assertion.expression) && !isParenthesizedOperand(sourceCode, assertion.expression);
+	return closingAngle === void 0 || operandStart === void 0 || isUnparenthesizedKeyword ? void 0 : [closingAngle.range[1], operandStart.range[0]];
+};
+//#endregion
+//#region ../src/js/eslint/configs/builtin/index.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const RULE_DEFINITIONS = {
+	"api-or-internal-tag": apiOrInternalTagRule,
+	"boolish-prefix": boolishPrefixRule,
+	"interface-suffix": interfaceSuffixRule,
+	"internal-usage": internalUsageRule,
+	"public-api-documentation": publicApiDocumentationRule,
+	"require-import-attributes": requireImportAttributesRule,
+	"require-import-alias": requireImportAliasRule,
+	"resolvable-doc-reference": resolvableDocReferenceRule,
+	"type-assertion-style": {
 		meta: {
-			name: packageOrganization,
-			version
+			type: "layout",
+			fixable: "code",
+			docs: {
+				description: "Require a type assertion to parenthesize an operand that reads wider than it casts, and to carry no trailing space.",
+				url: "https://github.com/brnshkr/config/blob/master/docs/js/eslint/rules/type-assertion-style.md"
+			},
+			schema: [{ oneOf: [REQUIREMENT_SCHEMA, {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					parentheses: REQUIREMENT_SCHEMA,
+					spacing: REQUIREMENT_SCHEMA
+				}
+			}] }],
+			messages: {
+				[MESSAGE_ID_EXPECTED_PARENTHESES]: "The operand of a type assertion must be parenthesized.",
+				[MESSAGE_ID_UNEXPECTED_PARENTHESES]: "The operand of a type assertion must not be parenthesized.",
+				[MESSAGE_ID_EXPECTED_SPACE]: "A type assertion must be followed by a space.",
+				[MESSAGE_ID_UNEXPECTED_SPACE]: "A type assertion must not be followed by a space."
+			}
 		},
-		rules: RULE_DEFINITIONS
-	} }
-}, {
-	name: buildConfigName(MAIN_SCOPES[packageOrganizationUpper], SUB_SCOPES.RULES),
-	files: GLOB_SCRIPT_FILES,
-	rules: RULES
-}];
+		create: (context) => {
+			const options = context.options[0];
+			const parentheses = (typeof options === "string" ? options : options?.parentheses) ?? "always";
+			const spacing = (typeof options === "string" ? void 0 : options?.spacing) ?? "never";
+			const sourceCode = context.sourceCode;
+			const assertionsWithParenthesesFix = /* @__PURE__ */ new Set();
+			const gapText = spacing === "always" ? " " : "";
+			return {
+				[ASSERTION_SELECTOR]: (assertion) => {
+					const node = assertion.expression;
+					if (!isKeywordOperand(sourceCode, node)) return;
+					const isParenthesized = isParenthesizedOperand(sourceCode, node);
+					if (isParenthesized === (parentheses === "always")) return;
+					const isAngleBracket = assertion.typeAnnotation.range[0] < node.range[0];
+					const operandRange = resolveOperandRange(sourceCode, assertion, isAngleBracket);
+					if (operandRange === void 0) return;
+					if (isAngleBracket) assertionsWithParenthesesFix.add(assertion);
+					const operandText = sourceCode.getText(node);
+					const replacementText = isParenthesized ? operandText : `(${operandText})`;
+					const erasedRanges = [[operandRange[0], node.range[0]], [node.range[1], operandRange[1]]];
+					context.report({
+						node,
+						messageId: isParenthesized ? MESSAGE_ID_UNEXPECTED_PARENTHESES : MESSAGE_ID_EXPECTED_PARENTHESES,
+						fix: (fixer) => hasCommentInAnyRange(sourceCode, erasedRanges) ? [] : [fixer.replaceTextRange(operandRange, isAngleBracket ? `${gapText}${replacementText}` : `${replacementText} `)]
+					});
+				},
+				"TSTypeAssertion:exit": (node) => {
+					const gapRange = resolveGapRange(sourceCode, node);
+					if (gapRange === void 0 || assertionsWithParenthesesFix.has(node)) return;
+					const isSpaced = gapRange[0] !== gapRange[1];
+					if (isSpaced === (spacing === "always")) return;
+					context.report({
+						node,
+						messageId: isSpaced ? MESSAGE_ID_UNEXPECTED_SPACE : MESSAGE_ID_EXPECTED_SPACE,
+						fix: (fixer) => hasCommentInAnyRange(sourceCode, [gapRange]) ? [] : [fixer.replaceTextRange(gapRange, gapText)]
+					});
+				}
+			};
+		}
+	}
+};
+const builtin = (typescriptOptions) => {
+	const tsConfigPath = resolveTsConfigPath(typeof typescriptOptions === "object" ? typescriptOptions : void 0);
+	return [{
+		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: {
+			[`${packageOrganization}/api-or-internal-tag`]: "error",
+			[`${packageOrganization}/boolish-prefix`]: "error",
+			[`${packageOrganization}/interface-suffix`]: "error",
+			[`${packageOrganization}/internal-usage`]: ["error", { tsConfigPath }],
+			[`${packageOrganization}/public-api-documentation`]: "error",
+			[`${packageOrganization}/require-import-alias`]: ["error", { tsConfigPath }],
+			[`${packageOrganization}/require-import-attributes`]: "error",
+			[`${packageOrganization}/resolvable-doc-reference`]: "error",
+			[`${packageOrganization}/type-assertion-style`]: "error"
+		}
+	}];
+};
 const builtinConfig = { [packageOrganization]: builtin };
 //#endregion
 //#region ../src/js/eslint/utils/module.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const MODULES = {
 	[packageOrganization]: { name: packageOrganization },
 	comments: {
@@ -208,15 +2167,11 @@ const MODULES = {
 		name: "css",
 		packages: { requiredAll: [ESLINT_PACKAGES.ESLINT_CSS] }
 	},
-	gitignore: {
-		name: "gitignore",
-		packages: { requiredAll: [ESLINT_PACKAGES.ESLINT_FLAT_CONFIG_GITIGNORE] }
-	},
 	import: {
 		name: "import",
 		packages: {
 			requiredAny: [ESLINT_PACKAGES.ESLINT_PLUGIN_IMPORT_X, ESLINT_PACKAGES.ESLINT_PLUGIN_ANTFU],
-			optional: [ESLINT_PACKAGES.ESLINT_IMPORT_RESOVLER_TYPESCRIPT]
+			optional: [ESLINT_PACKAGES.ESLINT_IMPORT_RESOLVER_TYPESCRIPT]
 		}
 	},
 	javascript: {
@@ -282,14 +2237,13 @@ const MODULES = {
 		packages: { requiredAll: [ESLINT_PACKAGES.ESLINT_PLUGIN_YML] }
 	}
 };
-const resolvePackages = async (moduleInfo, type) => resolvePackagesSharedAsynchronously(moduleInfo, type);
-const enabledStates = {};
-const isModuleEnabled = (moduleInfo) => enabledStates[moduleInfo.name] ?? isModuleEnabledByDefault(moduleInfo);
-const setModuleEnabled = (moduleInfo, state) => {
-	enabledStates[moduleInfo.name] = state;
-};
+const resolvePackages = resolvePackagesSharedAsynchronously;
+const { isModuleEnabled, setModuleEnabled } = createModuleState();
 //#endregion
 //#region ../src/js/eslint/configs/comments.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const comments = async () => {
 	const { requiredAll: [pluginComments] } = await resolvePackages(MODULES.comments);
 	if (!pluginComments) return [];
@@ -303,15 +2257,72 @@ const comments = async () => {
 		files: GLOB_SCRIPT_FILES,
 		rules: {
 			...renameRules(recommendedRules, { "@eslint-community/eslint-comments": "comments" }),
-			"comments/require-description": "error"
+			"comments/require-description": ["error", { additionalDirectives: [
+				"@ts-expect-error",
+				"c8 ignore",
+				"istanbul ignore",
+				"node:coverage ignore",
+				"svelte-ignore",
+				"v8 ignore"
+			] }]
 		}
 	}];
 };
 //#endregion
 //#region ../src/js/eslint/configs/css.ts
-const css = async () => {
+/**
+* @internal @brnshkr/config/eslint
+*/
+const buildTailwindSyntax = (defaultSyntax) => {
+	const declarations = objectFromEntries(objectKeys(defaultSyntax.properties).map((property) => [property, "<declaration-value>"]));
+	return { atrules: {
+		apply: { prelude: "<any-value>" },
+		config: { prelude: "<string>" },
+		"custom-variant": { prelude: "<any-value>" },
+		plugin: { prelude: "<string>" },
+		reference: { prelude: "<string>" },
+		slot: { prelude: null },
+		source: { prelude: "<any-value>" },
+		theme: { prelude: "<any-value>?" },
+		utility: {
+			prelude: "<any-value>",
+			descriptors: declarations
+		},
+		variant: {
+			prelude: "<any-value>",
+			descriptors: declarations
+		}
+	} };
+};
+const mergeSyntaxDefinitions = (baseSyntax, overridingSyntax) => ({
+	...baseSyntax,
+	...overridingSyntax,
+	atrules: {
+		...baseSyntax.atrules,
+		...overridingSyntax.atrules
+	},
+	properties: {
+		...baseSyntax.properties,
+		...overridingSyntax.properties
+	},
+	types: {
+		...baseSyntax.types,
+		...overridingSyntax.types
+	}
+});
+const buildCustomSyntax = (customSyntax, isTailwindEnabled) => {
+	if (!isTailwindEnabled) return customSyntax;
+	return (defaultSyntax) => {
+		const tailwindSyntax = buildTailwindSyntax(defaultSyntax);
+		if (customSyntax === void 0) return tailwindSyntax;
+		return mergeSyntaxDefinitions(tailwindSyntax, typeof customSyntax === "function" ? customSyntax(defaultSyntax) : customSyntax);
+	};
+};
+const css = async (options) => {
 	const { requiredAll: [pluginCss] } = await resolvePackages(MODULES.css);
 	if (!pluginCss) return [];
+	const isTailwindEnabled = options?.tailwind ?? doAllPackagesExist([ESLINT_PACKAGES.TAILWINDCSS]);
+	const customSyntax = buildCustomSyntax(options?.customSyntax, isTailwindEnabled);
 	return [{
 		name: buildConfigName(MAIN_SCOPES.CSS, SUB_SCOPES.SETUP),
 		plugins: { css: pluginCss }
@@ -319,41 +2330,68 @@ const css = async () => {
 		name: buildConfigName(MAIN_SCOPES.CSS, SUB_SCOPES.RULES),
 		files: [GLOB_CSS],
 		language: "css/css",
+		languageOptions: {
+			...customSyntax === void 0 ? void 0 : { customSyntax },
+			tolerant: options?.tolerant ?? isTailwindEnabled
+		},
 		rules: {
 			...pluginCss.configs.recommended.rules,
+			...isTailwindEnabled ? {
+				"css/no-duplicate-imports": "off",
+				"css/no-invalid-properties": "off"
+			} : void 0,
 			"css/prefer-logical-properties": "error",
 			"css/relative-font-units": ["error", { allowUnits: ["em", "rem"] }],
-			"css/use-baseline": "error"
+			...isModuleEnabled(MODULES.unicorn) ? {
+				"unicorn/no-missing-local-resource": "error",
+				"unicorn/prefer-explicit-viewport-units": "error"
+			} : void 0
 		}
 	}];
 };
 //#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]
-}];
+/**
+* @internal @brnshkr/config/eslint
+*/
+const DEFAULT_IGNORE_FILE = ".gitignore";
+const isIgnoreFile = (customIgnore) => /^\.[\w\-]+ignore$/v.test(path.basename(customIgnore));
+const ignores = (customIgnores = []) => {
+	const existingIgnoreFiles = [.../* @__PURE__ */ new Set([DEFAULT_IGNORE_FILE, ...customIgnores.filter((customIgnore) => isIgnoreFile(customIgnore))])].map((ignoreFile) => path.resolve(ignoreFile)).filter((ignoreFile) => doesFileExist(ignoreFile));
+	return [{
+		name: buildConfigName(MAIN_SCOPES.IGNORES, SUB_SCOPES.BASE),
+		ignores: [...GLOB_IGNORES, ...customIgnores.filter((customIgnore) => !isIgnoreFile(customIgnore))]
+	}, ...existingIgnoreFiles.map((ignoreFile) => ({
+		...includeIgnoreFile(ignoreFile, { gitignoreResolution: true }),
+		name: buildConfigName(MAIN_SCOPES.IGNORES, SUB_SCOPES.FILES)
+	}))];
+};
 //#endregion
 //#region ../src/js/eslint/configs/import.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const imports = async () => {
-	const { requiredAny: [pluginImport, pluginAntfu], optional: [importResovlerTypescript] } = await resolvePackages(MODULES.import);
+	const { requiredAny: [pluginImport, pluginAntfu], optional: [importResolverTypescript] } = await resolvePackages(MODULES.import);
 	const plugins = {};
 	const settings = {};
 	let pluginImportRules = {};
+	let pluginImportTsRules = {};
 	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);
+		settings["import-x/resolver-next"] = [pluginImport.createNodeResolver(), importResolverTypescript === void 0 ? void 0 : importResolverTypescript.createTypeScriptImportResolver({ bun: true })].filter(Boolean);
+		if (isModuleEnabled(MODULES.typescript)) settings["import-x/extensions"] = [
+			".cjs",
+			".cts",
+			".js",
+			".jsx",
+			".mjs",
+			".mts",
+			".ts",
+			".tsx"
+		];
+		settings["import-x/ignore"] = [String.raw`[/\\]node_modules[/\\]`];
 		settings["import-x/core-modules"] = [
 			"bun",
 			"bun:bundle",
@@ -362,33 +2400,46 @@ const imports = async () => {
 			"bun:sqlite",
 			"bun:test"
 		];
-		const pluginImportTsRules = isModuleEnabled(MODULES.typescript) ? renameRules(pluginImport.flatConfigs.typescript.rules, { "import-x": "import" }) : {};
+		pluginImportTsRules = 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/consistent-type-specifier-style": "error",
 			"import/extensions": [
 				"error",
 				"ignorePackages",
 				{
-					js: "never",
-					ts: "never",
-					cts: "never",
-					mts: "never"
+					checkTypeImports: true,
+					pattern: {
+						js: "never",
+						ts: "never",
+						cts: "never",
+						mts: "never"
+					},
+					pathGroupOverrides: [{
+						pattern: "{{.,..,../..,../../..,../../../..,../../../../..}/**/declarations,$types/declarations,$declarations}{,/**}",
+						action: "ignore"
+					}]
 				}
 			],
 			"import/first": "error",
 			"import/max-dependencies": ["error", { max: 15 }],
+			"import/namespace": "off",
 			"import/newline-after-import": "error",
 			"import/no-absolute-path": "error",
 			"import/no-amd": "error",
-			"import/no-cycle": ["error", { maxDepth: 3 }],
+			"import/no-cycle": ["error", {
+				ignoreExternal: true,
+				maxDepth: 3
+			}],
 			"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-extraneous-dependencies": ["error", {
+				devDependencies: GLOB_DEVELOPMENT_FILES,
+				includeTypes: true
+			}],
 			"import/no-import-module-exports": "error",
 			"import/no-mutable-exports": "error",
 			"import/no-named-as-default-member": "error",
@@ -402,7 +2453,7 @@ const imports = async () => {
 			"import/no-useless-path-segments": ["error", { noUselessIndex: true }],
 			"import/no-unresolved": ["error", {
 				commonjs: true,
-				caseSensitive: true
+				caseSensitiveStrict: true
 			}],
 			"import/no-webpack-loader-syntax": "error",
 			"import/order": ["error", {
@@ -446,23 +2497,34 @@ const imports = async () => {
 			"antfu/no-import-node-modules-by-path": "error"
 		};
 	}
-	if (Object.keys(plugins).length === 0) return [];
+	if (objectKeys(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
-		}
-	}];
+	if (objectKeys(settings).length > 0) setupConfig.settings = settings;
+	return [
+		setupConfig,
+		{
+			name: buildConfigName(MAIN_SCOPES.IMPORT, SUB_SCOPES.RULES),
+			files: GLOB_SCRIPT_FILES,
+			rules: {
+				...pluginImportRules,
+				...pluginAntfuRules
+			}
+		},
+		...isModuleEnabled(MODULES.typescript) ? [{
+			name: buildConfigName(MAIN_SCOPES.IMPORT, `${SUB_SCOPES.RULES}-typescript`),
+			files: [GLOB_TS],
+			rules: pluginImportTsRules
+		}] : []
+	];
 };
 //#endregion
 //#region ../src/js/eslint/configs/javascript.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const javascript = async () => {
 	const { optional: [pluginAntfu, pluginUnusedImports] } = await resolvePackages(MODULES.javascript);
 	const plugins = {};
@@ -494,16 +2556,19 @@ const javascript = async () => {
 				ecmaFeatures: { jsx: true }
 			}
 		},
-		linterOptions: { reportUnusedDisableDirectives: "error" }
+		linterOptions: {
+			reportUnusedDisableDirectives: "error",
+			reportUnusedInlineConfigs: "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",
+			"accessor-pairs": ["error", { enforceForTSTypes: true }],
 			"array-callback-return": ["error", { checkForEach: true }],
-			"arrow-body-style": ["error", "as-needed"],
+			"arrow-body-style": "error",
 			"block-scoped-var": "error",
 			"capitalized-comments": [
 				"error",
@@ -531,8 +2596,12 @@ const javascript = async () => {
 				includeCommonJSModuleExports: true
 			}],
 			"func-names": "error",
-			"func-style": ["error", "expression"],
-			"grouped-accessor-pairs": "error",
+			"func-style": "error",
+			"grouped-accessor-pairs": [
+				"error",
+				"getBeforeSet",
+				{ enforceForTSTypes: true }
+			],
 			"guard-for-in": "error",
 			"init-declarations": "error",
 			"logical-assignment-operators": "error",
@@ -549,7 +2618,10 @@ const javascript = async () => {
 				skipBlankLines: true,
 				skipComments: true
 			}],
-			"max-nested-callbacks": ["error", { max: 3 }],
+			"max-nested-callbacks": ["error", {
+				max: 3,
+				checkConstructorCallCallbacks: true
+			}],
 			"max-params": ["error", { max: 4 }],
 			"max-statements": ["error", { max: 30 }],
 			"new-cap": "error",
@@ -560,6 +2632,8 @@ const javascript = async () => {
 			"no-caller": "error",
 			"no-cond-assign": ["error", "always"],
 			"no-console": "error",
+			"no-constant-binary-expression": ["error", { checkRelationalComparisons: true }],
+			"no-constant-condition": ["error", { checkLoops: "all" }],
 			"no-constructor-return": "error",
 			"no-div-regex": "error",
 			"no-duplicate-imports": isModuleEnabled(MODULES.import) ? "off" : ["error", { allowSeparateTypeImports: true }],
@@ -569,26 +2643,39 @@ const javascript = async () => {
 			"no-eval": "error",
 			"no-extend-native": "error",
 			"no-extra-bind": "error",
+			"no-extra-boolean-cast": ["error", { enforceForInnerExpressions: true }],
 			"no-extra-label": "error",
+			"no-fallthrough": ["error", {
+				allowEmptyCase: true,
+				reportUnusedFallthroughComment: true
+			}],
 			"no-implicit-coercion": ["error", { boolean: false }],
 			"no-implicit-globals": "error",
 			"no-implied-eval": "error",
 			"no-inline-comments": "error",
-			"no-inner-declarations": "error",
+			"no-inner-declarations": [
+				"error",
+				"functions",
+				{ blockScopedFunctions: "disallow" }
+			],
 			"no-invalid-this": "error",
+			"no-irregular-whitespace": ["error", { skipStrings: false }],
 			"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-magic-numbers": ["error", {
+				ignore: [
+					-1,
+					0,
+					1,
+					100,
+					42069
+				],
+				enforceConst: true
+			}],
 			"no-multi-assign": "error",
 			"no-multi-str": "error",
 			"no-negated-condition": "error",
@@ -649,14 +2736,20 @@ const javascript = async () => {
 			"no-return-assign": ["error", "always"],
 			"no-script-url": "error",
 			"no-self-compare": "error",
-			"no-sequences": "error",
-			"no-shadow": "error",
+			"no-sequences": ["error", { allowInParentheses: false }],
+			"no-shadow": ["error", { hoist: "all" }],
 			"no-template-curly-in-string": "error",
 			"no-throw-literal": "error",
-			"no-underscore-dangle": "error",
-			"no-unmodified-loop-condition": "error",
+			"no-undef": ["error", { typeof: true }],
+			"no-underscore-dangle": ["error", {
+				enforceInClassFields: true,
+				enforceInMethodNames: true
+			}],
+			"no-unmodified-loop-condition": ["error", { checkConditionalExpressions: true }],
 			"no-unneeded-ternary": ["error", { defaultAssignment: false }],
 			"no-unreachable-loop": "error",
+			"no-unsafe-negation": ["error", { enforceForOrderingRelations: true }],
+			"no-unsafe-optional-chaining": ["error", { disallowArithmeticOperators: true }],
 			"no-unused-expressions": "error",
 			"no-use-before-define": "error",
 			"no-useless-call": "error",
@@ -666,7 +2759,7 @@ const javascript = async () => {
 			"no-useless-rename": "error",
 			"no-useless-return": "error",
 			"no-var": "error",
-			"no-void": "error",
+			"no-void": ["error", { allowAsStatement: true }],
 			"no-warning-comments": "error",
 			"object-shorthand": [
 				"error",
@@ -677,7 +2770,7 @@ const javascript = async () => {
 				}
 			],
 			"operator-assignment": "error",
-			"prefer-arrow-callback": "error",
+			"prefer-arrow-callback": ["error", { allowUnboundThis: false }],
 			"prefer-const": ["error", { ignoreReadBeforeAssign: true }],
 			"prefer-destructuring": "error",
 			"prefer-exponentiation-operator": "error",
@@ -706,136 +2799,112 @@ const javascript = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/typescript.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 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;
+	if (!isModuleEnabled(MODULES.typescript)) return;
+	const { requiredAll: [, tsEslint] } = await resolvePackages(MODULES.typescript);
+	return tsEslint?.parser;
 };
-const resolveTypeAwareOptions = (resolvedOptions, files, ignores) => {
+const resolveTypeAwareOptions = (resolvedOptions, files, ignoredGlobs) => {
 	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])];
+	typeAwareOptions.files = [.../* @__PURE__ */ new Set([...typeAwareOptions.files ?? [], ...files])];
+	typeAwareOptions.ignores = [.../* @__PURE__ */ new Set([...typeAwareOptions.ignores ?? [], ...ignoredGlobs])];
 	return typeAwareOptions;
 };
 const extractRelevantRules = (configs, key) => {
 	for (const config of configs) 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({
+const getNamingConvention = () => [
+	"error",
+	{
+		selector: "default",
+		format: [
+			"strictCamelCase",
+			"StrictPascalCase",
+			"UPPER_CASE"
+		],
+		leadingUnderscore: "forbid",
+		trailingUnderscore: "forbid"
+	},
+	{
+		selector: ["objectLiteralProperty", "variable"],
+		format: ["strictCamelCase", "UPPER_CASE"]
+	},
+	{
 		selector: "variable",
-		types: ["boolean"],
+		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: [
-			"as",
-			"is",
-			"does",
-			"do",
-			"did",
-			"has",
-			"was",
-			"can"
-		]
-	});
-	return ruleOptions;
-};
+		prefix: ["T"],
+		custom: {
+			regex: "^[A-Z]",
+			match: true
+		}
+	},
+	{
+		selector: "interface",
+		format: ["StrictPascalCase"],
+		custom: {
+			regex: "^I[A-Z]",
+			match: false
+		}
+	}
+];
 const typescript = async (options) => {
 	const { requiredAll: [isTypescriptInstalled, tsEslint] } = await resolvePackages(MODULES.typescript);
 	if (!isTypescriptInstalled || !tsEslint) return [];
 	const { optional: [, pluginUnusedImports] } = await resolvePackages(MODULES.javascript);
 	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,
+		typeAware: doesTsConfigExist(resolveTsConfigPath(options)),
 		...options
 	};
-	const ignores = resolvedOptions.ignores ?? [];
-	const files = [...new Set([...resolvedOptions.extraFileExtensions.map((extension) => `**/*.${extension}`), ...resolvedOptions.files ?? GLOB_SCRIPT_FILES])];
+	const ignoredGlobs = resolvedOptions.ignores ?? [];
+	const files = [.../* @__PURE__ */ new Set([...resolvedOptions.extraFileExtensions.map((extension) => `**/*.${extension}`), ...resolvedOptions.files ?? GLOB_SCRIPT_FILES])];
 	const hasEnabledTypeAwareness = resolvedOptions.typeAware !== false;
-	const typeAwareOptions = hasEnabledTypeAwareness ? resolveTypeAwareOptions(resolvedOptions, files, ignores) : {};
+	const typeAwareOptions = hasEnabledTypeAwareness ? resolveTypeAwareOptions(resolvedOptions, files, ignoredGlobs) : {};
 	const createParserConfig = (isTypeAware) => ({
 		name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, `${SUB_SCOPES.PARSER}${isTypeAware ? "-type-aware" : ""}`),
 		files: isTypeAware ? typeAwareOptions.files : files,
-		ignores: isTypeAware ? typeAwareOptions.ignores : ignores,
+		ignores: isTypeAware ? typeAwareOptions.ignores : ignoredGlobs,
 		languageOptions: {
 			parser: tsEslint.parser,
 			parserOptions: {
@@ -851,9 +2920,9 @@ const typescript = async (options) => {
 	const createRulesConfig = (isTypeAware) => ({
 		name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, `${SUB_SCOPES.RULES}${isTypeAware ? "-type-aware" : ""}`),
 		files: isTypeAware ? typeAwareOptions.files : files,
-		ignores: isTypeAware ? typeAwareOptions.ignores : ignores,
+		ignores: isTypeAware ? typeAwareOptions.ignores : ignoredGlobs,
 		rules: {
-			"ts/naming-convention": getNamingConvention(isTypeAware),
+			"ts/naming-convention": getNamingConvention(),
 			...isTypeAware ? {
 				...extractRelevantRules(tsEslint.configs.recommendedTypeCheckedOnly, "recommended-type-checked-only"),
 				...extractRelevantRules(tsEslint.configs.strictTypeCheckedOnly, "strict-type-checked-only"),
@@ -864,11 +2933,19 @@ const typescript = async (options) => {
 				"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/no-base-to-string": ["error", { checkUnknown: true }],
+				"ts/no-floating-promises": ["error", { checkThenables: true }],
+				"ts/no-unnecessary-condition": ["error", { checkTypePredicates: true }],
+				"ts/only-throw-error": ["error", { allowThrowingUnknown: false }],
+				"ts/prefer-nullish-coalescing": ["error", { ignoreConditionalTests: false }],
+				"ts/return-await": ["error", "in-try-catch"],
+				"ts/strict-boolean-expressions": ["error", {
+					allowNumber: false,
+					allowString: false
+				}],
 				"ts/strict-void-return": "error",
 				"ts/switch-exhaustiveness-check": ["error", { requireDefaultForNonUnion: true }]
 			} : {
@@ -878,7 +2955,36 @@ const typescript = async (options) => {
 				...pluginUnusedImports ? { "ts/no-unused-vars": "off" } : void 0,
 				"ts/consistent-type-assertions": ["error", { assertionStyle: "angle-bracket" }],
 				"ts/consistent-type-imports": "error",
-				"ts/member-ordering": "error",
+				"ts/member-ordering": ["error", { default: [
+					"signature",
+					"call-signature",
+					["public-field", "public-accessor"],
+					["protected-field", "protected-accessor"],
+					["private-field", "private-accessor"],
+					["#private-field", "#private-accessor"],
+					"static-initialization",
+					"constructor",
+					[
+						"public-get",
+						"public-set",
+						"public-method"
+					],
+					[
+						"protected-get",
+						"protected-set",
+						"protected-method"
+					],
+					[
+						"private-get",
+						"private-set",
+						"private-method"
+					],
+					[
+						"#private-get",
+						"#private-set",
+						"#private-method"
+					]
+				] }],
 				"ts/method-signature-style": "error",
 				"ts/no-import-type-side-effects": "error",
 				"no-redeclare": "off",
@@ -891,6 +2997,7 @@ const typescript = async (options) => {
 			}
 		}
 	});
+	const coreRulesCoveredByTypescript = objectFromEntries(objectEntries(extractRelevantRules(tsEslint.configs.recommended, "eslint-recommended")).filter(([, severity]) => severity === "off"));
 	return [
 		{
 			name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, SUB_SCOPES.SETUP),
@@ -903,8 +3010,9 @@ const typescript = async (options) => {
 		{
 			name: buildConfigName(MAIN_SCOPES.TYPESCRIPT, `${SUB_SCOPES.RULES}-typescript`),
 			files: [GLOB_TS],
-			ignores: typeAwareOptions.ignores ?? ignores,
+			ignores: typeAwareOptions.ignores ?? ignoredGlobs,
 			rules: {
+				...coreRulesCoveredByTypescript,
 				"ts/explicit-function-return-type": "error",
 				"ts/explicit-member-accessibility": "error"
 			}
@@ -913,9 +3021,129 @@ const typescript = async (options) => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/jsdoc.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
+const TAGS_BY_MODULE = { test: ["vitest-environment", "vitest-environment-options"] };
+const EXAMPLE_CODE_REGEX = "/```(?:js|javascript|ts|typescript)\\s*\\n([\\s\\S]*?)\\n\\s*```/gv";
+const TAG_SEQUENCE = [
+	{ tags: [
+		"file",
+		"fileoverview",
+		"overview",
+		"module"
+	] },
+	{ tags: ["api", "internal"] },
+	{ tags: [
+		"deprecated",
+		"ignore",
+		"since",
+		"version",
+		["to", "do"].join("")
+	] },
+	{ tags: [
+		"author",
+		"copyright",
+		"license"
+	] },
+	{ tags: [
+		"summary",
+		"typeSummary",
+		"desc",
+		"description",
+		"classdesc"
+	] },
+	{ tags: [
+		"namespace",
+		"category",
+		"package"
+	] },
+	{ tags: ["import"] },
+	{ tags: ["typedef"] },
+	{ tags: ["template"] },
+	{ tags: [
+		"augments",
+		"extends",
+		"implements"
+	] },
+	{ tags: ["readonly"] },
+	{ tags: [
+		"override",
+		"requires",
+		"mixes",
+		"mixin",
+		"mixinClass",
+		"mixinFunction",
+		"borrows",
+		"constructs",
+		"lends",
+		"final",
+		"global",
+		"abstract",
+		"virtual",
+		"static",
+		"private",
+		"protected",
+		"public",
+		"access",
+		"const",
+		"constant",
+		"variation",
+		"var",
+		"member",
+		"memberof",
+		"inner",
+		"instance",
+		"inheritdoc",
+		"inheritDoc",
+		"hideconstructor"
+	] },
+	{ tags: ["name"] },
+	{ tags: [
+		"this",
+		"interface",
+		"enum",
+		"event",
+		"kind",
+		"type",
+		"alias",
+		"external",
+		"host",
+		"async",
+		"callback",
+		"func",
+		"function",
+		"method",
+		"class",
+		"constructor",
+		"generator",
+		"fires",
+		"emits",
+		"listens"
+	] },
+	{ tags: ["prop", "property"] },
+	{ tags: [
+		"param",
+		"arg",
+		"argument"
+	] },
+	{ tags: ["return", "returns"] },
+	{ tags: ["yield", "yields"] },
+	{ tags: ["throws", "exception"] },
+	{ tags: ["satisfies"] },
+	{ tags: ["default", "defaultvalue"] },
+	{ tags: ["exports"] },
+	{ tags: [
+		"link",
+		"see",
+		"tutorial"
+	] },
+	{ tags: ["example"] }
+];
 const jsdoc = async () => {
-	const { requiredAll: [pluginJsdoc], optional: [getJsdocProcessorPlugin] } = await resolvePackages(MODULES.jsdoc);
+	const { requiredAll: [pluginJsdoc], optional: [jsdocProcessorModule] } = await resolvePackages(MODULES.jsdoc);
 	if (!pluginJsdoc) return [];
+	const definedTags = ["api", ...isModuleEnabled(MODULES.test) ? TAGS_BY_MODULE.test : []];
 	const createSetupConfig = (isForTypescript) => ({
 		name: buildConfigName(MAIN_SCOPES.JSDOC, `${SUB_SCOPES.SETUP}${isForTypescript ? "-typescript" : ""}`),
 		...isForTypescript ? void 0 : { plugins: { jsdoc: pluginJsdoc } },
@@ -926,10 +3154,15 @@ const jsdoc = async () => {
 		files: isForTypescript ? [GLOB_TS] : [GLOB_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/check-tag-names": ["error", {
+				definedTags,
+				typed: true
+			}],
 			"jsdoc/require-param": "off",
 			"jsdoc/require-returns": "off"
 		} : {
 			...pluginJsdoc.configs["flat/recommended-error"].rules,
+			"jsdoc/check-tag-names": ["error", { definedTags }],
 			"jsdoc/check-indentation": ["error", { allowIndentedSections: true }],
 			"jsdoc/check-line-alignment": "error",
 			"jsdoc/check-syntax": "error",
@@ -942,123 +3175,21 @@ const jsdoc = async () => {
 				noSingleLineBlocks: true,
 				singleLineTags: []
 			}],
-			"jsdoc/no-bad-blocks": "error",
+			"jsdoc/no-bad-blocks": ["error", { preventAllMultiAsteriskBlocks: true }],
 			"jsdoc/no-blank-block-descriptions": "error",
 			"jsdoc/no-blank-blocks": "error",
+			"jsdoc/no-unnecessary-type-assertion": ["error", { preferConstToLiteralTuples: true }],
+			"jsdoc/normalize-see-links": "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-hyphen-before-param-description": ["error", "never"],
 			"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/sort-tags": ["error", { tagSequence: TAG_SEQUENCE }],
 			"jsdoc/tag-lines": [
 				"error",
 				"any",
@@ -1075,11 +3206,15 @@ const jsdoc = async () => {
 		} }
 	});
 	const parser = await getTsEslintParserIfExists();
-	const examplePlugin = getJsdocProcessorPlugin ? getJsdocProcessorPlugin.getJsdocProcessorPlugin({
+	const examplePlugin = jsdocProcessorModule ? jsdocProcessorModule.getJsdocProcessorPlugin({
 		checkDefaults: true,
 		checkExamples: true,
 		checkParams: true,
 		checkProperties: true,
+		exampleCodeRegex: EXAMPLE_CODE_REGEX,
+		matchingFileNameDefaults: "dummy.jsdoc-defaults.md/*.js",
+		matchingFileNameParams: "dummy.jsdoc-params.md/*.js",
+		matchingFileNameProperties: "dummy.jsdoc-properties.md/*.js",
 		parser
 	}) : void 0;
 	return [
@@ -1099,6 +3234,9 @@ const jsdoc = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/json.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const TSCONFIG_FILES = ["**/tsconfig.json", "**/tsconfig.*.json"];
 const JSON_FILES_TO_TREAT_AS_JSONC = [...TSCONFIG_FILES, ".vscode/**/*.json"];
 const LANGUAGE_TO_GLOB_MAP = {
@@ -1184,6 +3322,7 @@ const getJsoncSortConfigs = () => [
 						"lint-staged",
 						"eslintConfig",
 						"stylelint",
+						"markdownlint-cli2",
 						"prettier",
 						"ava",
 						"stackblitz",
@@ -1559,7 +3698,7 @@ const json = async () => {
 					{ emptyObjects: "never" }
 				],
 				"jsonc/object-property-newline": "error",
-				"jsonc/quotes": ["error", "double"]
+				"jsonc/quotes": "error"
 			} : void 0
 		}
 	});
@@ -1582,8 +3721,14 @@ const json = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/markdown.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const extractRelevantValues = (identifier, configs, key) => {
-	for (const config of configs) if (config.name === `markdown/${key}` && config[identifier] !== void 0 && config[identifier] !== null) return config[identifier];
+	for (const config of configs) {
+		const value = config[identifier] ?? void 0;
+		if (value !== void 0 && config.name === `markdown/${key}`) return value;
+	}
 	throw new Error(`Expected key "${key}" to be contained in given config.`);
 };
 const markdown = async (options) => {
@@ -1634,7 +3779,10 @@ const markdown = async (options) => {
 					"summary",
 					"sup",
 					"var"
-				] }]
+				] }],
+				"markdown/no-space-in-emphasis": ["error", { checkStrikethrough: true }],
+				"markdown/table-column-count": ["error", { checkMissingCells: true }],
+				...isModuleEnabled(MODULES.unicorn) ? { "unicorn/no-missing-local-resource": "error" } : void 0
 			}
 		},
 		{
@@ -1648,10 +3796,12 @@ const markdown = async (options) => {
 				"no-inline-comments": "off",
 				"no-magic-numbers": "off",
 				"import/no-default-export": "off",
+				"import/no-extraneous-dependencies": "off",
 				"import/unambiguous": "off",
 				"node/no-missing-import": "off",
 				"ts/no-redeclare": "off",
 				"ts/no-unused-vars": "off",
+				"unicorn/no-barrel-files": "off",
 				"unused/no-unused-imports": "off",
 				"unused/no-unused-vars": "off"
 			}
@@ -1660,6 +3810,9 @@ const markdown = async (options) => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/node.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const node = async (options) => {
 	const { requiredAll: [pluginNode] } = await resolvePackages(MODULES.node);
 	if (!pluginNode) return [];
@@ -1675,12 +3828,12 @@ const node = async (options) => {
 			"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/no-unpublished-bin": "error",
 			"node/prefer-global/buffer": "error",
 			"node/prefer-global/console": "error",
 			"node/prefer-global/crypto": "error",
@@ -1690,17 +3843,29 @@ const node = async (options) => {
 			"node/prefer-global/timers": "error",
 			"node/prefer-global/url-search-params": "error",
 			"node/prefer-global/url": "error",
+			"node/prefer-import/assert-strict": "error",
 			"node/prefer-node-protocol": "error",
+			"node/prefer-process-get-builtin-module": "error",
 			"node/prefer-promises/dns": "error",
-			"node/prefer-promises/fs": "error"
+			"node/prefer-promises/fs": "error",
+			...isModuleEnabled(MODULES.import) && doAllPackagesExist([ESLINT_PACKAGES.ESLINT_PLUGIN_IMPORT_X]) ? {
+				"node/no-extraneous-import": "off",
+				"node/no-extraneous-require": "off"
+			} : void 0
 		}
 	}];
 };
 //#endregion
 //#region ../src/js/eslint/configs/unicorn.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const FILE_NAMES_TO_IGNORE = [
+	"__mocks__",
+	"__tests__",
 	"ACKNOWLEDGMENTS.md",
 	"ADOPTERS.md",
+	"AGENT_INSTRUCTIONS.md",
 	"AGENTS.md",
 	"API_REFERENCE.md",
 	"ARCHITECTURE.md",
@@ -1726,6 +3891,7 @@ const FILE_NAMES_TO_IGNORE = [
 	"FAQ.md",
 	"GOVERNANCE.md",
 	"INSTALL.md",
+	"INSTRUCTIONS.md",
 	"ISSUE_TEMPLATE.md",
 	"LICENSE.md",
 	"LLMS.md",
@@ -1749,10 +3915,10 @@ const FILE_NAMES_TO_IGNORE = [
 	"RELEASING.md",
 	"RESEARCH.md",
 	"ROADMAP.md",
-	"SKILL.md",
-	"SPEC.md",
 	"SECURITY_POLICY.md",
 	"SECURITY.md",
+	"SKILL.md",
+	"SPEC.md",
 	"STYLE_GUIDE.md",
 	"SUPPORT.md",
 	"TESTING.md",
@@ -1762,6 +3928,21 @@ const FILE_NAMES_TO_IGNORE = [
 	"UPGRADE_NOTES.md",
 	"VERSIONING.md"
 ];
+const COMMENT_TERMS = [
+	"commitlint",
+	"JSDoc",
+	"PHP",
+	"PHPStan",
+	"PHPUnit",
+	"pnpm",
+	"PostCSS",
+	"SCSS",
+	"Stylelint",
+	"Symfony",
+	"TOML",
+	"TSDoc",
+	"Vitest"
+];
 const unicorn = async () => {
 	const { requiredAll: [pluginUnicorn] } = await resolvePackages(MODULES.unicorn);
 	if (!pluginUnicorn) return [];
@@ -1773,30 +3954,114 @@ const unicorn = async () => {
 		files: GLOB_SCRIPT_FILES,
 		rules: {
 			...pluginUnicorn.configs.recommended.rules,
-			"unicorn/better-regex": "error",
+			"no-else-return": "off",
+			"no-useless-concat": "off",
+			"operator-assignment": "off",
+			"unicorn/comment-content": ["error", { replacements: {
+				[String.raw`\bapplication\b(?!/)`]: false,
+				[String.raw`\bapplications\b`]: false,
+				...Object.fromEntries(COMMENT_TERMS.map((term) => [String.raw`\b${term}\b`, {
+					replacement: term,
+					caseSensitive: false
+				}]))
+			} }],
+			"unicorn/consistent-boolean-name": "off",
+			"unicorn/consistent-class-member-order": ["error", { order: [
+				"public-field",
+				"static-field",
+				"private-field",
+				"static-block",
+				"constructor",
+				"public-method",
+				"static-method",
+				"private-method"
+			] }],
+			"unicorn/consistent-conditional-object-spread": ["error", "ternary"],
 			"unicorn/consistent-destructuring": "error",
+			"func-style": "off",
+			"unicorn/consistent-function-style": ["error", {
+				defaultExport: "arrow-function",
+				namedExports: "arrow-function",
+				namedFunctions: "arrow-function",
+				objectProperties: "arrow-function",
+				reassignedVariables: "arrow-function",
+				typedVariables: "arrow-function"
+			}],
 			"unicorn/custom-error-definition": "error",
 			"unicorn/filename-case": ["error", {
 				case: "kebabCase",
 				ignore: FILE_NAMES_TO_IGNORE
 			}],
 			"unicorn/require-post-message-target-origin": "error",
+			"unicorn/iteration-fallback-style": ["error", "fallback"],
+			"unicorn/name-replacements": ["error", {
+				replacements: {
+					application: false,
+					applications: false,
+					repository: false
+				},
+				ignore: ["[Ii]nheritDoc", String.raw`\.dist$`]
+			}],
+			"unicorn/no-accidental-bitwise-operator": "off",
+			"unicorn/no-array-front-mutation": "error",
+			"unicorn/no-array-reduce": ["error", { allowSimpleOperations: false }],
+			"unicorn/no-array-reverse": ["error", { allowExpressionStatement: false }],
+			"unicorn/no-array-sort": ["error", { allowExpressionStatement: false }],
+			"unicorn/no-barrel-files": "error",
+			"unicorn/no-instanceof-builtins": ["error", { useErrorIsError: true }],
+			"unicorn/no-invalid-file-input-accept": "error",
 			"unicorn/no-keyword-prefix": "error",
-			"unicorn/no-nested-ternay": "off",
-			"no-nested-ternary": "error",
+			"unicorn/no-manually-wrapped-comments": "error",
+			"unicorn/no-missing-local-resource": "error",
+			"unicorn/no-negated-comparison": ["error", { checkLogicalExpressions: true }],
+			"unicorn/no-null": ["error", { checkStrictEquality: true }],
+			"unicorn/no-typeof-undefined": ["error", { checkGlobalVariables: true }],
+			"unicorn/no-unsafe-dom-html": "error",
 			"unicorn/no-unused-properties": "error",
-			"unicorn/prefer-json-parse-buffer": "error",
+			"unicorn/numeric-separators-style": ["error", {
+				binary: {
+					minimumDigits: 9,
+					groupLength: 8
+				},
+				hexadecimal: {
+					minimumDigits: 3,
+					groupLength: 2
+				},
+				number: {
+					minimumDigits: 4,
+					groupLength: 3,
+					fractionGroupLength: 3
+				},
+				octal: {
+					minimumDigits: 4,
+					groupLength: 3
+				}
+			}],
+			"unicorn/prefer-dispose": "error",
+			"unicorn/prefer-error-is-error": "error",
+			"unicorn/prefer-minimal-ternary": ["error", {
+				checkComputedMemberAccess: true,
+				checkVaryingBase: true
+			}],
+			"unicorn/prefer-queue-microtask": ["error", {
+				checkSetImmediate: true,
+				checkSetTimeout: true
+			}],
+			"unicorn/prefer-regexp-escape": "error",
+			"unicorn/prefer-short-arrow-method": "error",
 			"unicorn/prefer-switch": "off",
-			"unicorn/string-content": ["error", { patterns: {
-				"\\.\\.\\.": "…",
-				"^http:\\/\\/": String.raw`^https:\/\/`
-			} }],
-			"unicorn/text-encoding-identifier-case": ["error", { withDash: true }]
+			"unicorn/require-css-escape": ["error", { checkAllSelectors: true }],
+			"unicorn/string-content": ["error", { patterns: { "\\.\\.\\.": "…" } }],
+			"unicorn/text-encoding-identifier-case": ["error", { withDash: true }],
+			"unicorn/try-complexity": "error"
 		}
 	}];
 };
 //#endregion
 //#region ../src/js/eslint/configs/overrides.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const jsOverrides = [{
 	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.JAVASCRIPT}/scripts`),
 	files: ["scripts/**/*.?(c)js"],
@@ -1844,6 +4109,25 @@ const tsOverrides = isModuleEnabled(MODULES.typescript) ? [{
 		"import/no-named-as-default-member": "off"
 	}
 }] : [];
+const importOverrides = isModuleEnabled(MODULES.import) && isModuleEnabled(MODULES.typescript) ? [{
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.IMPORT}/${MAIN_SCOPES.TYPESCRIPT}`),
+	files: [GLOB_TS],
+	rules: {
+		"import/default": "off",
+		"import/named": "off",
+		"import/no-named-as-default-member": "off",
+		"import/no-unresolved": "off"
+	}
+}] : [];
+const buildTypeAwareImportOverrides = (typescriptOptions) => {
+	const resolvedOptions = typeof typescriptOptions === "object" ? typescriptOptions : void 0;
+	return isModuleEnabled(MODULES.import) && isModuleEnabled(MODULES.typescript) && (resolvedOptions?.typeAware ?? doesTsConfigExist(resolveTsConfigPath(resolvedOptions))) !== false ? [{
+		name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.IMPORT}/type-aware`),
+		files: [GLOB_TS],
+		ignores: DEFAULT_TYPE_AWARE_IGNORES,
+		rules: { "import/no-deprecated": "off" }
+	}] : [];
+};
 const testOverrides = isModuleEnabled(MODULES.test) ? [{
 	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.TEST}/general`),
 	files: GLOB_TEST_FILES,
@@ -1854,46 +4138,62 @@ const unicornOverrides = isModuleEnabled(MODULES.unicorn) ? [{
 	files: [...GLOB_SCRIPT_FILES.map((glob) => `**/classes/${glob}`), ...GLOB_SCRIPT_FILES.map((glob) => `**/errors/${glob}`)],
 	rules: { "unicorn/filename-case": ["error", {
 		case: "pascalCase",
+		checkDirectories: false,
 		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",
-		"unused/no-unused-imports": "off",
-		"unused/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 jsdocOverrides = isModuleEnabled(MODULES.jsdoc) ? [
+	...isModuleEnabled(MODULES[packageOrganization]) ? [{
+		name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.JSDOC}/internal-tag`),
+		files: GLOB_SCRIPT_FILES,
+		settings: { jsdoc: { structuredTags: { internal: {
+			name: "text",
+			type: false
+		} } } },
+		rules: { "jsdoc/empty-tags": "off" }
+	}] : [],
+	{
+		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/no-self-import": "off",
+			"import/unambiguous": "off",
+			"style/eol-last": "off",
+			"style/no-multiple-empty-lines": "off",
+			"ts/no-unused-expressions": "off",
+			"ts/no-unused-vars": "off",
+			"unicorn/no-null": "off",
+			"unicorn/no-useless-undefined": "off",
+			"unused/no-unused-imports": "off",
+			"unused/no-unused-vars": "off"
+		}
+	},
+	{
+		name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.JSDOC}/default-expressions`),
+		files: [
+			"**/*.jsdoc-defaults.md/*.js",
+			"**/*.jsdoc-params.md/*.js",
+			"**/*.jsdoc-properties.md/*.js"
+		],
+		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],
@@ -1905,11 +4205,14 @@ const svelteOverrides = isModuleEnabled(MODULES.svelte) ? [{
 		"svelte/comment-directive": ["error", { reportUnusedDisableDirectives: true }],
 		"svelte/system": "error"
 	}
-}, {
+}, ...isModuleEnabled(MODULES.unicorn) ? [{
 	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.SVELTE}/components`),
 	files: [`**/components/${GLOB_SVELTE}`],
-	rules: { "unicorn/filename-case": ["error", { case: "pascalCase" }] }
-}] : [];
+	rules: { "unicorn/filename-case": ["error", {
+		case: "pascalCase",
+		checkDirectories: false
+	}] }
+}] : []] : [];
 const tomlOverrides = isModuleEnabled(MODULES.toml) ? [{
 	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.TOML}/general`),
 	files: [GLOB_TOML],
@@ -1922,10 +4225,16 @@ const yamlOverrides = isModuleEnabled(MODULES.yaml) ? [{
 		"no-irregular-whitespace": "off",
 		"no-unused-vars": "off"
 	}
+}, {
+	name: buildConfigName(MAIN_SCOPES.OVERRIDES, `${MAIN_SCOPES.YAML}/extension`),
+	files: GLOB_YAML_FIXED_EXTENSION_FILES,
+	rules: { "yaml/file-extension": "off" }
 }] : [];
-const overrides = () => [
+const overrides = (typescriptOptions) => [
 	...jsOverrides,
 	...tsOverrides,
+	...importOverrides,
+	...buildTypeAwareImportOverrides(typescriptOptions),
 	...testOverrides,
 	...unicornOverrides,
 	...jsdocOverrides,
@@ -1944,12 +4253,16 @@ const overrides = () => [
 			"import/no-default-export": "off",
 			"import/no-rename-default": "off",
 			"import/no-named-as-default-member": "off",
-			"node/no-sync": "off"
+			"node/no-sync": "off",
+			"unicorn/no-barrel-files": "off"
 		}
 	}
 ];
 //#endregion
 //#region ../src/js/eslint/configs/perfectionist.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const perfectionist = async () => {
 	const { requiredAll: [pluginPerfectionist] } = await resolvePackages(MODULES.perfectionist);
 	if (!pluginPerfectionist) return [];
@@ -1971,6 +4284,9 @@ const perfectionist = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/regexp.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const regexp = async () => {
 	const { requiredAll: [pluginRegExp] } = await resolvePackages(MODULES.regexp);
 	if (!pluginRegExp) return [];
@@ -1985,10 +4301,8 @@ const regexp = async () => {
 			"regexp/confusing-quantifier": "error",
 			"regexp/grapheme-string-literal": "error",
 			"regexp/letter-case": ["error", {
-				caseInsensitive: "lowercase",
-				unicodeEscape: "lowercase",
-				hexadecimalEscape: "lowercase",
-				controlEscape: "uppercase"
+				unicodeEscape: "uppercase",
+				hexadecimalEscape: "uppercase"
 			}],
 			"regexp/no-control-character": "error",
 			"regexp/no-empty-alternative": "error",
@@ -2013,7 +4327,6 @@ const regexp = async () => {
 			"regexp/sort-character-class-elements": "error",
 			"regexp/unicode-escape": "error",
 			"regexp/unicode-property": ["error", {
-				generalCategory: "never",
 				key: "short",
 				property: "long"
 			}]
@@ -2022,21 +4335,22 @@ const regexp = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/style.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const style = async () => {
 	const { requiredAll: [pluginStyle] } = await resolvePackages(MODULES.style);
 	if (!pluginStyle) return [];
 	const styleConfig = pluginStyle.configs.customize({
-		jsx: true,
 		semi: true,
 		indent: 2,
 		quotes: QUOTES,
 		quoteProps: "as-needed",
 		arrowParens: true,
-		blockSpacing: true,
-		braceStyle: "1tbs",
-		commaDangle: "always-multiline"
+		braceStyle: "1tbs"
 	});
-	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;
+	const indentRuleEntry = styleConfig.rules?.["@stylistic/indent"];
+	const indentRuleConfig = Array.isArray(indentRuleEntry) && isPlainObject(indentRuleEntry[2]) ? indentRuleEntry[2] : void 0;
 	return [{
 		name: buildConfigName(MAIN_SCOPES.STYLE, SUB_SCOPES.SETUP),
 		plugins: { style: pluginStyle }
@@ -2343,6 +4657,9 @@ const style = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/svelte.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const extractRelevantConfig = (configs, key) => {
 	for (const config of configs) if (config.name === `svelte:${key}` && config.rules) return config;
 	throw new Error(`Expected key "${key}" to be contained in given config.`);
@@ -2383,14 +4700,11 @@ const svelte = async () => {
 					style: ["scss", null]
 				}],
 				"svelte/button-has-type": "error",
-				"svelte/consistent-selector-style": ["error", {
-					checkGlobal: false,
-					style: [
-						"type",
-						"class",
-						"id"
-					]
-				}],
+				"svelte/consistent-selector-style": ["error", { style: [
+					"type",
+					"class",
+					"id"
+				] }],
 				"svelte/derived-has-same-inputs-outputs": "error",
 				"svelte/experimental-require-strict-events": "error",
 				"svelte/experimental-require-slot-types": "error",
@@ -2404,25 +4718,29 @@ const svelte = async () => {
 				}],
 				"style/indent": "off",
 				"svelte/indent": ["error", { indent: 2 }],
-				"svelte/max-attributes-per-line": ["error", {
-					multiline: 1,
-					singleline: 3
-				}],
+				"svelte/max-attributes-per-line": ["error", { singleline: 3 }],
 				"svelte/mustache-spacing": "error",
 				"svelte/no-add-event-listener": "error",
+				"svelte/no-at-const-tags": "error",
 				"svelte/no-at-debug-tags": "error",
+				"svelte/no-bind-value-on-checkable-inputs": "error",
+				"svelte/no-conflicting-module-names": "error",
 				"svelte/no-extra-reactive-curlies": "error",
 				"svelte/no-ignored-unsubscribe": "error",
-				"svelte/no-inline-styles": "error",
+				"svelte/no-inline-styles": ["error", { allowTransitions: false }],
 				"svelte/no-inspect": "error",
+				"svelte/no-nested-style-tag": "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/no-unused-props": ["error", { checkImportedTypes: true }],
+				"svelte/prefer-attribute-interpolation": "error",
 				"svelte/prefer-class-directive": "error",
 				"prefer-const": "off",
 				"svelte/prefer-const": "error",
+				"svelte/prefer-derived-over-derived-by": "error",
 				"svelte/prefer-destructured-store-props": "error",
 				"svelte/prefer-style-directive": "error",
 				"svelte/require-event-prefix": "error",
@@ -2441,6 +4759,9 @@ const svelte = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/test.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const test = async () => {
 	const { requiredAll: [pluginVitest] } = await resolvePackages(MODULES.test);
 	if (!pluginVitest) return [];
@@ -2480,7 +4801,7 @@ const test = async () => {
 			"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-lowercase-title": ["error", { ignore: ["describe"] }],
 			"test/prefer-mock-promise-shorthand": "error",
 			"test/prefer-snapshot-hint": "error",
 			"test/prefer-spy-on": "error",
@@ -2494,13 +4815,17 @@ const test = async () => {
 			"test/prefer-vi-mocked": "error",
 			"test/require-awaited-expect-poll": "error",
 			"test/require-hook": "error",
-			"test/require-mock-type-parameters": "error",
+			"test/require-mock-type-parameters": ["error", { checkImportFunctions: true }],
+			"test/valid-expect": ["error", { alwaysAwait: true }],
 			"test/warn-todo": "error"
 		}
 	}];
 };
 //#endregion
 //#region ../src/js/eslint/configs/toml.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const toml = async () => {
 	const { requiredAll: [pluginToml] } = await resolvePackages(MODULES.toml);
 	if (!pluginToml) return [];
@@ -2526,6 +4851,9 @@ const toml = async () => {
 };
 //#endregion
 //#region ../src/js/eslint/configs/yaml.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const yaml = async () => {
 	const { requiredAll: [pluginYaml] } = await resolvePackages(MODULES.yaml);
 	if (!pluginYaml) return [];
@@ -2538,7 +4866,6 @@ const yaml = async () => {
 		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",
@@ -2546,23 +4873,21 @@ const yaml = async () => {
 				{ emptyObjects: "never" }
 			],
 			"yaml/indent": ["error", 2],
-			"yaml/no-multiple-empty-lines": "error",
-			"yaml/no-trailing-zeros": "error",
-			"yaml/quotes": ["error", {
-				avoidEscape: true,
-				prefer: QUOTES
-			}],
+			"yaml/no-boolean-key": "error",
+			"yaml/quotes": ["error", { prefer: QUOTES }],
 			"yaml/require-string-key": "error"
 		}
 	}];
 };
 //#endregion
 //#region ../src/js/eslint/configs/index.ts
+/**
+* @internal @brnshkr/config/eslint
+*/
 const configs = {
 	[packageOrganization]: builtinConfig[packageOrganization],
 	comments,
 	css,
-	gitignore,
 	ignores,
 	import: imports,
 	javascript,
@@ -2583,12 +4908,49 @@ const configs = {
 };
 //#endregion
 //#region ../src/js/eslint/index.ts
+/**
+* Build the `@brnshkr` ESLint flat config composer.
+*
+* Merges sensible defaults for every supported module (TypeScript, Svelte, JSDoc, etc.) with user
+* overrides and any additional flat configs. Modules whose optional peer dependency is not installed
+* are skipped automatically, so consumers only opt into what they use.
+*
+* @api
+*
+* @param optionsAndGlobalConfig per-module toggles and global flat-config fields (`files`,
+* `ignores`, `languageOptions`, etc.) merged with the defaults
+* @param additionalConfigs extra flat-config entries appended after the built-in ones
+*
+* @returns configured {@link FlatConfigComposer} that resolves to the final flat-config array
+*
+* @see https://github.com/brnshkr/config/blob/master/docs/js/eslint/index.md
+*
+* @example
+* ```js
+* import { getConfig } from '@brnshkr/config/eslint';
+*
+* getConfig(undefined);
+* getConfig({});
+*
+* getConfig({
+*   svelte: false,
+*   files: ['src/**'],
+* }, {
+*   files: ['scripts/**'],
+*   rules: { 'no-console': 'off' },
+* });
+*
+* getConfig(undefined, {
+*   files: ['scripts/**'],
+*   rules: { 'no-console': 'off' },
+* });
+* ```
+*/
 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),
@@ -2607,8 +4969,7 @@ const getConfig = (optionsAndGlobalConfig, ...additionalConfigs) => {
 	};
 	setModuleEnabled(MODULES[packageOrganization], resolvedOptions[packageOrganization]);
 	setModuleEnabled(MODULES.comments, resolvedOptions.comments);
-	setModuleEnabled(MODULES.css, resolvedOptions.css);
-	setModuleEnabled(MODULES.gitignore, resolvedOptions.gitignore !== false);
+	setModuleEnabled(MODULES.css, resolvedOptions.css !== false);
 	setModuleEnabled(MODULES.import, resolvedOptions.import);
 	setModuleEnabled(MODULES.jsdoc, resolvedOptions.jsdoc);
 	setModuleEnabled(MODULES.json, resolvedOptions.json);
@@ -2628,13 +4989,12 @@ const getConfig = (optionsAndGlobalConfig, ...additionalConfigs) => {
 		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[packageOrganization])) appendToComposer(configs[packageOrganization](resolvedOptions.typescript));
 	if (isModuleEnabled(MODULES.comments)) appendToComposer(configs.comments());
 	if (isModuleEnabled(MODULES.regexp)) appendToComposer(configs.regexp());
 	if (isModuleEnabled(MODULES.unicorn)) appendToComposer(configs.unicorn());
@@ -2645,12 +5005,17 @@ const getConfig = (optionsAndGlobalConfig, ...additionalConfigs) => {
 	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.css)) appendToComposer(configs.css(typeof resolvedOptions.css === "object" ? resolvedOptions.css : void 0));
 	if (isModuleEnabled(MODULES.markdown)) appendToComposer(configs.markdown(typeof resolvedOptions.markdown === "object" ? resolvedOptions.markdown : void 0));
-	appendToComposer(configs.overrides());
+	appendToComposer(configs.overrides(resolvedOptions.typescript));
 	appendToComposer(...getUserConfigs(resolvedOptions, additionalConfigs));
 	return composer;
 };
+/**
+* Default-exported pre-built composer for direct re-export from an ESLint flat-config file.
+*
+* @api
+*/
 var eslint_default = getConfig();
 //#endregion
 export { eslint_default as default, getConfig };