lintmax 0.1.15

package/dist/constants-Cjkf4mJh.mjs

@@ -0,0 +1,105 @@
+//#region src/constants.ts
+const BIOME_RULES_OFF = [
+	"noBarrelFile",
+	"noConditionalExpect",
+	"noConsole",
+	"noDefaultExport",
+	"noExcessiveCognitiveComplexity",
+	"noExcessiveLinesPerFile",
+	"noExcessiveLinesPerFunction",
+	"noExportedImports",
+	"noImplicitBoolean",
+	"noImportantStyles",
+	"noInlineStyles",
+	"noLeakedRender",
+	"useConsistentCurlyBraces",
+	"noJsxLiterals",
+	"noJsxPropsBind",
+	"noMagicNumbers",
+	"noNestedTernary",
+	"noNodejsModules",
+	"noProcessGlobal",
+	"noReactSpecificProps",
+	"noSecrets",
+	"noSolidDestructuredProps",
+	"noTernary",
+	"noUndeclaredDependencies",
+	"noUnresolvedImports",
+	"useBaseline",
+	"useBlockStatements",
+	"useComponentExportOnlyModules",
+	"useDestructuring",
+	"useConsistentTestIt",
+	"useExplicitReturnType",
+	"useExplicitType",
+	"useImportExtensions",
+	"useNamingConvention",
+	"useQwikValidLexicalScope",
+	"useSingleVarDeclarator",
+	"useSolidForComponent",
+	"useSortedClasses"
+];
+const BIOME_IGNORE_PATTERNS = [
+	"!!**/.build",
+	"!!**/.cache",
+	"!!**/.source",
+	"!!**/.next",
+	"!!**/.output",
+	"!!**/.turbo",
+	"!!**/.venv",
+	"!!**/.wxt",
+	"!!**/_generated",
+	"!!**/Android",
+	"!!**/Darwin",
+	"!!**/dist",
+	"!!**/maestro",
+	"!!**/module_bindings",
+	"!!**/playwright-report",
+	"!!**/test-results",
+	"!!**/*.xcassets"
+];
+const DEFAULT_SHARED_IGNORE_PATTERNS = [
+	"_generated/**",
+	".next/**",
+	".source/**",
+	"dist/**",
+	"generated/**",
+	"module_bindings/**",
+	"next-env.d.ts",
+	"readonly/**",
+	"expo/**/babel.config.js",
+	"expo/**/global.css",
+	"expo/**/metro.config.js",
+	"expo/**/uniwind-env.d.ts",
+	"expo/**/uniwind-types.d.ts"
+].map((p) => p.startsWith("**/") ? p : `**/${p}`);
+const BIOME_PATTERN_RULE_OVERRIDES = [{
+	includes: ["**/expo/**"],
+	rules: ["style/noProcessEnv"]
+}, {
+	includes: ["**/maestro/**"],
+	rules: ["performance/noAwaitInLoops"]
+}];
+const OXLINT_PATTERN_RULE_OVERRIDES = [{
+	files: ["**/expo/**/*.tsx", "**/expo/**/*.ts"],
+	rules: { "react-perf/jsx-no-new-object-as-prop": "off" }
+}];
+const TAILWIND_ENTRY_CANDIDATES = [
+	"ui/src/styles/globals.css",
+	"src/styles/globals.css",
+	"app/globals.css",
+	"web/global.css",
+	"styles/globals.css",
+	"global.css"
+];
+const ESLINT_TEST_FILE_PATTERNS = [
+	"**/*.test.ts",
+	"**/*.test.tsx",
+	"**/*.spec.ts",
+	"**/*.spec.tsx",
+	"**/__tests__/**/*.ts",
+	"**/__tests__/**/*.tsx"
+];
+const SHARED_OVERRIDE_SYMBOL_KEY = "lintmax.sharedOverride";
+//#endregion
+export { ESLINT_TEST_FILE_PATTERNS as a, TAILWIND_ENTRY_CANDIDATES as c, DEFAULT_SHARED_IGNORE_PATTERNS as i, BIOME_PATTERN_RULE_OVERRIDES as n, OXLINT_PATTERN_RULE_OVERRIDES as o, BIOME_RULES_OFF as r, SHARED_OVERRIDE_SYMBOL_KEY as s, BIOME_IGNORE_PATTERNS as t };

package/dist/eslint.d.mts

