lintmax 0.1.44

package/dist/src-D4isRHIx.mjs

@@ -0,0 +1,822 @@
+import { c as SHARED_OVERRIDE_SYMBOL_KEY, i as DEFAULT_SHARED_IGNORE_PATTERNS, n as BIOME_PATTERN_RULE_OVERRIDES, r as BIOME_RULES_OFF, s as OXLINT_PATTERN_RULE_OVERRIDES, t as BIOME_IGNORE_PATTERNS } from "./constants-BRYEJmsZ.mjs";
+import { a as assertJsonSerializable, c as findUnknownRules, d as normalizeObjectListInput, f as normalizePathListInput, h as stripPluginNamespace, i as joinPath, l as isRecord, m as normalizeTailwindOption, n as fromFileUrl, o as assertObject, p as normalizeRulesOffInput, s as assertOptionalString, t as dirnamePath, u as normalizeIgnorePattern } from "./path-Cu_Nf2ct.mjs";
+import { file, spawnSync, write } from "bun";
+import { lstatSync } from "node:fs";
+import { join, relative } from "node:path";
+//#region src/core.ts
+/** biome-ignore-all lint/style/useConsistentMemberAccessibility: biome+eslint conflict */
+var CliExitError = class extends Error {
+	code;
+	name = "CliExitError";
+	constructor({ code, message }) {
+		super(message ?? "");
+		this.code = code;
+	}
+};
+const decoder = new TextDecoder();
+const cacheDir = "node_modules/.cache/lintmax";
+const cwd = process.cwd();
+const ignoreEntries = [".cache/", ".eslintcache"];
+const lintmaxRoot = dirnamePath(dirnamePath(fromFileUrl(import.meta.url)));
+const PRETTIER_MD_ARGS = [
+	"--single-quote",
+	"--no-semi",
+	"--trailing-comma",
+	"none",
+	"--print-width",
+	"80",
+	"--arrow-parens",
+	"avoid",
+	"--tab-width",
+	"2",
+	"--prose-wrap",
+	"preserve"
+];
+const parseJsonObject = ({ text }) => {
+	const parsed = JSON.parse(text);
+	return isRecord(parsed) ? parsed : {};
+};
+const decodeText = (bytes) => decoder.decode(bytes ?? new Uint8Array());
+const pathExists = async ({ path }) => file(path).exists();
+const readJson = async ({ path }) => {
+	if (!await pathExists({ path })) return {};
+	try {
+		return parseJsonObject({ text: await file(path).text() });
+	} catch {
+		return {};
+	}
+};
+const readRequiredJson = async ({ path }) => {
+	const text = await file(path).text();
+	return JSON.parse(text);
+};
+const writeJson = async ({ data, path }) => write(path, `${JSON.stringify(data, null, 2)}\n`);
+const ensureDirectory = ({ directory }) => {
+	const result = spawnSync({
+		cmd: [
+			"mkdir",
+			"-p",
+			directory
+		],
+		stderr: "pipe",
+		stdout: "pipe"
+	});
+	if (result.exitCode === 0) return;
+	const stderr = decodeText(result.stderr).trim();
+	throw new CliExitError({
+		code: result.exitCode,
+		message: stderr.length > 0 ? stderr : `Failed to create directory: ${directory}`
+	});
+};
+const resolvePackageJsonPath = async ({ pkg }) => {
+	try {
+		return fromFileUrl(import.meta.resolve(`${pkg}/package.json`));
+	} catch {
+		const consumerCandidate = joinPath(cwd, "node_modules", pkg, "package.json");
+		if (await pathExists({ path: consumerCandidate })) return consumerCandidate;
+		return null;
+	}
+};
+const resolveBin = async ({ bin, pkg }) => {
+	const packageJsonPath = await resolvePackageJsonPath({ pkg });
+	if (!packageJsonPath) throw new CliExitError({
+		code: 1,
+		message: `Cannot find ${pkg} — run: bun add -d ${pkg}`
+	});
+	const pkgJson = await readRequiredJson({ path: packageJsonPath });
+	return joinPath(dirnamePath(packageJsonPath), typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.[bin] ?? "");
+};
+const run = ({ args, command, env, label, silent = false }) => {
+	const result = spawnSync({
+		cmd: [command, ...args],
+		cwd,
+		env,
+		stderr: silent ? "pipe" : "inherit",
+		stdout: silent ? "pipe" : "inherit"
+	});
+	if (result.exitCode === 0) return;
+	if (silent) {
+		process.stderr.write(`[${label}]\n`);
+		const stdout = decodeText(result.stdout);
+		if (stdout.length > 0) process.stderr.write(stdout);
+		const stderr = decodeText(result.stderr);
+		if (stderr.length > 0) process.stderr.write(stderr);
+	}
+	throw new CliExitError({ code: result.exitCode });
+};
+const runCapture = ({ args, command, env }) => {
+	const result = spawnSync({
+		cmd: [command, ...args],
+		cwd,
+		env,
+		stderr: "pipe",
+		stdout: "pipe"
+	});
+	return {
+		exitCode: result.exitCode,
+		stderr: decodeText(result.stderr),
+		stdout: decodeText(result.stdout)
+	};
+};
+const readVersion = async () => {
+	return (await readRequiredJson({ path: joinPath(lintmaxRoot, "package.json") })).version;
+};
+const usage = ({ version }) => {
+	process.stdout.write(`lintmax v${version}\n\n`);
+	process.stdout.write("Usage: lintmax <command>\n\n");
+	process.stdout.write("Commands:\n");
+	process.stdout.write("  init     Scaffold config files for a new project\n");
+	process.stdout.write("  fix      Auto-fix and format all files\n");
+	process.stdout.write("  check    Check all files without modifying\n");
+	process.stdout.write("  rules    List all enabled rules\n");
+	process.stdout.write("  --version  Show version\n");
+};
+//#endregion
+//#region src/index.ts
+const SHARED_OVERRIDE_KEYS = [
+	"biome",
+	"eslint",
+	"oxlint"
+];
+const ESLINT_IMPORT_MARKER_KEY = "__lintmaxImportRef";
+const ESLINT_IMPORT_SENTINEL = "eslint-import";
+const pkgRoot = dirnamePath(fromFileUrl(import.meta.resolve("../package.json")));
+const normalizeBiomeIgnorePattern = ({ pattern }) => {
+	if (pattern.startsWith("!!")) return pattern;
+	const trimmed = normalizeIgnorePattern({ pattern });
+	return trimmed.startsWith("**/") ? `!!${trimmed}` : `!!**/${trimmed}`;
+};
+const resolveSchemaPath = async ({ cwd }) => {
+	try {
+		return fromFileUrl(import.meta.resolve("@biomejs/biome/configuration_schema.json"));
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+	}
+	const consumerCandidate = joinPath(cwd, "node_modules", "@biomejs", "biome", "configuration_schema.json");
+	if (await file(consumerCandidate).exists()) return consumerCandidate;
+	throw new Error("Cannot find module @biomejs/biome/configuration_schema.json");
+};
+const resolveBiomeSchema = async ({ cwd }) => {
+	const schema = await readRequiredJson({ path: await resolveSchemaPath({ cwd }) });
+	const rulesProps = schema.$defs.Rules?.properties ?? {};
+	const categories = Object.keys(rulesProps).filter((k) => k !== "recommended");
+	const ruleMap = /* @__PURE__ */ new Map();
+	for (const cat of categories) {
+		const key = cat.charAt(0).toUpperCase() + cat.slice(1);
+		const props = schema.$defs[key]?.properties;
+		if (props) {
+			for (const rule of Object.keys(props)) if (rule !== "recommended" && rule !== "all") ruleMap.set(rule, cat);
+		}
+	}
+	return {
+		categories,
+		ruleMap
+	};
+};
+const extractRuleNames = (rules) => {
+	const names = [];
+	for (const key of Object.keys(rules)) names.push(stripPluginNamespace({ rule: key }));
+	return names;
+};
+const assertKnownBiomeRuleNames = ({ categoryMap, label, rules }) => {
+	const unknown = findUnknownRules({
+		knownRules: new Set(categoryMap.keys()),
+		normalizeRule: (rule) => stripPluginNamespace({ rule }),
+		rules
+	});
+	if (unknown.length > 0) throw new Error(`${label} contains unknown biome rules: ${unknown.join(", ")}`);
+};
+const assertKnownOxlintRuleNames = ({ label, rules, knownRules }) => {
+	const unknown = findUnknownRules({
+		knownRules,
+		rules
+	});
+	if (unknown.length > 0) throw new Error(`${label} contains unknown oxlint rules: ${unknown.join(", ")}`);
+};
+const groupByCategory = ({ categoryMap, ruleNames }) => {
+	const result = {};
+	for (const rule of ruleNames) {
+		const cat = categoryMap.get(rule);
+		if (cat) {
+			result[cat] ??= {};
+			result[cat][rule] = "off";
+		}
+	}
+	return result;
+};
+const normalizeSharedOverrideItem = ({ index, item, label }) => {
+	const files = normalizePathListInput({
+		label: `${label}[${index}].files`,
+		value: item.files
+	});
+	const biomeRules = normalizeRulesOffInput({
+		label: `${label}[${index}].biome`,
+		value: item.biome
+	});
+	const eslintRules = normalizeRulesOffInput({
+		label: `${label}[${index}].eslint`,
+		value: item.eslint
+	});
+	const oxlintRules = normalizeRulesOffInput({
+		label: `${label}[${index}].oxlint`,
+		value: item.oxlint
+	});
+	if (!(biomeRules || eslintRules || oxlintRules)) throw new Error(`${label}[${index}] must define at least one action: biome, eslint, or oxlint`);
+	return {
+		biomeRules,
+		eslintRules,
+		files,
+		oxlintRules
+	};
+};
+const normalizeSharedOverrides = ({ label, value }) => {
+	const out = [];
+	if (value === void 0) return out;
+	const obj = assertObject({
+		label,
+		value
+	});
+	const entries = [];
+	for (const [pattern, rawOverride] of Object.entries(obj)) {
+		const override = assertObject({
+			label: `${label}.${pattern}`,
+			value: rawOverride
+		});
+		for (const key of Object.keys(override)) if (!SHARED_OVERRIDE_KEYS.includes(key)) throw new Error(`${label}.${pattern}.${key} is not supported. Use biome, eslint, or oxlint.`);
+		entries.push({
+			...override,
+			files: [pattern]
+		});
+	}
+	for (const [i, item] of entries.entries()) out.push(normalizeSharedOverrideItem({
+		index: i,
+		item,
+		label
+	}));
+	return out;
+};
+const collectSharedRuleOverrides = ({ ruleKey, sharedOverrides }) => {
+	const out = [];
+	for (const override of sharedOverrides) {
+		const rules = override[ruleKey];
+		if (rules) out.push({
+			files: override.files,
+			rules
+		});
+	}
+	return out;
+};
+const parseLinterOffOverrides = ({ assertKnownRules, fileKey, label, requireOff = false, value }) => {
+	const out = [];
+	for (const [i, override] of normalizeObjectListInput({
+		label,
+		value
+	}).entries()) {
+		const itemLabel = requireOff ? `${label}[${i}]` : label;
+		if (requireOff && override[fileKey] === void 0) throw new Error(`${label}[${i}].${fileKey} is required`);
+		if (requireOff && override.off === void 0) throw new Error(`${label}[${i}].off is required`);
+		const normalizedOverrideRules = normalizeRulesOffInput({
+			label: `${itemLabel}.off`,
+			value: override.off
+		});
+		if (normalizedOverrideRules) {
+			assertKnownRules?.(normalizedOverrideRules);
+			out.push({
+				files: normalizePathListInput({
+					label: `${itemLabel}.${fileKey}`,
+					value: override[fileKey]
+				}),
+				rules: normalizedOverrideRules
+			});
+		}
+	}
+	return out;
+};
+const parseTopLevelSyncScalars = ({ options }) => {
+	if (options.compact !== void 0 && typeof options.compact !== "boolean") throw new Error("compact must be a boolean");
+	const tailwind = normalizeTailwindOption({
+		label: "tailwind",
+		value: options.tailwind
+	});
+	assertOptionalString({
+		label: "tsconfigRootDir",
+		value: options.tsconfigRootDir
+	});
+	return {
+		sharedOverrides: options.overrides === void 0 ? [] : normalizeSharedOverrides({
+			label: "overrides",
+			value: options.overrides
+		}),
+		tailwind,
+		topLevelIgnores: options.ignores === void 0 ? [] : normalizePathListInput({
+			label: "ignores",
+			value: options.ignores
+		}),
+		tsconfigRootDir: options.tsconfigRootDir
+	};
+};
+const parseLinterSyncCommon = ({ linter, value }) => {
+	const parsed = {};
+	if (value.ignores !== void 0) parsed.ignores = normalizePathListInput({
+		label: `${linter}.ignores`,
+		value: value.ignores
+	});
+	const normalizedOffRules = normalizeRulesOffInput({
+		label: `${linter}.off`,
+		value: value.off
+	});
+	if (normalizedOffRules) parsed.off = Object.keys(normalizedOffRules);
+	return parsed;
+};
+const validateBiomeSyncConfig = ({ biome }) => {
+	const biomeValue = assertObject({
+		label: "biome config",
+		value: biome
+	});
+	const parsedCommon = parseLinterSyncCommon({
+		linter: "biome",
+		value: biomeValue
+	});
+	const parsedOverrides = parseLinterOffOverrides({
+		fileKey: "includes",
+		label: "biome.overrides",
+		requireOff: true,
+		value: biomeValue.overrides
+	}).map((override) => ({
+		includes: override.files,
+		off: Object.keys(override.rules)
+	}));
+	const parsed = { ...parsedCommon };
+	if (parsedOverrides.length > 0) parsed.overrides = parsedOverrides;
+	return parsed;
+};
+const parseEslintAppendEntry = ({ index, item }) => {
+	const { $lintmax: marker } = item;
+	if (marker === ESLINT_IMPORT_SENTINEL) {
+		const allowedKeys = new Set([
+			"$lintmax",
+			"files",
+			"from",
+			"ignores",
+			"name"
+		]);
+		for (const key of Object.keys(item)) if (!allowedKeys.has(key)) throw new Error(`eslint.append[${index}].${key} is not supported for eslint-import entries. Use from, name, files, ignores.`);
+		assertOptionalString({
+			label: `eslint.append[${index}].from`,
+			value: item.from
+		});
+		const { from } = item;
+		if (typeof from !== "string" || from.trim().length === 0) throw new Error(`eslint.append[${index}].from must be a non-empty string`);
+		assertOptionalString({
+			label: `eslint.append[${index}].name`,
+			value: item.name
+		});
+		return {
+			files: item.files === void 0 ? void 0 : normalizePathListInput({
+				label: `eslint.append[${index}].files`,
+				value: item.files
+			}),
+			from,
+			ignores: item.ignores === void 0 ? void 0 : normalizePathListInput({
+				label: `eslint.append[${index}].ignores`,
+				value: item.ignores
+			}),
+			name: typeof item.name === "string" && item.name.trim().length > 0 ? item.name : "default"
+		};
+	}
+	if ("$lintmax" in item) throw new Error(`eslint.append[${index}].$lintmax has unsupported value. Use eslintImport(...) or remove the $lintmax key.`);
+	assertJsonSerializable({
+		label: `eslint.append[${index}]`,
+		value: item
+	});
+	return { config: item };
+};
+const validateEslintSyncConfig = ({ eslint }) => {
+	const eslintValue = assertObject({
+		label: "eslint config",
+		value: eslint
+	});
+	const parsed = { ...parseLinterSyncCommon({
+		linter: "eslint",
+		value: eslintValue
+	}) };
+	if (eslintValue.tailwind !== void 0) throw new Error("eslint.tailwind is not supported in sync config. Use top-level tailwind.");
+	if (eslintValue.tsconfigRootDir !== void 0) throw new Error("eslint.tsconfigRootDir is not supported in sync config. Use top-level tsconfigRootDir.");
+	if (eslintValue.append !== void 0) parsed.append = normalizeObjectListInput({
+		label: "eslint.append",
+		value: eslintValue.append
+	}).map((item, i) => parseEslintAppendEntry({
+		index: i,
+		item
+	}));
+	return parsed;
+};
+const validateOxlintSyncConfig = ({ oxlint }) => {
+	const oxlintValue = assertObject({
+		label: "oxlint config",
+		value: oxlint
+	});
+	const parsedCommon = parseLinterSyncCommon({
+		linter: "oxlint",
+		value: oxlintValue
+	});
+	const parsedOverrides = parseLinterOffOverrides({
+		fileKey: "files",
+		label: "oxlint.overrides",
+		requireOff: true,
+		value: oxlintValue.overrides
+	}).map((override) => ({
+		files: override.files,
+		off: Object.keys(override.rules)
+	}));
+	const parsed = { ...parsedCommon };
+	if (parsedOverrides.length > 0) parsed.overrides = parsedOverrides;
+	return parsed;
+};
+const validateSyncOptions = ({ options }) => {
+	if (!options) return {
+		sharedOverrides: [],
+		topLevelIgnores: []
+	};
+	const parsed = { ...parseTopLevelSyncScalars({ options }) };
+	if (options.biome) parsed.biome = validateBiomeSyncConfig({ biome: options.biome });
+	if (options.eslint) parsed.eslint = validateEslintSyncConfig({ eslint: options.eslint });
+	if (options.oxlint) parsed.oxlint = validateOxlintSyncConfig({ oxlint: options.oxlint });
+	return parsed;
+};
+const mergeUniquePatterns = ({ into, patterns }) => {
+	if (!patterns) return;
+	for (const raw of patterns) {
+		const pattern = normalizeIgnorePattern({ pattern: raw });
+		if (pattern.length > 0 && !into.includes(pattern)) into.push(pattern);
+	}
+};
+const mergeIgnorePatternGroups = ({ groups }) => {
+	const merged = [];
+	for (const group of groups) mergeUniquePatterns({
+		into: merged,
+		patterns: group
+	});
+	return merged;
+};
+const buildUserIgnorePatterns = ({ topLevelIgnores }) => mergeIgnorePatternGroups({ groups: [topLevelIgnores] });
+const buildLinterOptionsWithSharedOverrides = ({ createEmpty, ruleKey, sharedOverrides, source, mapSharedOverride }) => {
+	if (!(source || sharedOverrides.length > 0)) return source;
+	const next = source ? { ...source } : createEmpty();
+	next.off = source?.off;
+	const sharedRuleOverrides = collectSharedRuleOverrides({
+		ruleKey,
+		sharedOverrides
+	}).map(mapSharedOverride);
+	const localOverrides = source?.overrides ?? [];
+	const mergedOverrides = [...sharedRuleOverrides, ...localOverrides];
+	if (mergedOverrides.length > 0) next.overrides = mergedOverrides;
+	return next;
+};
+const buildBiomeOptions = ({ biomeSource, sharedOverrides }) => buildLinterOptionsWithSharedOverrides({
+	createEmpty: () => ({}),
+	mapSharedOverride: (override) => ({
+		includes: override.files,
+		off: Object.keys(override.rules)
+	}),
+	ruleKey: "biomeRules",
+	sharedOverrides,
+	source: biomeSource
+});
+const buildOxlintOptions = ({ oxlintSource, sharedOverrides }) => buildLinterOptionsWithSharedOverrides({
+	createEmpty: () => ({}),
+	mapSharedOverride: (override) => ({
+		files: override.files,
+		off: Object.keys(override.rules)
+	}),
+	ruleKey: "oxlintRules",
+	sharedOverrides,
+	source: oxlintSource
+});
+const buildEslintIgnorePatterns = ({ eslintSource, userIgnorePatterns }) => mergeIgnorePatternGroups({ groups: [userIgnorePatterns, eslintSource?.ignores === void 0 ? void 0 : normalizePathListInput({
+	label: "eslint.ignores",
+	value: eslintSource.ignores
+})] });
+const buildEslintOptions = ({ eslintSource, sharedOverrides, tailwind, tsconfigRootDir, userIgnorePatterns }) => {
+	const eslintIgnores = buildEslintIgnorePatterns({
+		eslintSource,
+		userIgnorePatterns
+	});
+	const sharedRuleOverrides = collectSharedRuleOverrides({
+		ruleKey: "eslintRules",
+		sharedOverrides
+	}).map((override) => ({
+		files: override.files,
+		rules: override.rules
+	}));
+	const sharedOverrideAppendIndexes = sharedRuleOverrides.map((_, index) => index);
+	const eslintImportRefs = [];
+	if (eslintSource || sharedOverrides.length > 0 || tailwind !== void 0 || tsconfigRootDir !== void 0) {
+		const eslintOptions = { off: eslintSource?.off };
+		if (eslintIgnores.length > 0) eslintOptions.ignores = eslintIgnores;
+		const appendEntries = [];
+		for (const entry of eslintSource?.append ?? []) if ("config" in entry) appendEntries.push(entry.config);
+		else {
+			const importRefIndex = eslintImportRefs.push({
+				exportName: entry.name,
+				files: entry.files,
+				ignores: entry.ignores,
+				source: entry.from
+			});
+			appendEntries.push({ [ESLINT_IMPORT_MARKER_KEY]: importRefIndex - 1 });
+		}
+		const mergedAppend = [...sharedRuleOverrides, ...appendEntries];
+		if (mergedAppend.length > 0) eslintOptions.append = mergedAppend;
+		eslintOptions.tailwind = normalizeTailwindOption({
+			label: "tailwind",
+			value: tailwind
+		}) ?? true;
+		eslintOptions.tsconfigRootDir = tsconfigRootDir;
+		return {
+			eslintImportRefs,
+			eslintOptions,
+			sharedOverrideAppendIndexes
+		};
+	}
+	if (eslintIgnores.length === 0) return {
+		eslintImportRefs,
+		eslintOptions: void 0,
+		sharedOverrideAppendIndexes
+	};
+	return {
+		eslintImportRefs,
+		eslintOptions: {
+			ignores: eslintIgnores,
+			tailwind: true
+		},
+		sharedOverrideAppendIndexes
+	};
+};
+const normalizeLinterOffOverrides = ({ assertKnownRules, fileKey, label, value }) => parseLinterOffOverrides({
+	assertKnownRules,
+	fileKey,
+	label,
+	value
+});
+const normalizeKnownOffRules = ({ assertKnownRules, label, value }) => {
+	const normalizedRules = normalizeRulesOffInput({
+		label,
+		value
+	});
+	if (!normalizedRules) return;
+	assertKnownRules?.(normalizedRules);
+	return normalizedRules;
+};
+const createBiomeConfig = async ({ cwd, options, sharedIgnorePatterns }) => {
+	const { categories, ruleMap } = await resolveBiomeSchema({ cwd });
+	const allRulesOff = [...BIOME_RULES_OFF];
+	const normalizedRules = normalizeKnownOffRules({
+		assertKnownRules: (rules) => assertKnownBiomeRuleNames({
+			categoryMap: ruleMap,
+			label: "biome.off",
+			rules
+		}),
+		label: "biome.off",
+		value: options?.off
+	});
+	if (normalizedRules) for (const key of Object.keys(normalizedRules)) {
+		const ruleName = stripPluginNamespace({ rule: key });
+		if (!allRulesOff.includes(ruleName)) allRulesOff.push(ruleName);
+	}
+	const ignorePatterns = [...BIOME_IGNORE_PATTERNS];
+	const mergedIgnorePatterns = mergeIgnorePatternGroups({ groups: [sharedIgnorePatterns, options?.ignores === void 0 ? void 0 : normalizePathListInput({
+		label: "biome.ignores",
+		value: options.ignores
+	})] });
+	for (const pattern of mergedIgnorePatterns) {
+		const negated = normalizeBiomeIgnorePattern({ pattern });
+		if (!ignorePatterns.includes(negated)) ignorePatterns.push(negated);
+	}
+	const overrides = [{
+		css: { parser: { tailwindDirectives: true } },
+		includes: ["**"],
+		linter: { rules: groupByCategory({
+			categoryMap: ruleMap,
+			ruleNames: allRulesOff
+		}) }
+	}];
+	for (const override of BIOME_PATTERN_RULE_OVERRIDES) overrides.push({
+		includes: [...override.includes],
+		linter: { rules: groupByCategory({
+			categoryMap: ruleMap,
+			ruleNames: override.rules
+		}) }
+	});
+	for (const override of normalizeLinterOffOverrides({
+		assertKnownRules: (rules) => assertKnownBiomeRuleNames({
+			categoryMap: ruleMap,
+			label: "biome.overrides.off",
+			rules
+		}),
+		fileKey: "includes",
+		label: "biome.overrides",
+		value: options?.overrides
+	})) overrides.push({
+		includes: override.files,
+		linter: { rules: groupByCategory({
+			categoryMap: ruleMap,
+			ruleNames: extractRuleNames(override.rules)
+		}) }
+	});
+	return {
+		$schema: "https://biomejs.dev/schemas/latest/schema.json",
+		assist: { actions: { source: { organizeImports: "off" } } },
+		css: {
+			formatter: {
+				enabled: true,
+				quoteStyle: "single"
+			},
+			parser: { tailwindDirectives: true }
+		},
+		files: {
+			experimentalScannerIgnores: ignorePatterns.map((p) => p.startsWith("!!") ? p.slice(2) : p),
+			includes: ["**", ...ignorePatterns]
+		},
+		formatter: {
+			indentStyle: "space",
+			lineWidth: 123
+		},
+		javascript: { formatter: {
+			arrowParentheses: "asNeeded",
+			bracketSameLine: true,
+			jsxQuoteStyle: "single",
+			quoteStyle: "single",
+			semicolons: "asNeeded",
+			trailingCommas: "none"
+		} },
+		json: { formatter: { trailingCommas: "none" } },
+		linter: {
+			domains: {
+				next: "all",
+				project: "all",
+				qwik: "all",
+				react: "all",
+				solid: "all",
+				tailwind: "all",
+				test: "all",
+				vue: "all"
+			},
+			rules: Object.fromEntries(categories.map((c) => [c, "error"]))
+		},
+		overrides
+	};
+};
+const createOxlintConfig = async ({ options, sharedIgnorePatterns }) => {
+	const base = await readRequiredJson({ path: joinPath(pkgRoot, "oxlintrc.json") });
+	const knownRules = new Set([
+		...Object.keys(base.rules),
+		...(base.overrides ?? []).flatMap((override) => Object.keys(override.rules)),
+		...OXLINT_PATTERN_RULE_OVERRIDES.flatMap((override) => Object.keys(override.rules))
+	]);
+	const mergedIgnorePatterns = mergeIgnorePatternGroups({ groups: [sharedIgnorePatterns, options?.ignores === void 0 ? void 0 : normalizePathListInput({
+		label: "oxlint.ignores",
+		value: options.ignores
+	})] });
+	base.overrides ??= [];
+	for (const override of OXLINT_PATTERN_RULE_OVERRIDES) base.overrides.push({
+		files: [...override.files],
+		rules: { ...override.rules }
+	});
+	if (mergedIgnorePatterns.length > 0) {
+		base.ignorePatterns ??= [];
+		for (const pattern of mergedIgnorePatterns) if (!base.ignorePatterns.includes(pattern)) base.ignorePatterns.push(pattern);
+	}
+	if (!options) return base;
+	const normalizedRules = normalizeKnownOffRules({
+		assertKnownRules: (rules) => assertKnownOxlintRuleNames({
+			knownRules,
+			label: "oxlint.off",
+			rules
+		}),
+		label: "oxlint.off",
+		value: options.off
+	});
+	if (normalizedRules) for (const [key, value] of Object.entries(normalizedRules)) base.rules[key] = value;
+	for (const override of normalizeLinterOffOverrides({
+		assertKnownRules: (rules) => assertKnownOxlintRuleNames({
+			knownRules,
+			label: "oxlint.overrides.off",
+			rules
+		}),
+		fileKey: "files",
+		label: "oxlint.overrides",
+		value: options.overrides
+	})) base.overrides.push({
+		files: override.files,
+		rules: override.rules
+	});
+	return base;
+};
+const resolveSyncImportSource = ({ cwd, dir, source }) => {
+	if (!(source.startsWith(".") || source.startsWith(".."))) return source;
+	const relativeSource = relative(dir, joinPath(cwd, source)).replaceAll("\\", "/");
+	return relativeSource.startsWith(".") ? relativeSource : `./${relativeSource}`;
+};
+const discoverSymlinkPatterns = ({ root }) => {
+	const result = spawnSync({
+		cmd: [
+			"git",
+			"-C",
+			root,
+			"ls-files",
+			"-z",
+			"--cached",
+			"--others",
+			"--exclude-standard"
+		],
+		stderr: "pipe",
+		stdout: "pipe"
+	});
+	if (result.exitCode !== 0) return [];
+	const entries = new TextDecoder().decode(result.stdout).split("\0").filter((e) => e.length > 0);
+	const out = [];
+	for (const entry of entries) {
+		let isSymlink;
+		try {
+			isSymlink = lstatSync(join(root, entry)).isSymbolicLink();
+		} catch {
+			isSymlink = false;
+		}
+		if (isSymlink) out.push(entry);
+	}
+	return out;
+};
+const sync = async (options) => {
+	const { biome, eslint, oxlint, sharedOverrides, tailwind, topLevelIgnores, tsconfigRootDir } = validateSyncOptions({ options });
+	const cwd = process.cwd();
+	const dir = joinPath(cwd, cacheDir);
+	const userIgnorePatterns = buildUserIgnorePatterns({ topLevelIgnores });
+	const sharedIgnorePatterns = mergeIgnorePatternGroups({ groups: [
+		DEFAULT_SHARED_IGNORE_PATTERNS,
+		discoverSymlinkPatterns({ root: cwd }),
+		userIgnorePatterns
+	] });
+	const biomeOptions = buildBiomeOptions({
+		biomeSource: biome,
+		sharedOverrides
+	});
+	const oxlintOptions = buildOxlintOptions({
+		oxlintSource: oxlint,
+		sharedOverrides
+	});
+	const { eslintImportRefs, eslintOptions, sharedOverrideAppendIndexes } = buildEslintOptions({
+		eslintSource: eslint,
+		sharedOverrides,
+		tailwind,
+		tsconfigRootDir,
+		userIgnorePatterns
+	});
+	ensureDirectory({ directory: dir });
+	const biomeConfig = await createBiomeConfig({
+		cwd,
+		options: biomeOptions,
+		sharedIgnorePatterns
+	});
+	const oxlintConfig = await createOxlintConfig({
+		options: oxlintOptions,
+		sharedIgnorePatterns
+	});
+	const normalizedImportRefs = eslintImportRefs.map((importRef) => ({
+		exportName: importRef.exportName,
+		files: importRef.files,
+		ignores: importRef.ignores,
+		source: resolveSyncImportSource({
+			cwd,
+			dir,
+			source: importRef.source
+		})
+	}));
+	const importStatements = normalizedImportRefs.map((importRef, index) => `import * as __lintmaxAppendImport${index} from ${JSON.stringify(importRef.source)}`).join("\n");
+	const importEntries = normalizedImportRefs.map((importRef, index) => `  { exportName: ${JSON.stringify(importRef.exportName)}, files: ${JSON.stringify(importRef.files ?? null)}, ignores: ${JSON.stringify(importRef.ignores ?? null)}, module: __lintmaxAppendImport${index} }`).join(",\n");
+	const importExpansion = normalizedImportRefs.length === 0 ? "" : `\nconst appendImports = [\n${importEntries}\n]\nconst normalizedAppend = []\nfor (const entry of options.append ?? []) {\n  if (entry && typeof entry === 'object' && !Array.isArray(entry) && ${JSON.stringify(ESLINT_IMPORT_MARKER_KEY)} in entry) {\n    const importIndex = entry[${JSON.stringify(ESLINT_IMPORT_MARKER_KEY)}]\n    if (typeof importIndex !== 'number' || !Number.isInteger(importIndex))\n      throw new Error('Invalid eslint import marker index in generated config')\n    const importRef = appendImports[importIndex]\n    if (!importRef) throw new Error(\`Missing eslint import ref for index \${importIndex}\`)\n    const imported = importRef.module[importRef.exportName]\n    const importedEntries = Array.isArray(imported) ? imported : [imported]\n    for (const importedEntry of importedEntries) {\n      if (!importedEntry || typeof importedEntry !== 'object' || Array.isArray(importedEntry))\n        throw new Error(\`Imported eslint append from \${importRef.exportName} must resolve to config object(s)\`)\n      normalizedAppend.push({\n        ...importedEntry,\n        ...(Array.isArray(importRef.files) ? { files: [...importRef.files] } : {}),\n        ...(Array.isArray(importRef.ignores) ? { ignores: [...importRef.ignores] } : {})\n      })\n    }\n    continue\n  }\n  normalizedAppend.push(entry)\n}\noptions.append = normalizedAppend\n`;
+	const eslintConfig = eslintOptions ? `${importStatements.length > 0 ? `${importStatements}\n` : ""}import { eslint } from 'lintmax/eslint'\nconst options = ${JSON.stringify(eslintOptions)}\nfor (const index of ${JSON.stringify(sharedOverrideAppendIndexes)}) {\n  const entry = options.append?.[index]\n  if (entry && typeof entry === 'object') entry[Symbol.for(${JSON.stringify(SHARED_OVERRIDE_SYMBOL_KEY)})] = true\n}${importExpansion}export default eslint(options)\n` : "export { default } from 'lintmax/eslint'\n";
+	const runtimeConfig = {
+		comments: options?.comments !== false,
+		compact: options?.compact !== false
+	};
+	await write(joinPath(dir, "biome.json"), `${JSON.stringify(biomeConfig, null, 2)}\n`);
+	await write(joinPath(dir, ".oxlintrc.json"), `${JSON.stringify(oxlintConfig, null, 2)}\n`);
+	await write(joinPath(dir, "eslint.generated.mjs"), eslintConfig);
+	await write(joinPath(dir, "lintmax.json"), `${JSON.stringify(runtimeConfig, null, 2)}\n`);
+};
+const eslintImport = ({ files, from, ignores, name }) => {
+	const entry = {
+		$lintmax: ESLINT_IMPORT_SENTINEL,
+		from
+	};
+	if (files !== void 0) entry.files = files;
+	if (ignores !== void 0) entry.ignores = ignores;
+	if (name !== void 0) entry.name = name;
+	return entry;
+};
+const defineConfig = (options) => {
+	validateSyncOptions({ options });
+	return options;
+};
+//#endregion
+export { run as _, PRETTIER_MD_ARGS as a, writeJson as b, decodeText as c, lintmaxRoot as d, pathExists as f, resolveBin as g, readVersion as h, CliExitError as i, ensureDirectory as l, readRequiredJson as m, eslintImport as n, cacheDir as o, readJson as p, sync as r, cwd as s, defineConfig as t, ignoreEntries as u, runCapture as v, usage as y };