tailwind-lint 0.1.0

package/dist/linter-QRh7wAZ7.cjs

@@ -0,0 +1,686 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_constants = require('./constants-BFubEpZ9.cjs');
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let _tailwindcss_language_service = require("@tailwindcss/language-service");
+let fast_glob = require("fast-glob");
+fast_glob = __toESM(fast_glob);
+let vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_module = require("node:module");
+
+//#region src/code-actions.ts
+function getLanguageId$1(filePath) {
+	return {
+		".astro": "astro",
+		".css": "css",
+		".erb": "erb",
+		".hbs": "handlebars",
+		".htm": "html",
+		".html": "html",
+		".js": "javascript",
+		".jsx": "javascriptreact",
+		".less": "less",
+		".md": "markdown",
+		".mdx": "mdx",
+		".php": "php",
+		".sass": "sass",
+		".scss": "scss",
+		".svelte": "svelte",
+		".ts": "typescript",
+		".tsx": "typescriptreact",
+		".twig": "twig",
+		".vue": "vue"
+	}[node_path.extname(filePath).toLowerCase()] || "html";
+}
+async function getQuickfixes(state, document, uri, diagnostics) {
+	const lspDiagnostics = diagnostics.map((diag) => ({
+		range: diag.range,
+		severity: diag.severity,
+		message: diag.message,
+		code: diag.code,
+		source: diag.source || "tailwindcss"
+	}));
+	return (await (0, _tailwindcss_language_service.doCodeActions)(state, {
+		textDocument: { uri },
+		range: {
+			start: {
+				line: 0,
+				character: 0
+			},
+			end: {
+				line: document.lineCount,
+				character: 0
+			}
+		},
+		context: { diagnostics: lspDiagnostics }
+	}, document)).filter((action) => action.kind === "quickfix" || action.kind?.startsWith("quickfix."));
+}
+function applyFirstQuickfix(action, uri, document, content) {
+	if (!action.edit?.changes?.[uri]) return null;
+	const sortedEdits = [...action.edit.changes[uri]].sort((a, b) => {
+		const lineDiff = b.range.start.line - a.range.start.line;
+		if (lineDiff !== 0) return lineDiff;
+		return b.range.start.character - a.range.start.character;
+	});
+	let newContent = content;
+	for (const edit of sortedEdits) {
+		const startOffset = document.offsetAt(edit.range.start);
+		const endOffset = document.offsetAt(edit.range.end);
+		newContent = newContent.substring(0, startOffset) + edit.newText + newContent.substring(endOffset);
+	}
+	return { content: newContent };
+}
+async function applyCodeActions(state, filePath, content, diagnostics) {
+	if (diagnostics.length === 0) return {
+		content,
+		changed: false,
+		fixedCount: 0
+	};
+	const languageId = getLanguageId$1(filePath);
+	const uri = `file://${filePath}`;
+	let currentDocument = vscode_languageserver_textdocument.TextDocument.create(uri, languageId, 1, content);
+	let currentContent = content;
+	let totalFixed = 0;
+	let iteration = 0;
+	for (; iteration < require_constants.MAX_FIX_ITERATIONS; iteration++) {
+		const currentDiagnostics = await (0, _tailwindcss_language_service.doValidate)(state, currentDocument);
+		if (currentDiagnostics.length === 0) break;
+		const quickfixes = await getQuickfixes(state, currentDocument, uri, currentDiagnostics);
+		if (quickfixes.length === 0) break;
+		const fixResult = applyFirstQuickfix(quickfixes[0], uri, currentDocument, currentContent);
+		if (!fixResult) break;
+		currentContent = fixResult.content;
+		currentDocument = vscode_languageserver_textdocument.TextDocument.create(uri, languageId, currentDocument.version + 1, currentContent);
+		totalFixed++;
+	}
+	if (iteration === require_constants.MAX_FIX_ITERATIONS) {
+		if ((await (0, _tailwindcss_language_service.doValidate)(state, currentDocument)).length > 0) console.warn(`Warning: Reached maximum fix iterations (${require_constants.MAX_FIX_ITERATIONS}) for ${filePath}. Some issues may remain.`);
+	}
+	return {
+		content: currentContent,
+		changed: currentContent !== content,
+		fixedCount: totalFixed
+	};
+}
+
+//#endregion
+//#region src/adapters/editor-state-adapter.ts
+function isDirectory(filePath) {
+	try {
+		return node_fs.statSync(filePath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function createEditorState(cwd) {
+	const settings = {
+		editor: { tabSize: require_constants.DEFAULT_TAB_SIZE },
+		tailwindCSS: {
+			inspectPort: null,
+			emmetCompletions: false,
+			includeLanguages: {},
+			classAttributes: [
+				"class",
+				"className",
+				"ngClass",
+				"[class]",
+				":class",
+				"v-bind:class",
+				"x-bind:class",
+				"class:list",
+				"classList"
+			],
+			classFunctions: [],
+			codeActions: true,
+			hovers: true,
+			codeLens: false,
+			suggestions: true,
+			validate: true,
+			colorDecorators: true,
+			rootFontSize: require_constants.DEFAULT_ROOT_FONT_SIZE,
+			showPixelEquivalents: true,
+			files: { exclude: [
+				"**/.git/**",
+				"**/node_modules/**",
+				"**/.hg/**",
+				"**/.svn/**"
+			] },
+			experimental: {
+				configFile: null,
+				classRegex: []
+			},
+			lint: {
+				cssConflict: "warning",
+				invalidApply: "error",
+				invalidScreen: "error",
+				invalidVariant: "error",
+				invalidConfigPath: "error",
+				invalidTailwindDirective: "error",
+				invalidSourceDirective: "error",
+				recommendedVariantOrder: "warning",
+				usedBlocklistedClass: "warning",
+				suggestCanonicalClasses: "warning"
+			}
+		}
+	};
+	return {
+		connection: null,
+		folder: cwd,
+		userLanguages: {},
+		capabilities: {
+			configuration: true,
+			diagnosticRelatedInformation: true,
+			itemDefaults: []
+		},
+		getConfiguration: async () => settings,
+		getDocumentSymbols: async () => [],
+		readDirectory: async (document, directory) => {
+			const docPath = typeof document === "string" ? document : document.uri.replace("file://", "");
+			const dir = node_path.resolve(node_path.dirname(docPath), directory);
+			try {
+				return node_fs.readdirSync(dir).map((file) => [file, { isDirectory: isDirectory(node_path.join(dir, file)) }]);
+			} catch {
+				return [];
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/types.ts
+/**
+* Error thrown when adapter fails to load required modules
+*/
+var AdapterLoadError = class extends Error {
+	constructor(version, cause) {
+		super(`Failed to load ${version} adapter: ${cause.message}`);
+		this.version = version;
+		this.name = "AdapterLoadError";
+	}
+};
+
+//#endregion
+//#region src/adapters/v3-adapter.ts
+const require$3 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href || __filename);
+async function loadV3ClassMetadata(state, cwd, verbose = false) {
+	try {
+		const tailwindcss = require$3(require$3.resolve("tailwindcss", { paths: [cwd] }));
+		try {
+			const tailwindDir = node_path.dirname(require$3.resolve("tailwindcss/package.json", { paths: [cwd] }));
+			const contextUtils = require$3(node_path.join(tailwindDir, "lib", "lib", "setupContextUtils"));
+			const generateRulesModule = require$3(node_path.join(tailwindDir, "lib", "lib", "generateRules"));
+			state.modules = {
+				tailwindcss: {
+					version: state.version || "unknown",
+					module: tailwindcss
+				},
+				jit: {
+					generateRules: { module: generateRulesModule.generateRules || ((_set, _context) => []) },
+					createContext: { module: contextUtils.createContext },
+					expandApplyAtRules: { module: generateRulesModule.expandApplyAtRules }
+				}
+			};
+			if (verbose) console.log("  ✓ Loaded v3 JIT modules");
+		} catch (jitError) {
+			if (verbose) {
+				const message = jitError instanceof Error ? jitError.message : String(jitError);
+				console.log(`  ⚠ Warning: Could not load v3 JIT modules: ${message}`);
+			}
+			state.modules = { tailwindcss: {
+				version: state.version || "unknown",
+				module: tailwindcss
+			} };
+		}
+		extractConfigMetadata(state);
+	} catch (error) {
+		if (error instanceof Error) throw new AdapterLoadError("v3", error);
+		throw new Error(`Failed to load v3 class metadata: ${String(error)}`);
+	}
+}
+function extractConfigMetadata(state) {
+	const { config } = state;
+	if (!config || typeof config !== "object") return;
+	const theme = config.theme;
+	state.screens = Object.keys(theme?.screens ?? {});
+	state.blocklist = config.blocklist ?? [];
+	if (config.variants && typeof config.variants === "object") state.variants = Object.keys(config.variants).map((name) => ({
+		name,
+		values: [],
+		isArbitrary: false,
+		hasDash: true,
+		selectors: () => []
+	}));
+	if (config.corePlugins) state.corePlugins = Array.isArray(config.corePlugins) ? config.corePlugins : Object.keys(config.corePlugins);
+}
+
+//#endregion
+//#region src/adapters/v4-adapter.ts
+const require$2 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href || __filename);
+function fileExists$2(filePath) {
+	try {
+		return node_fs.existsSync(filePath);
+	} catch {
+		return false;
+	}
+}
+function readFileSync$2(filePath) {
+	if (!filePath || typeof filePath !== "string") throw new TypeError("File path must be a non-empty string");
+	return node_fs.readFileSync(filePath, "utf-8");
+}
+async function loadV4DesignSystem(state, cwd, configPath, verbose = false) {
+	try {
+		const tailwindcss = require$2(require$2.resolve("tailwindcss", { paths: [cwd] }));
+		if (tailwindcss !== null && tailwindcss !== void 0 && (typeof tailwindcss === "object" || typeof tailwindcss === "function") && "__unstable__loadDesignSystem" in tailwindcss && typeof tailwindcss.__unstable__loadDesignSystem === "function") {
+			let cssContent;
+			const basePath = node_path.dirname(configPath);
+			if (fileExists$2(configPath)) cssContent = readFileSync$2(configPath, true);
+			else cssContent = "@import \"tailwindcss\";";
+			const loadDesignSystem = tailwindcss.__unstable__loadDesignSystem;
+			const designSystem = await loadDesignSystem(cssContent, {
+				base: basePath,
+				async loadStylesheet(_id, base, content) {
+					if (content) return {
+						base,
+						content
+					};
+					if (!_id.startsWith(".") && !_id.startsWith("/")) try {
+						const pkgJsonPath = require$2.resolve(`${_id}/package.json`, { paths: [base, cwd] });
+						const pkgDir = node_path.dirname(pkgJsonPath);
+						const cssPath = node_path.join(pkgDir, "index.css");
+						if (fileExists$2(cssPath)) return {
+							base: pkgDir,
+							content: readFileSync$2(cssPath, true)
+						};
+					} catch {}
+					const filePath = node_path.resolve(base, _id);
+					if (fileExists$2(filePath)) return {
+						base: node_path.dirname(filePath),
+						content: readFileSync$2(filePath, true)
+					};
+					return {
+						base,
+						content: ""
+					};
+				}
+			});
+			Object.assign(designSystem, {
+				dependencies: () => /* @__PURE__ */ new Set(),
+				compile(classes) {
+					return (designSystem.candidatesToAst ? designSystem.candidatesToAst(classes) : designSystem.candidatesToCss?.(classes) || []).map((result) => {
+						if (Array.isArray(result)) return result;
+						if (result === null) return [];
+						return [];
+					});
+				}
+			});
+			state.designSystem = designSystem;
+			if (!state.classNames) state.classNames = { context: {} };
+			if (verbose) console.log("  ✓ Loaded v4 design system");
+		} else throw new AdapterLoadError("v4", /* @__PURE__ */ new Error("Tailwind v4 __unstable__loadDesignSystem is not available. Please ensure you have Tailwind CSS v4 installed."));
+	} catch (error) {
+		if (error instanceof AdapterLoadError) throw error;
+		if (error instanceof Error) throw new AdapterLoadError("v4", error);
+		throw new Error(`Failed to load v4 design system: ${String(error)}`);
+	}
+}
+
+//#endregion
+//#region src/state.ts
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href || __filename);
+function fileExists$1(filePath) {
+	try {
+		return node_fs.existsSync(filePath);
+	} catch {
+		return false;
+	}
+}
+function readFileSync$1(filePath) {
+	if (!filePath || typeof filePath !== "string") throw new TypeError("File path must be a non-empty string");
+	return node_fs.readFileSync(filePath, "utf-8");
+}
+function getTailwindVersion(cwd) {
+	try {
+		const tailwindPackageJson = require$1.resolve("tailwindcss/package.json", { paths: [cwd] });
+		return JSON.parse(node_fs.readFileSync(tailwindPackageJson, "utf-8")).version;
+	} catch {
+		return;
+	}
+}
+function isV4Config(version) {
+	return version?.startsWith("4.") ?? false;
+}
+function isCssConfigFile$1(filePath) {
+	return filePath.endsWith(".css");
+}
+async function loadTailwindConfig$1(configPath) {
+	if (isCssConfigFile$1(configPath)) return {};
+	if (!node_path.isAbsolute(configPath)) throw new Error(`Config path must be absolute for security reasons: ${configPath}`);
+	try {
+		delete require$1.cache[configPath];
+		const configModule = require$1(configPath);
+		const config = "default" in configModule ? configModule.default : configModule;
+		if (typeof config !== "object" || config === null) throw new Error("Config must be an object");
+		return config;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to load config from ${configPath}: ${errorMessage}`);
+	}
+}
+async function findTailwindConfigPath$1(cwd, configPath) {
+	if (configPath) {
+		const resolved = node_path.isAbsolute(configPath) ? configPath : node_path.resolve(cwd, configPath);
+		return fileExists$1(resolved) ? resolved : null;
+	}
+	for (const p of require_constants.V3_CONFIG_PATHS) {
+		const fullPath = node_path.join(cwd, p);
+		if (fileExists$1(fullPath)) return fullPath;
+	}
+	const v4Paths = require_constants.V4_CSS_FOLDERS.flatMap((folder) => require_constants.V4_CSS_NAMES.map((name) => node_path.join(folder, name)));
+	for (const p of v4Paths) {
+		const fullPath = node_path.join(cwd, p);
+		if (fileExists$1(fullPath)) try {
+			const content = readFileSync$1(fullPath);
+			if (content.includes("@import \"tailwindcss\"") || content.includes("@import 'tailwindcss'")) return fullPath;
+		} catch {}
+	}
+	return null;
+}
+function resolveTailwindPath(cwd, configDir) {
+	const paths = configDir ? [configDir, cwd] : [cwd];
+	try {
+		return require$1.resolve("tailwindcss", { paths });
+	} catch {
+		throw new Error(`Could not resolve tailwindcss module from ${paths.join(" or ")}`);
+	}
+}
+async function createState(cwd, configPath, verbose = false) {
+	const resolvedConfigPath = await findTailwindConfigPath$1(cwd, configPath);
+	if (!resolvedConfigPath) throw new Error("Could not find tailwind config file (JS/TS or CSS)");
+	const isCssConfig = isCssConfigFile$1(resolvedConfigPath);
+	const tailwindcss = require$1(resolveTailwindPath(cwd, node_path.dirname(resolvedConfigPath)));
+	const version = getTailwindVersion(cwd);
+	const isV4 = isV4Config(version);
+	if (verbose) {
+		console.log(`  Tailwind version: ${version || "unknown"}`);
+		console.log(`  Config type: ${isCssConfig ? "CSS (v4)" : "JavaScript"}`);
+		console.log(`  Config path: ${resolvedConfigPath}`);
+	}
+	let config = {};
+	let resolvedConfig = { separator: ":" };
+	if (!isCssConfig) {
+		config = await loadTailwindConfig$1(resolvedConfigPath);
+		resolvedConfig = {
+			...config,
+			separator: config.separator ?? require_constants.DEFAULT_SEPARATOR
+		};
+		if (tailwindcss.resolveConfig) resolvedConfig = tailwindcss.resolveConfig(config);
+	}
+	const state = {
+		enabled: true,
+		configPath: resolvedConfigPath,
+		config: resolvedConfig,
+		version,
+		v4: isV4 || void 0,
+		separator: resolvedConfig.separator || require_constants.DEFAULT_SEPARATOR,
+		screens: [],
+		variants: [],
+		classNames: void 0,
+		classList: void 0,
+		modules: void 0,
+		blocklist: [],
+		editor: createEditorState(cwd),
+		features: ["diagnostics"]
+	};
+	if (isV4 || isCssConfig) await loadV4DesignSystem(state, cwd, resolvedConfigPath, verbose);
+	else await loadV3ClassMetadata(state, cwd, verbose);
+	return state;
+}
+
+//#endregion
+//#region src/linter.ts
+function fileExists(filePath) {
+	try {
+		return require("node:fs").existsSync(filePath);
+	} catch {
+		return false;
+	}
+}
+function readFileSync(filePath) {
+	if (!filePath || typeof filePath !== "string") throw new TypeError("File path must be a non-empty string");
+	return require("node:fs").readFileSync(filePath, "utf-8");
+}
+function writeFileSync(filePath, content) {
+	if (!filePath || typeof filePath !== "string") throw new TypeError("File path must be a non-empty string");
+	if (typeof content !== "string") throw new TypeError("Content must be a string");
+	require("node:fs").writeFileSync(filePath, content, "utf-8");
+}
+function serializeDiagnostics(diagnostics) {
+	return diagnostics.map((diagnostic) => ({
+		range: {
+			start: {
+				line: diagnostic.range.start.line,
+				character: diagnostic.range.start.character
+			},
+			end: {
+				line: diagnostic.range.end.line,
+				character: diagnostic.range.end.character
+			}
+		},
+		severity: diagnostic.severity || 2,
+		message: diagnostic.message,
+		code: diagnostic.code?.toString(),
+		source: diagnostic.source
+	}));
+}
+function getLanguageId(filePath) {
+	return {
+		".astro": "astro",
+		".css": "css",
+		".erb": "erb",
+		".hbs": "handlebars",
+		".htm": "html",
+		".html": "html",
+		".js": "javascript",
+		".jsx": "javascriptreact",
+		".less": "less",
+		".md": "markdown",
+		".mdx": "mdx",
+		".php": "php",
+		".sass": "sass",
+		".scss": "scss",
+		".svelte": "svelte",
+		".ts": "typescript",
+		".tsx": "typescriptreact",
+		".twig": "twig",
+		".vue": "vue"
+	}[node_path.extname(filePath).toLowerCase()] || "html";
+}
+async function validateDocument(state, filePath, content) {
+	try {
+		if (!state) throw new Error("State is not initialized");
+		if (state.v4 && !state.designSystem) throw new Error("Design system not initialized for Tailwind v4. This might indicate a configuration issue.");
+		if (!state.v4 && !state.modules?.tailwindcss) throw new Error("Tailwind modules not initialized for Tailwind v3. This might indicate a configuration issue.");
+		const languageId = getLanguageId(filePath);
+		const uri = `file://${filePath}`;
+		return serializeDiagnostics(await (0, _tailwindcss_language_service.doValidate)(state, vscode_languageserver_textdocument.TextDocument.create(uri, languageId, 1, content)));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to validate document ${filePath}: ${message}`);
+	}
+}
+async function findTailwindConfigPath(cwd, configPath) {
+	const { V3_CONFIG_PATHS, V4_CSS_FOLDERS, V4_CSS_NAMES } = await Promise.resolve().then(() => require("./constants-Bstz7FuV.cjs"));
+	if (configPath) {
+		const resolved = node_path.isAbsolute(configPath) ? configPath : node_path.resolve(cwd, configPath);
+		return fileExists(resolved) ? resolved : null;
+	}
+	for (const p of V3_CONFIG_PATHS) {
+		const fullPath = node_path.join(cwd, p);
+		if (fileExists(fullPath)) return fullPath;
+	}
+	const v4Paths = V4_CSS_FOLDERS.flatMap((folder) => V4_CSS_NAMES.map((name) => node_path.join(folder, name)));
+	for (const p of v4Paths) {
+		const fullPath = node_path.join(cwd, p);
+		if (fileExists(fullPath)) try {
+			const content = readFileSync(fullPath);
+			if (content.includes("@import \"tailwindcss\"") || content.includes("@import 'tailwindcss'")) return fullPath;
+		} catch {}
+	}
+	return null;
+}
+function isCssConfigFile(filePath) {
+	return filePath.endsWith(".css");
+}
+async function loadTailwindConfig(configPath) {
+	if (isCssConfigFile(configPath)) return {};
+	if (!node_path.isAbsolute(configPath)) throw new Error(`Config path must be absolute for security reasons: ${configPath}`);
+	try {
+		const { createRequire } = await import("node:module");
+		const require = createRequire(require("url").pathToFileURL(__filename).href || __filename);
+		delete require.cache[configPath];
+		const configModule = require(configPath);
+		const config = "default" in configModule ? configModule.default : configModule;
+		if (typeof config !== "object" || config === null) throw new Error("Config must be an object");
+		return config;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to load config from ${configPath}: ${errorMessage}`);
+	}
+}
+async function discoverFiles(cwd, patterns, configPath, autoDiscover) {
+	if (autoDiscover) return discoverFilesFromConfig(cwd, configPath);
+	return expandPatterns(cwd, patterns);
+}
+async function expandPatterns(cwd, patterns) {
+	const explicitFiles = [];
+	const globPatterns = [];
+	for (const pattern of patterns) if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[")) globPatterns.push(pattern);
+	else if (fileExists(node_path.resolve(cwd, pattern))) explicitFiles.push(pattern);
+	if (globPatterns.length === 0) return explicitFiles;
+	const globResults = await (0, fast_glob.default)(globPatterns, {
+		cwd,
+		absolute: false,
+		ignore: require_constants.DEFAULT_IGNORE_PATTERNS
+	});
+	if (explicitFiles.length === 0) return globResults;
+	const fileSet = new Set(explicitFiles);
+	for (const file of globResults) fileSet.add(file);
+	return Array.from(fileSet);
+}
+async function discoverFilesFromConfig(cwd, configPath) {
+	const configFilePath = await findTailwindConfigPath(cwd, configPath);
+	if (!configFilePath) throw new Error("Could not find Tailwind config");
+	if (!isCssConfigFile(configFilePath)) {
+		const config = await loadTailwindConfig(configFilePath);
+		if (!config || !config.content) throw new Error("Could not find Tailwind config or config has no content property");
+		const patterns = extractContentPatterns(config);
+		if (patterns.length === 0) throw new Error("No content patterns found in Tailwind config");
+		return expandPatterns(cwd, patterns);
+	}
+	throw new Error("Auto-discovery is not supported for CSS-based configs (v4). Please specify file patterns.");
+}
+function extractContentPatterns(config) {
+	if (!config.content) return [];
+	if (Array.isArray(config.content)) return config.content.filter((p) => typeof p === "string");
+	if (config.content.files) return config.content.files.filter((p) => typeof p === "string");
+	return [];
+}
+async function processFiles(state, cwd, files, fix, onProgress) {
+	const results = [];
+	for (let i = 0; i < files.length; i++) {
+		if (onProgress) onProgress(i + 1, files.length, files[i]);
+		const result = await processFile(state, cwd, files[i], fix);
+		if (result) results.push(result);
+	}
+	return results;
+}
+async function processFile(state, cwd, filePath, fix) {
+	const absolutePath = node_path.isAbsolute(filePath) ? filePath : node_path.resolve(cwd, filePath);
+	if (!fileExists(absolutePath)) return null;
+	let content = readFileSync(absolutePath);
+	let diagnostics = await validateDocument(state, absolutePath, content);
+	let fixedCount = 0;
+	let wasFixed = false;
+	if (fix && diagnostics.length > 0) {
+		const fixResult = await applyCodeActions(state, absolutePath, content, diagnostics);
+		if (fixResult.changed) {
+			writeFileSync(absolutePath, fixResult.content);
+			content = fixResult.content;
+			wasFixed = true;
+			fixedCount = fixResult.fixedCount;
+			diagnostics = await validateDocument(state, absolutePath, content);
+		}
+	}
+	return {
+		path: node_path.relative(cwd, absolutePath),
+		diagnostics,
+		fixed: wasFixed,
+		fixedCount
+	};
+}
+async function initializeState(cwd, configPath, verbose = false) {
+	try {
+		if (verbose) console.log("→ Initializing Tailwind CSS language service...");
+		const state = await createState(cwd, configPath, verbose);
+		if (verbose) console.log("  ✓ State initialized successfully\n");
+		return state;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to initialize Tailwind state: ${message}`);
+	}
+}
+async function lint({ cwd, patterns, configPath, autoDiscover, fix = false, verbose = false, onProgress }) {
+	const files = await discoverFiles(cwd, patterns, configPath, autoDiscover);
+	if (verbose) console.log(`→ Discovered ${files.length} file${files.length !== 1 ? "s" : ""} to lint`);
+	if (files.length === 0) return {
+		files: [],
+		totalFilesProcessed: 0
+	};
+	return {
+		files: (await processFiles(await initializeState(cwd, configPath, verbose), cwd, files, fix, onProgress)).filter((result) => result.diagnostics.length > 0 || result.fixed),
+		totalFilesProcessed: files.length
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'lint', {
+  enumerable: true,
+  get: function () {
+    return lint;
+  }
+});
+//# sourceMappingURL=linter-QRh7wAZ7.cjs.map