@@ -0,0 +1,9 @@
+import { n as EslintOptions } from "./lintmax-types-CJ7VY33l.mjs";
+import * as _$eslint_config0 from "eslint/config";
+import { defineConfig } from "eslint/config";
+
+//#region src/eslint.d.ts
+declare const eslintFactory: (options?: EslintOptions) => ReturnType<typeof defineConfig>;
+declare const defaultConfig: _$eslint_config0.Config[];
+//#endregion
+export { type EslintOptions, defaultConfig as default, eslintFactory as eslint };

package/dist/eslint.mjs

@@ -0,0 +1,344 @@
+import { a as ESLINT_TEST_FILE_PATTERNS, c as TAILWIND_ENTRY_CANDIDATES, i as DEFAULT_SHARED_IGNORE_PATTERNS, s as SHARED_OVERRIDE_SYMBOL_KEY } from "./constants-Cjkf4mJh.mjs";
+import { c as findUnknownRules, d as normalizeObjectListInput, f as normalizePathListInput, g as warnToError, i as joinPath, l as isRecord, m as normalizeTailwindOption, p as normalizeRulesOffInput, r as isAbsolutePath } from "./path-Cu_Nf2ct.mjs";
+import eslintReact from "@eslint-react/eslint-plugin";
+import { includeIgnoreFile } from "@eslint/compat";
+import eslint from "@eslint/js";
+import nextPlugin from "@next/eslint-plugin-next";
+import eslintPluginBetterTailwindcss from "eslint-plugin-better-tailwindcss";
+import { configs } from "eslint-plugin-perfectionist";
+import preferArrow from "eslint-plugin-prefer-arrow-functions";
+import reactPlugin from "eslint-plugin-react";
+import reactHooks from "eslint-plugin-react-hooks";
+import turbo from "eslint-plugin-turbo";
+import { defineConfig, globalIgnores } from "eslint/config";
+import { existsSync } from "node:fs";
+import tseslint from "typescript-eslint";
+//#region src/eslint.ts
+const sharedOverrideMarker = Symbol.for(SHARED_OVERRIDE_SYMBOL_KEY);
+const normalizeAppendInput = ({ append }) => {
+	const out = [];
+	for (const value of normalizeObjectListInput({
+		allowNonPlain: true,
+		label: "eslint.append",
+		value: append
+	})) out.push(value);
+	return out;
+};
+const validateEslintOptions = ({ options }) => {
+	if (!options) return;
+	if (options.ignores !== void 0) normalizePathListInput({
+		allowUndefined: true,
+		label: "eslint.ignores",
+		value: options.ignores
+	});
+	if (options.off !== void 0) normalizeRulesOffInput({
+		label: "eslint.off",
+		value: options.off
+	});
+	if (options.append !== void 0) normalizeAppendInput({ append: options.append });
+	const tailwindEntrySetting = normalizeTailwindOption({
+		label: "eslint.tailwind",
+		value: options.tailwind
+	});
+	if (typeof tailwindEntrySetting === "string") {
+		const root = options.tsconfigRootDir ?? process.cwd();
+		const resolved = isAbsolutePath(tailwindEntrySetting) ? tailwindEntrySetting : joinPath(root, tailwindEntrySetting);
+		if (!existsSync(resolved)) throw new Error(`eslint.tailwind file not found: ${resolved}. Use an existing path, set eslint.tailwind to false, or remove eslint.tailwind to use auto-detection.`);
+	}
+	if (options.tsconfigRootDir !== void 0 && typeof options.tsconfigRootDir !== "string") throw new Error("eslint.tsconfigRootDir must be a string");
+};
+const collectKnownEslintRuleNames = ({ appendConfigs, baseConfigs }) => {
+	const knownRuleNames = /* @__PURE__ */ new Set();
+	const seenConfigs = /* @__PURE__ */ new WeakSet();
+	const collectPluginRuleNames = ({ plugins }) => {
+		if (!isRecord(plugins)) return;
+		for (const [pluginName, plugin] of Object.entries(plugins)) if (isRecord(plugin) && isRecord(plugin.rules)) for (const ruleName of Object.keys(plugin.rules)) knownRuleNames.add(`${pluginName}/${ruleName}`);
+	};
+	const collectFromConfig = ({ config, includeRules }) => {
+		if (typeof config !== "object" || config === null) return;
+		if (seenConfigs.has(config)) return;
+		seenConfigs.add(config);
+		if (Array.isArray(config)) {
+			for (const entry of config) collectFromConfig({
+				config: entry,
+				includeRules
+			});
+			return;
+		}
+		if (!isRecord(config)) return;
+		if (includeRules && isRecord(config.rules)) for (const ruleName of Object.keys(config.rules)) knownRuleNames.add(ruleName);
+		if ("plugins" in config) collectPluginRuleNames({ plugins: config.plugins });
+		if ("extends" in config) collectFromConfig({
+			config: config.extends,
+			includeRules: true
+		});
+	};
+	for (const config of baseConfigs) collectFromConfig({
+		config,
+		includeRules: true
+	});
+	for (const config of appendConfigs) collectFromConfig({
+		config,
+		includeRules: false
+	});
+	return knownRuleNames;
+};
+const getSharedAppendConfig = ({ config }) => {
+	return config[sharedOverrideMarker] === true ? config : null;
+};
+const resolveTailwindEntry = ({ root, tailwind }) => {
+	const tailwindSetting = tailwind ?? true;
+	if (tailwindSetting === false) return;
+	if (typeof tailwindSetting === "string") return isAbsolutePath(tailwindSetting) ? tailwindSetting : joinPath(root, tailwindSetting);
+	const matches = [];
+	for (const candidate of TAILWIND_ENTRY_CANDIDATES) {
+		const resolved = joinPath(root, candidate);
+		if (existsSync(resolved)) matches.push(resolved);
+	}
+	if (matches.length <= 1) return matches[0];
+	const preferredOnAmbiguous = [joinPath(root, "ui/src/styles/globals.css")];
+	for (const preferred of preferredOnAmbiguous) if (matches.includes(preferred)) return preferred;
+	const relMatches = matches.map((path) => path.slice(root.length + 1));
+	throw new Error(`Multiple Tailwind entry files found: ${relMatches.join(", ")}. Set eslint.tailwind to an explicit path.`);
+};
+const tailwindRules = (entryPoint) => entryPoint ? eslintPluginBetterTailwindcss.configs["recommended-error"].rules : {};
+const eslintFactory = (options) => {
+	validateEslintOptions({ options });
+	const opts = options ?? {};
+	const root = opts.tsconfigRootDir ?? process.cwd();
+	const configs$1 = [];
+	const gitignorePath = joinPath(root, ".gitignore");
+	const normalizedIgnores = normalizePathListInput({
+		allowUndefined: true,
+		label: "eslint.ignores",
+		value: opts.ignores
+	});
+	const tailwindEntry = resolveTailwindEntry({
+		root,
+		tailwind: opts.tailwind
+	});
+	const tailwindSettings = {};
+	if (tailwindEntry) tailwindSettings["better-tailwindcss"] = { entryPoint: tailwindEntry };
+	configs$1.push(globalIgnores([...DEFAULT_SHARED_IGNORE_PATTERNS, ...normalizedIgnores]));
+	try {
+		configs$1.push(includeIgnoreFile(gitignorePath));
+	} catch (error) {
+		if (error instanceof Error) {
+			const message = error.message.toLowerCase();
+			if (!(message.includes("enoent") || message.includes("no such file"))) throw error;
+		} else throw error;
+	}
+	configs$1.push(...defineConfig(configs["recommended-natural"], { ignores: ["**/postcss.config.mjs"] }, {
+		extends: [
+			eslint.configs.recommended,
+			eslint.configs.all,
+			...tseslint.configs.all,
+			...tseslint.configs.recommended,
+			...tseslint.configs.recommendedTypeChecked,
+			...tseslint.configs.stylisticTypeChecked,
+			eslintReact.configs["strict-type-checked"],
+			eslintReact.configs.recommended
+		],
+		files: [
+			"**/*.js",
+			"**/*.ts",
+			"**/*.tsx"
+		],
+		plugins: {
+			preferArrow,
+			turbo
+		},
+		rules: {
+			"@eslint-react/avoid-shorthand-boolean": "off",
+			"@eslint-react/avoid-shorthand-fragment": "off",
+			"@eslint-react/jsx-dollar": "error",
+			"@eslint-react/jsx-shorthand-boolean": "error",
+			"@eslint-react/jsx-shorthand-fragment": "error",
+			"@eslint-react/naming-convention/component-name": "error",
+			"@eslint-react/naming-convention/ref-name": "error",
+			"@eslint-react/no-duplicate-key": "error",
+			"@eslint-react/no-missing-component-display-name": "error",
+			"@eslint-react/no-missing-context-display-name": "off",
+			"@eslint-react/no-unnecessary-key": "error",
+			"@typescript-eslint/consistent-return": "off",
+			"@typescript-eslint/consistent-type-imports": ["error", {
+				fixStyle: "separate-type-imports",
+				prefer: "type-imports"
+			}],
+			"@typescript-eslint/explicit-function-return-type": "off",
+			"@typescript-eslint/explicit-member-accessibility": "off",
+			"@typescript-eslint/explicit-module-boundary-types": "off",
+			"@typescript-eslint/init-declarations": "off",
+			"@typescript-eslint/naming-convention": ["error", {
+				format: [
+					"camelCase",
+					"UPPER_CASE",
+					"PascalCase"
+				],
+				selector: "variable"
+			}],
+			"@typescript-eslint/no-confusing-void-expression": "off",
+			"@typescript-eslint/no-floating-promises": "off",
+			"@typescript-eslint/no-magic-numbers": "off",
+			"@typescript-eslint/no-misused-promises": [2, { checksVoidReturn: { attributes: false } }],
+			"@typescript-eslint/no-unnecessary-condition": ["error", { allowConstantLoopConditions: true }],
+			"@typescript-eslint/no-unsafe-type-assertion": "off",
+			"@typescript-eslint/no-useless-default-assignment": "off",
+			"@typescript-eslint/prefer-destructuring": ["error", {
+				array: false,
+				object: true
+			}],
+			"@typescript-eslint/prefer-readonly-parameter-types": "off",
+			"@typescript-eslint/strict-boolean-expressions": "off",
+			camelcase: "off",
+			"capitalized-comments": [
+				"error",
+				"always",
+				{ ignorePattern: "oxlint|biome|console|let|const|return|if|for|throw" }
+			],
+			curly: ["error", "multi"],
+			"id-length": "off",
+			"max-lines": "off",
+			"max-lines-per-function": "off",
+			"max-statements": "off",
+			"new-cap": ["error", { capIsNewExceptionPattern: ".*" }],
+			"no-duplicate-imports": ["error", { allowSeparateTypeImports: true }],
+			"no-magic-numbers": "off",
+			"no-nested-ternary": "off",
+			"no-ternary": "off",
+			"no-undefined": "off",
+			"no-underscore-dangle": "off",
+			"one-var": ["error", "never"],
+			"perfectionist/sort-imports": ["error", {
+				newlinesBetween: 0,
+				order: "asc",
+				type: "natural"
+			}],
+			"perfectionist/sort-objects": "off",
+			"perfectionist/sort-variable-declarations": "off",
+			"preferArrow/prefer-arrow-functions": ["error", { returnStyle: "implicit" }],
+			"require-atomic-updates": "off",
+			"sort-imports": "off",
+			"sort-keys": "off",
+			"sort-vars": "off"
+		}
+	}, {
+		plugins: eslintReact.configs["strict-type-checked"].plugins,
+		rules: {
+			...warnToError({
+				...eslintReact.configs["strict-type-checked"].rules,
+				...eslintReact.configs.recommended.rules
+			}),
+			"@eslint-react/dom/no-string-style-prop": "error",
+			"@eslint-react/dom/no-unknown-property": "error",
+			"@eslint-react/jsx-no-undef": "error"
+		}
+	}), ...defineConfig(reactHooks.configs.flat["recommended-latest"], {
+		files: ["**/*.ts", "**/*.tsx"],
+		...reactPlugin.configs.flat.all,
+		...reactPlugin.configs.flat["jsx-runtime"],
+		languageOptions: {
+			...reactPlugin.configs.flat.all?.languageOptions,
+			...reactPlugin.configs.flat["jsx-runtime"]?.languageOptions,
+			globals: { React: "writable" }
+		},
+		plugins: {
+			"better-tailwindcss": eslintPluginBetterTailwindcss,
+			react: reactPlugin
+		},
+		rules: {
+			...reactPlugin.configs["jsx-runtime"].rules,
+			...reactPlugin.configs.all.rules,
+			...tailwindRules(tailwindEntry),
+			"better-tailwindcss/enforce-consistent-line-wrapping": "off",
+			"react-hooks/exhaustive-deps": "error",
+			"react-hooks/incompatible-library": "error",
+			"react-hooks/preserve-manual-memoization": "off",
+			"react-hooks/set-state-in-effect": "off",
+			"react-hooks/unsupported-syntax": "error",
+			"react/forbid-component-props": "off",
+			"react/function-component-definition": "off",
+			"react/jsx-child-element-spacing": "off",
+			"react/jsx-closing-bracket-location": "off",
+			"react/jsx-curly-newline": "off",
+			"react/jsx-filename-extension": ["error", { extensions: [".tsx"] }],
+			"react/jsx-handler-names": "off",
+			"react/jsx-indent": "off",
+			"react/jsx-indent-props": "off",
+			"react/jsx-max-depth": "off",
+			"react/jsx-max-props-per-line": "off",
+			"react/jsx-newline": "off",
+			"react/jsx-no-bind": "off",
+			"react/jsx-no-literals": "off",
+			"react/jsx-one-expression-per-line": "off",
+			"react/jsx-props-no-spreading": "off",
+			"react/jsx-sort-props": ["error", { ignoreCase: true }],
+			"react/no-multi-comp": "off",
+			"react/prefer-read-only-props": "off",
+			"react/require-default-props": "off"
+		},
+		settings: tailwindSettings
+	}), ...defineConfig({
+		files: ["**/*.ts", "**/*.tsx"],
+		plugins: { "@next/next": nextPlugin },
+		rules: {
+			...warnToError({
+				...nextPlugin.configs.recommended.rules,
+				...nextPlugin.configs["core-web-vitals"].rules
+			}),
+			"@next/next/no-duplicate-head": "off",
+			"@next/next/no-html-link-for-pages": "off"
+		}
+	}), ...defineConfig({
+		files: [...ESLINT_TEST_FILE_PATTERNS],
+		rules: { "@typescript-eslint/require-await": "off" }
+	}));
+	const appendConfigs = normalizeAppendInput({ append: opts.append });
+	const knownRuleNames = collectKnownEslintRuleNames({
+		appendConfigs,
+		baseConfigs: configs$1
+	});
+	const normalizedRules = normalizeRulesOffInput({
+		label: "eslint.off",
+		value: opts.off
+	});
+	if (normalizedRules) {
+		const unknownRules = findUnknownRules({
+			knownRules: knownRuleNames,
+			rules: normalizedRules
+		});
+		if (unknownRules.length > 0) throw new Error(`eslint.off contains unknown eslint rules: ${unknownRules.join(", ")}`);
+		const overrideRules = {};
+		for (const [key, value] of Object.entries(normalizedRules)) overrideRules[key] = value;
+		configs$1.push({ rules: overrideRules });
+	}
+	for (const config of appendConfigs) {
+		const shared = getSharedAppendConfig({ config });
+		const unknownRules = shared && config.rules ? findUnknownRules({
+			knownRules: knownRuleNames,
+			rules: config.rules
+		}) : [];
+		if (unknownRules.length > 0) throw new Error(`overrides.eslint contains unknown eslint rules: ${unknownRules.join(", ")}`);
+		const sanitized = shared === null ? config : (() => {
+			const out = {};
+			if (shared.files !== void 0) out.files = shared.files;
+			if (shared.rules !== void 0) out.rules = shared.rules;
+			return out;
+		})();
+		configs$1.push(sanitized.rules ? {
+			...sanitized,
+			rules: warnToError(sanitized.rules)
+		} : sanitized);
+	}
+	configs$1.push({
+		languageOptions: { parserOptions: {
+			projectService: true,
+			tsconfigRootDir: root
+		} },
+		linterOptions: { reportUnusedDisableDirectives: true }
+	});
+	return defineConfig(...configs$1);
+};
+const defaultConfig = eslintFactory();
+//#endregion
+export { defaultConfig as default, eslintFactory as eslint };

package/dist/ignores-BzTRqd-5.mjs

@@ -0,0 +1,102 @@
+import { a as ESLINT_TEST_FILE_PATTERNS, i as DEFAULT_SHARED_IGNORE_PATTERNS } from "./constants-Cjkf4mJh.mjs";
+import { $, Glob } from "bun";
+//#region src/ignores.ts
+/** biome-ignore-all lint/nursery/useNamedCaptureGroup: not needed */
+const eslintDisableRe = /eslint-disable(?:-next-line)?\s+(.+?)(?:\s*\*\/|\s*$)/gu;
+const oxlintDisableRe = /oxlint-disable(?:-next-line)?\s+(.+?)(?:\s*\*\/|\s*$)/gu;
+const biomeIgnoreRe = /biome-ignore(?:-all)?\s+([\w/]+)/gu;
+const tsIgnoreRe = /@ts-(?:ignore|expect-error|nocheck)/gu;
+const trailingCommentRe = /\s*--.*$/u;
+const trailingCloseRe = /\s*\*\/$/u;
+const tsInlineRe = /@ts-(?:ignore|expect-error|nocheck)/u;
+const DANGEROUS_PATTERNS = [
+	"no-unsafe-",
+	"no-non-null-assertion",
+	"@ts-ignore",
+	"@ts-nocheck",
+	"noNonNullAssertion"
+];
+const DANGEROUS_NON_TEST_PATTERNS = [
+	"@ts-expect-error",
+	"no-explicit-any",
+	"noExplicitAny"
+];
+const isTestFile = (f) => ESLINT_TEST_FILE_PATTERNS.some((p) => new Glob(p).match(f));
+const isDangerousEntry = (rule, files) => {
+	if (DANGEROUS_PATTERNS.some((p) => rule.includes(p))) return true;
+	if (DANGEROUS_NON_TEST_PATTERNS.some((p) => rule.includes(p))) return files.some((f) => !isTestFile(f));
+	return false;
+};
+const parseRules = (line, re) => {
+	const rules = [];
+	re.lastIndex = 0;
+	let match = re.exec(line);
+	while (match) {
+		const raw = match[1];
+		if (raw) for (const r of raw.split(",")) {
+			const trimmed = r.trim().replace(trailingCommentRe, "").replace(trailingCloseRe, "");
+			if (trimmed) rules.push(trimmed);
+		}
+		match = re.exec(line);
+	}
+	return rules;
+};
+const scanIgnores = async (cwd) => {
+	const ruleFiles = /* @__PURE__ */ new Map();
+	const add = (rule, file) => {
+		const existing = ruleFiles.get(rule);
+		if (existing) existing.add(file);
+		else ruleFiles.set(rule, new Set([file]));
+	};
+	const lines = (await $`rg -n "^\s*//\s*eslint-disable|^\s*/\*\s*eslint-disable|^\s*//\s*oxlint-disable|^\s*/\*\s*oxlint-disable|^\s*/\*\*\s*biome-ignore|^\s*//\s*@ts-ignore|^\s*//\s*@ts-expect-error|^\s*//\s*@ts-nocheck|^\s*/\*\s*@ts-nocheck" ${cwd} -g '*.ts' -g '*.tsx' -g '!node_modules' -g '!*.d.ts' ${DEFAULT_SHARED_IGNORE_PATTERNS.flatMap((p) => ["-g", `!${p}`])}`.quiet().nothrow()).stdout.toString().trim().split("\n").filter(Boolean);
+	for (const line of lines) {
+		const firstColon = line.indexOf(":");
+		const secondColon = line.indexOf(":", firstColon + 1);
+		const file = line.slice(0, firstColon).replace(`${cwd}/`, "");
+		const content = secondColon > firstColon ? line.slice(secondColon + 1) : line.slice(firstColon + 1);
+		for (const rule of parseRules(content, eslintDisableRe)) add(rule, file);
+		for (const rule of parseRules(content, oxlintDisableRe)) add(rule, file);
+		for (const rule of parseRules(content, biomeIgnoreRe)) add(rule, file);
+		tsIgnoreRe.lastIndex = 0;
+		if (tsIgnoreRe.test(content)) {
+			const tsMatch = tsInlineRe.exec(content);
+			if (tsMatch) add(tsMatch[0], file);
+		}
+	}
+	return ruleFiles;
+};
+const formatIgnores = (ruleFiles, verbose) => {
+	if (ruleFiles.size === 0) return "no suppressions";
+	const entries = [...ruleFiles.entries()].map(([rule, files]) => ({
+		count: files.size,
+		files: [...files],
+		rule
+	})).toSorted((a, b) => b.count - a.count);
+	const dangerous = entries.filter((e) => isDangerousEntry(e.rule, e.files));
+	const safe = entries.filter((e) => !isDangerousEntry(e.rule, e.files));
+	const total = entries.reduce((sum, e) => sum + e.count, 0);
+	const lines = [];
+	if (dangerous.length > 0) {
+		const dangerousCount = dangerous.reduce((sum, e) => sum + e.count, 0);
+		lines.push(`!! ${dangerousCount} dangerous suppressions — fix these:`, "");
+		const maxRule = Math.max(...dangerous.map((e) => e.rule.length));
+		for (const e of dangerous) {
+			lines.push(`  ${e.rule.padEnd(maxRule)}  ${String(e.count).padStart(3)}`);
+			if (verbose) for (const f of e.files) lines.push(`    ${f}`);
+		}
+		lines.push("");
+	}
+	lines.push(`${total} suppressions across ${entries.length} rules`, "");
+	const maxRule = Math.max(...entries.map((e) => e.rule.length));
+	for (const e of safe) {
+		lines.push(`  ${e.rule.padEnd(maxRule)}  ${String(e.count).padStart(3)}`);
+		if (verbose) for (const f of e.files) lines.push(`    ${f}`);
+	}
+	return lines.join("\n");
+};
+const runIgnores = async (verbose) => {
+	const ruleFiles = await scanIgnores(process.cwd());
+	process.stdout.write(`${formatIgnores(ruleFiles, verbose)}\n`);
+};
+//#endregion
+export { runIgnores };

package/dist/index.d.mts

@@ -0,0 +1,13 @@
+import { r as SyncOptions, t as EslintImportAppendEntry } from "./lintmax-types-CJ7VY33l.mjs";
+
+//#region src/index.d.ts
+declare const sync: (options?: SyncOptions) => Promise<void>;
+declare const eslintImport: ({
+  files,
+  from,
+  ignores,
+  name
+}: Omit<EslintImportAppendEntry, "$lintmax">) => EslintImportAppendEntry;
+declare const defineConfig: <T extends SyncOptions>(options: T) => T;
+//#endregion
+export { type EslintImportAppendEntry, type SyncOptions, defineConfig, eslintImport, sync };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as eslintImport, r as sync, t as defineConfig } from "./src-C8jQ6tK0.mjs";
+export { defineConfig, eslintImport, sync };

package/dist/lintmax-types-CJ7VY33l.d.mts

@@ -0,0 +1,69 @@
+import { Linter } from "eslint";
+
+//#region src/lintmax-types.d.ts
+interface BiomeOptions {
+  ignores?: PathListInput;
+  off?: RulesOffInput;
+  overrides?: {
+    includes: PathListInput;
+    off: RulesOffInput;
+  }[];
+}
+interface EslintImportAppendEntry {
+  $lintmax: 'eslint-import';
+  files?: PathListInput;
+  from: string;
+  ignores?: PathListInput;
+  name?: string;
+}
+interface EslintOptions {
+  append?: Linter.Config[];
+  ignores?: PathListInput;
+  off?: RulesOffInput;
+  tailwind?: TailwindOption;
+  tsconfigRootDir?: string;
+}
+interface JsonObject {
+  [key: string]: JsonValue;
+}
+type JsonPrimitive = boolean | null | number | string;
+type JsonValue = JsonObject | JsonPrimitive | JsonValue[];
+interface OxlintOptions {
+  ignores?: PathListInput;
+  off?: RulesOffInput;
+  overrides?: {
+    files: PathListInput;
+    off: RulesOffInput;
+  }[];
+}
+type PathListInput = readonly string[];
+type RulesOffInput = readonly string[];
+type SharedOverrideMapRuleOptions = {
+  biome: RulesOffInput;
+  eslint?: RulesOffInput;
+  oxlint?: RulesOffInput;
+} | {
+  biome?: RulesOffInput;
+  eslint: RulesOffInput;
+  oxlint?: RulesOffInput;
+} | {
+  biome?: RulesOffInput;
+  eslint?: RulesOffInput;
+  oxlint: RulesOffInput;
+};
+interface SyncOptions {
+  biome?: BiomeOptions;
+  comments?: boolean;
+  compact?: boolean;
+  eslint?: Omit<EslintOptions, 'append' | 'tailwind' | 'tsconfigRootDir'> & {
+    append?: readonly (EslintImportAppendEntry | JsonObject)[];
+  };
+  ignores?: PathListInput;
+  overrides?: Record<string, SharedOverrideMapRuleOptions>;
+  oxlint?: OxlintOptions;
+  tailwind?: TailwindOption;
+  tsconfigRootDir?: string;
+}
+type TailwindOption = boolean | string;
+//#endregion
+export { EslintOptions as n, SyncOptions as r, EslintImportAppendEntry as t };