@gustcss/vite 0.10.0 → 0.11.0

package/dist/index.mjs

@@ -3,6 +3,7 @@ import { spawn, spawnSync } from "child_process";
 import path from "path";
 import fs from "fs";
 import { randomBytes } from "crypto";
+import { pathToFileURL } from "node:url";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -164,8 +165,107 @@ var import_runner = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 })))(), 1);
 const SUPPORTED_SOURCE = /\.(?:[cm]?[jt]sx?|html)(?:$|\?)/;
 const HTML_SOURCE = /\.html(?:$|\?)/;
-const UNSUPPORTED_FRAMEWORK_SOURCE = /\.(?:vue|astro|svelte)(?:$|\?)/;
+const UNSUPPORTED_FRAMEWORK_SOURCE = /\.(?:vue|svelte)(?:$|\?)/;
 const DEPENDENCY_SOURCE = /(?:^|[\\/])node_modules[\\/]/;
+const CLASS_FUNCTION_NAMES = [
+	"cn",
+	"cx",
+	"clsx",
+	"classNames",
+	"cva",
+	"tv",
+	"twMerge",
+	"twJoin"
+];
+const CLASS_FUNCTION_CALL = new RegExp(`(?<![\\w$])(${CLASS_FUNCTION_NAMES.join("|")})\\s*\\(`, "g");
+const VARIANT_FUNCTION_NAMES = /* @__PURE__ */ new Set(["cva", "tv"]);
+const NESTED_CALL = /(?:^|[^\w$])([A-Za-z_$][\w$]*)\s*\(/g;
+function nestedCallRanges(args) {
+	const ranges = [];
+	NESTED_CALL.lastIndex = 0;
+	let match;
+	while ((match = NESTED_CALL.exec(args)) !== null) {
+		const open = args.indexOf("(", match.index + match[0].length - 1);
+		if (open < 0) continue;
+		const end = findBalancedEnd(args, open, "(", ")");
+		if (end < 0) continue;
+		ranges.push({
+			start: match.index,
+			end: end + 1,
+			isHelper: CLASS_FUNCTION_NAMES.includes(match[1])
+		});
+		NESTED_CALL.lastIndex = open + 1;
+	}
+	return ranges;
+}
+function innermostCallAt(ranges, index) {
+	let found = null;
+	for (const range of ranges) if (index >= range.start && index < range.end) {
+		if (found === null || range.start > found.start) found = range;
+	}
+	return found;
+}
+function parenDepthAt(value, index) {
+	let depth = 0;
+	for (let i = 0; i < index; i += 1) if (value[i] === "(") depth += 1;
+	else if (value[i] === ")") depth -= 1;
+	return depth;
+}
+function isComparisonOperand(args, segment) {
+	let before = segment.start - 1;
+	while (before >= 0 && /\s/.test(args[before])) before -= 1;
+	const lead = before >= 1 ? args.slice(before - 1, before + 1) : "";
+	if (lead === "==" || lead === "!=" || before >= 1 && args[before] === "=") return true;
+	let after = segment.end;
+	while (after < args.length && /\s/.test(args[after])) after += 1;
+	const tail = args.slice(after, after + 2);
+	return tail === "==" || tail === "!=";
+}
+function defaultVariantsRanges(args) {
+	const ranges = [];
+	const pattern = /defaultVariants\s*:\s*\{/g;
+	let match;
+	while ((match = pattern.exec(args)) !== null) {
+		const open = args.indexOf("{", match.index);
+		const end = findBalancedEnd(args, open, "{", "}");
+		if (end < 0) break;
+		ranges.push([open, end + 1]);
+		pattern.lastIndex = end;
+	}
+	return ranges;
+}
+function inRanges(ranges, index) {
+	return ranges.some(([start, end]) => index >= start && index < end);
+}
+function maskIgnoredRanges(text, origins, ranges) {
+	if (ranges.length === 0) return text;
+	const chars = text.split("");
+	let sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+	let cursor = 0;
+	for (let i = 0; i < chars.length && cursor < sorted.length; i += 1) {
+		const origin = origins[i];
+		while (cursor < sorted.length && origin >= sorted[cursor][1]) cursor += 1;
+		if (cursor >= sorted.length) break;
+		if (origin >= sorted[cursor][0] && origin < sorted[cursor][1]) {
+			if (chars[i] !== "\n") chars[i] = " ";
+		}
+	}
+	return chars.join("");
+}
+function stripObjectKeys(value) {
+	return value.replace(/([{,]\s*)([A-Za-z_$][\w$]*)(\s*:)/g, (_match, lead, name, tail) => {
+		return lead + " ".repeat(name.length) + tail;
+	});
+}
+function isObjectKey(args, segment) {
+	let before = segment.start - 1;
+	while (before >= 0 && /\s/.test(args[before])) before -= 1;
+	const lead = before >= 0 ? args[before] : "";
+	if (lead !== "{" && lead !== ",") return false;
+	let after = segment.end;
+	while (after < args.length && /\s/.test(args[after])) after += 1;
+	return args[after] === ":";
+}
 function hasOwn(classes, token) {
 	return Object.hasOwn(classes, token);
 }
@@ -210,6 +310,7 @@ function findRawTextClosing(code, tagName, start) {
 function analyzeHtml(code, id) {
 	const markup = new Array(code.length).fill(" ");
 	const scriptRanges = [];
+	const commentRanges = [];
 	const exampleStack = [];
 	let index = 0;
 	while (index < code.length) {
@@ -217,7 +318,12 @@ function analyzeHtml(code, id) {
 		if (open < 0) break;
 		if (code.startsWith("<!--", open)) {
 			const commentEnd = code.indexOf("-->", open + 4);
-			index = commentEnd < 0 ? code.length : commentEnd + 3;
+			const end = commentEnd < 0 ? code.length : commentEnd + 3;
+			commentRanges.push({
+				start: open,
+				end
+			});
+			index = end;
 			continue;
 		}
 		const tagEnd = findHtmlTagEnd(code, open);
@@ -253,7 +359,8 @@ function analyzeHtml(code, id) {
 	if (exampleStack.length > 0) throw new Error(`[gustcss] unclosed <${exampleStack.at(-1)}> in ${id}`);
 	return {
 		markup: markup.join(""),
-		scriptRanges
+		scriptRanges,
+		commentRanges
 	};
 }
 function canStartRegex(code, index, previous) {
@@ -481,7 +588,7 @@ function rejectAmbiguousClassExpressions(code, structure, classes, id) {
 	while ((match = pattern.exec(structure)) !== null) {
 		const open = code.indexOf("{", match.index);
 		const end = findBalancedEnd(code, open, "{", "}");
-		if (end < 0) break;
+		if (end < 0) throw new Error(`[gustcss] incomplete class/className expression in ${id}. Ensure the expression is properly closed.`);
 		const ambiguous = findMappedToken(code.slice(open + 1, end - 1), classes);
 		if (ambiguous) throw new Error(`[gustcss] mapped class "${ambiguous}" remains in an ambiguous class expression in ${id}. Use a static class attribute/template segment, or add it to mangleExclude.`);
 		pattern.lastIndex = end;
@@ -508,6 +615,44 @@ function collectClassListCallEdits(code, structure, classes, id, edits) {
 		pattern.lastIndex = end;
 	}
 }
+function collectClassFunctionCallEdits(code, structure, classes, id, edits, ignores) {
+	CLASS_FUNCTION_CALL.lastIndex = 0;
+	let match;
+	while ((match = CLASS_FUNCTION_CALL.exec(structure)) !== null) {
+		const name = match[1];
+		const open = code.indexOf("(", match.index + name.length);
+		if (open < 0) continue;
+		const end = findBalancedEnd(code, open, "(", ")");
+		if (end < 0) throw new Error(`[gustcss] incomplete ${name}(...) call in ${id}. Ensure the expression is properly closed.`);
+		const args = code.slice(open + 1, end - 1);
+		const argsStart = open + 1;
+		const skipKeys = VARIANT_FUNCTION_NAMES.has(name);
+		const skipRanges = skipKeys ? defaultVariantsRanges(args) : [];
+		const nestedCalls = nestedCallRanges(args);
+		const depthSource = stripQuotedSegments(args);
+		scanQuotedSegments(args, (segment) => {
+			const { start, quote, contents } = segment;
+			const nested = innermostCallAt(nestedCalls, start);
+			if (!(nested !== null && nested.isHelper) && parenDepthAt(depthSource, start) > 0) return;
+			if (skipKeys && quote !== "`" && isObjectKey(args, segment) || inRanges(skipRanges, segment.start) || isComparisonOperand(args, segment)) {
+				ignores.push([argsStart + segment.start, argsStart + segment.end]);
+				return;
+			}
+			const offset = argsStart + start + 1;
+			if (quote === "`") {
+				collectTemplateBodyEdits(contents, classes, offset, edits);
+				return;
+			}
+			collectClassListEdits(contents, classes, offset, edits);
+		});
+		let withoutStrings = stripQuotedSegments(args);
+		if (skipKeys) withoutStrings = stripObjectKeys(withoutStrings);
+		for (const [rangeStart, rangeEnd] of skipRanges) withoutStrings = withoutStrings.slice(0, rangeStart) + " ".repeat(rangeEnd - rangeStart) + withoutStrings.slice(rangeEnd);
+		const dynamic = findMappedToken(withoutStrings, classes);
+		if (dynamic) throw new Error(`[gustcss] mapped class "${dynamic}" remains in a dynamic argument of ${name}(...) in ${id}. Pass it as a direct string literal, or add it to mangleExclude.`);
+		CLASS_FUNCTION_CALL.lastIndex = end;
+	}
+}
 function rejectDynamicSetAttributeCalls(code, structure, classes, id) {
 	const pattern = /\.setAttribute\s*\(/g;
 	let match;
@@ -575,40 +720,94 @@ function sourcesForFile(code, id) {
 	const inspection = new Array(code.length).fill(" ");
 	for (const range of html.scriptRanges) {
 		const script = code.slice(range.start, range.end);
-		const js = createJsMasks(script);
+		const jsScript = createJsMasks(script);
 		for (let offset = 0; offset < script.length; offset += 1) {
-			structure[range.start + offset] = js.structure[offset];
-			inspection[range.start + offset] = js.inspection[offset];
+			structure[range.start + offset] = jsScript.structure[offset];
+			inspection[range.start + offset] = jsScript.inspection[offset];
 		}
 	}
+	for (const range of html.commentRanges) for (let offset = range.start; offset < range.end; offset += 1) inspection[offset] = " ";
 	return {
 		attributes: html.markup,
 		structure: structure.join(""),
 		inspection: inspection.join("")
 	};
 }
-function collectRecognizedContextEdits(code, classes, id) {
+function collectEdits(code, classes, id) {
 	const edits = [];
+	const ignores = [];
 	const sources = sourcesForFile(code, id);
+	const commentRanges = [];
+	let commentIndex = 0;
+	while ((commentIndex = code.indexOf("<!--", commentIndex)) >= 0) {
+		const commentEnd = code.indexOf("-->", commentIndex + 4);
+		if (commentEnd < 0) {
+			commentRanges.push({
+				start: commentIndex,
+				end: code.length
+			});
+			break;
+		}
+		commentRanges.push({
+			start: commentIndex,
+			end: commentEnd + 3
+		});
+		commentIndex = commentEnd + 3;
+	}
+	function isInComment(pos) {
+		return commentRanges.some((range) => pos >= range.start && pos < range.end);
+	}
 	const attributePattern = /((?<![:\w-])class(?:Name)?\s*=\s*)(?:(["'])([\s\S]*?)(\2)|(\{\s*)(["'])([\s\S]*?)(\6)(\s*\}))/g;
 	let match;
 	while ((match = attributePattern.exec(sources.attributes)) !== null) {
+		if (isInComment(match.index)) continue;
 		if (!HTML_SOURCE.test(id) && !isJsxAttributeAt(sources.structure, match.index)) continue;
 		if (match[2] !== void 0) collectClassListEdits(match[3], classes, match.index + match[1].length + 1, edits);
 		else collectClassListEdits(match[7], classes, match.index + match[1].length + match[5].length + 1, edits);
 	}
 	const templatePattern = /((?<![:\w-])class(?:Name)?\s*=\s*\{\s*`)([\s\S]*?)(`\s*\})/g;
 	while ((match = templatePattern.exec(sources.attributes)) !== null) {
+		if (isInComment(match.index)) continue;
 		if (!HTML_SOURCE.test(id) && !isJsxAttributeAt(sources.structure, match.index)) continue;
 		collectTemplateBodyEdits(match[2], classes, match.index + match[1].length, edits);
 	}
 	collectClassListCallEdits(code, sources.structure, classes, id, edits);
+	collectClassFunctionCallEdits(code, sources.structure, classes, id, edits, ignores);
 	const setAttributePattern = /(\.setAttribute\(\s*["']class["']\s*,\s*)(["'])([\s\S]*?)(\2)(\s*\))/g;
 	while ((match = setAttributePattern.exec(code)) !== null) {
 		if (sources.structure[match.index] === " ") continue;
 		collectClassListEdits(match[3], classes, match.index + match[1].length + 1, edits);
 	}
-	return applyEdits(code, edits);
+	return {
+		edits,
+		ignores
+	};
+}
+function collectRecognizedContextEdits(code, classes, id) {
+	const collected = collectEdits(code, classes, id);
+	return {
+		...applyEdits(code, collected.edits),
+		ignores: collected.ignores
+	};
+}
+/**
+* Collect the rewrites for a source fragment (TypeScript frontmatter, an inline
+* `<script>` body, …) and run the same fail-closed checks as `transformSource`,
+* but return the edits instead of the rewritten code so the caller can place
+* them inside a larger document.
+*/
+function collectFragmentEdits(code, classes, id) {
+	const collected = collectEdits(code, classes, id);
+	const applied = applyEdits(code, collected.edits);
+	const rewritten = applied.code;
+	const sources = sourcesForFile(rewritten, id);
+	const inspection = maskIgnoredRanges(sources.inspection, applied.origins, collected.ignores);
+	rejectDynamicSetAttributeCalls(rewritten, sources.structure, classes, id);
+	rejectDynamicClassNameAssignments(rewritten, sources.structure, classes, id);
+	rejectAmbiguousClassExpressions(rewritten, sources.structure, classes, id);
+	const ambiguous = findMappedInQuotedSegments(inspection, classes);
+	if (ambiguous) throw new Error(`[gustcss] mapped class "${ambiguous}" remains in an ambiguous string in ${id}. Move it to a static class/className or classList context, or add it to mangleExclude.`);
+	return collected.edits;
 }
 const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 function encodeVLQ(value) {
@@ -676,13 +875,14 @@ function transformSource(code, classes, id) {
 	const transformed = collectRecognizedContextEdits(code, classes, id);
 	const rewritten = transformed.code;
 	const sources = sourcesForFile(rewritten, id);
+	const inspection = maskIgnoredRanges(sources.inspection, transformed.origins, transformed.ignores);
 	rejectDynamicSetAttributeCalls(rewritten, sources.structure, classes, id);
 	rejectDynamicClassNameAssignments(rewritten, sources.structure, classes, id);
 	rejectAmbiguousClassExpressions(rewritten, sources.structure, classes, id);
 	return {
 		code: rewritten,
 		map: createSourceMap(code, rewritten, transformed.origins, id),
-		inspection: sources.inspection
+		inspection
 	};
 }
 function findAmbiguousMappedClass(code, classes) {
@@ -696,7 +896,7 @@ function createClassNameTransformer(classes) {
 	const transformWithSourceMap = (code, id) => {
 		if (UNSUPPORTED_FRAMEWORK_SOURCE.test(id)) {
 			const referenced = findMappedToken(code, classes);
-			if (referenced) throw new Error(`[gustcss] class-name mangling does not support Vue, Astro, or Svelte templates yet (${id}). Add "${referenced}" to mangleExclude or disable mangleClassNames.`);
+			if (referenced) throw new Error(`[gustcss] class-name mangling does not support Vue or Svelte templates yet (${id}). Add "${referenced}" to mangleExclude or disable mangleClassNames.`);
 			return {
 				code,
 				map: null
@@ -716,9 +916,392 @@ function createClassNameTransformer(classes) {
 	};
 	const transform = (code, id) => transformWithSourceMap(code, id).code;
 	transform.withSourceMap = transformWithSourceMap;
+	transform.classes = classes;
 	return transform;
 }
 //#endregion
+//#region src/astro.js
+/**
+* Class-name mangling for `.astro` sources, driven by the AST that
+* `@astrojs/compiler`'s `parse()` returns.
+*
+* Only unambiguous class contexts are rewritten; any other place where a
+* mapped class name shows up fails the build (fail-closed), because a class
+* that reaches the DOM unrenamed would no longer match the mangled CSS.
+*/
+const CLASS_VALUED_BEFORE = /* @__PURE__ */ new Set([
+	"[",
+	",",
+	"&&",
+	"||"
+]);
+const CLASS_VALUED_AFTER = /* @__PURE__ */ new Set([
+	",",
+	"]",
+	"&&",
+	"||"
+]);
+const OPERATORS = [
+	"===",
+	"!==",
+	"&&",
+	"||",
+	"??",
+	"=>",
+	"==",
+	"!=",
+	"?.",
+	"<=",
+	">="
+];
+const PUNCTUATION = "[]{}(),:?.!+-*/%<>=&|~^;";
+/** Map UTF-8 byte offsets (what the compiler reports) to string indexes. */
+function byteToIndexMap(code) {
+	const map = [];
+	let byte = 0;
+	for (let index = 0; index < code.length; index += 1) {
+		const point = code.codePointAt(index);
+		const width = point < 128 ? 1 : point < 2048 ? 2 : point < 65536 ? 3 : 4;
+		for (let i = 0; i < width; i += 1) map[byte + i] = index;
+		byte += width;
+		if (point > 65535) index += 1;
+	}
+	map[byte] = code.length;
+	return map;
+}
+/**
+* Tokenize a JavaScript expression just far enough to know, for every string
+* literal and identifier, what surrounds it. Template literals are reported
+* as strings with quote "`" and are never rewritten. Returns null when the
+* expression cannot be tokenized (unterminated string, unknown character).
+*/
+function tokenizeExpression(source) {
+	const tokens = [];
+	let index = 0;
+	while (index < source.length) {
+		const char = source[index];
+		if (/\s/.test(char)) {
+			index += 1;
+			continue;
+		}
+		if (source.startsWith("//", index)) {
+			const newline = source.indexOf("\n", index);
+			index = newline < 0 ? source.length : newline + 1;
+			continue;
+		}
+		if (source.startsWith("/*", index)) {
+			const close = source.indexOf("*/", index + 2);
+			if (close < 0) return null;
+			index = close + 2;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			const start = index;
+			index += 1;
+			while (index < source.length && source[index] !== char) {
+				if (source[index] === "\\") index += 1;
+				index += 1;
+			}
+			if (index >= source.length) return null;
+			tokens.push({
+				type: "string",
+				quote: char,
+				start,
+				end: index + 1,
+				value: source.slice(start + 1, index)
+			});
+			index += 1;
+			continue;
+		}
+		if (/[A-Za-z_$]/.test(char)) {
+			const start = index;
+			while (index < source.length && /[\w$]/.test(source[index])) index += 1;
+			tokens.push({
+				type: "identifier",
+				start,
+				end: index,
+				value: source.slice(start, index)
+			});
+			continue;
+		}
+		if (/[0-9]/.test(char)) {
+			const start = index;
+			while (index < source.length && /[\w.]/.test(source[index])) index += 1;
+			tokens.push({
+				type: "number",
+				start,
+				end: index,
+				value: source.slice(start, index)
+			});
+			continue;
+		}
+		const operator = OPERATORS.find((candidate) => source.startsWith(candidate, index));
+		if (operator) {
+			tokens.push({
+				type: "operator",
+				start: index,
+				end: index + operator.length,
+				value: operator
+			});
+			index += operator.length;
+			continue;
+		}
+		if (PUNCTUATION.includes(char)) {
+			tokens.push({
+				type: "operator",
+				start: index,
+				end: index + 1,
+				value: char
+			});
+			index += 1;
+			continue;
+		}
+		return null;
+	}
+	return tokens;
+}
+/**
+* Rewrite the class-valued string literals of a `class:list` expression.
+* Accepted shapes are array literals, object literals and their nesting.
+* Inside them only array elements (also as the right operand of `&&` / `||`)
+* and quoted object keys are class-valued; every other occurrence of a mapped
+* class name fails closed.
+*/
+function collectClassListExpressionEdits(source, classes, baseOffset, edits, id) {
+	const fail = (token, reason) => {
+		throw new Error(`[gustcss] mapped class "${token}" ${reason} in class:list of ${id}. Use an array/object literal with quoted entries, or add it to mangleExclude.`);
+	};
+	const tokens = tokenizeExpression(source);
+	const first = tokens && tokens[0];
+	const last = tokens && tokens[tokens.length - 1];
+	if (!(tokens && tokens.length >= 2 && (first.value === "[" && last.value === "]" || first.value === "{" && last.value === "}"))) {
+		const mapped = findMappedToken(source, classes);
+		if (mapped) fail(mapped, "remains in an expression that is not an array or object literal");
+		return;
+	}
+	const stack = [];
+	for (let i = 0; i < tokens.length; i += 1) {
+		const token = tokens[i];
+		const previous = tokens[i - 1];
+		const next = tokens[i + 1];
+		const context = stack[stack.length - 1];
+		if (token.type === "operator") {
+			if (token.value === "[") {
+				const subscript = previous && (previous.type === "identifier" || previous.type === "string" || previous.value === ")" || previous.value === "]");
+				stack.push(subscript ? "subscript" : "array");
+			} else if (token.value === "{") stack.push("object");
+			else if (token.value === "(") stack.push("call");
+			else if (token.value === "]" || token.value === "}" || token.value === ")") {
+				if (stack.length === 0) fail(findMappedToken(source, classes) || "?", "appears in an unbalanced");
+				stack.pop();
+			}
+			continue;
+		}
+		if (token.type === "identifier") {
+			if (!hasOwn(classes, token.value)) continue;
+			if (context === "object" && previous && (previous.value === "{" || previous.value === ",") && next && (next.value === ":" || next.value === "," || next.value === "}")) fail(token.value, `is an unquoted object key (write it as "${token.value}")`);
+			fail(token.value, "is referenced as an identifier");
+		}
+		if (token.type !== "string") continue;
+		const mapped = findMappedToken(token.value, classes);
+		if (token.quote === "`") {
+			if (mapped) fail(mapped, "remains in a template literal");
+			continue;
+		}
+		const arrayElement = context === "array" && previous && CLASS_VALUED_BEFORE.has(previous.value) && next && CLASS_VALUED_AFTER.has(next.value);
+		const objectKey = context === "object" && previous && (previous.value === "{" || previous.value === ",") && next && next.value === ":";
+		if (arrayElement || objectKey) collectClassListEdits(token.value, classes, baseOffset + token.start + 1, edits);
+		else if (mapped) fail(mapped, "remains in a position that is not an array element or object key");
+	}
+	if (stack.length !== 0) fail(findMappedToken(source, classes) || "?", "appears in an unbalanced");
+}
+/**
+* Find a mapped class referenced by a stylesheet selector, including at-rule
+* preludes (`@scope (.flex)`) and attribute selectors (`[class~="flex"]`).
+* Declarations and comments are ignored.
+*/
+function findMappedClassInStylesheet(css, classes) {
+	const source = css.replace(/\/\*[\s\S]*?\*\//g, " ");
+	let prelude = "";
+	let quote = null;
+	for (let i = 0; i < source.length; i += 1) {
+		const char = source[i];
+		if (quote) {
+			prelude += char;
+			if (char === "\\") {
+				prelude += source[i + 1] || "";
+				i += 1;
+			} else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			prelude += char;
+			continue;
+		}
+		if (char === "{") {
+			const found = findMappedClassInSelector(prelude.trim(), classes);
+			if (found) return found;
+			prelude = "";
+		} else if (char === "}" || char === ";") prelude = "";
+		else prelude += char;
+	}
+	return null;
+}
+function findMappedClassInSelector(selector, classes) {
+	const classPattern = /\.((?:\\.|[A-Za-z0-9_-])+)/g;
+	let match;
+	while ((match = classPattern.exec(selector)) !== null) {
+		const name = match[1].replace(/\\(.)/g, "$1");
+		if (hasOwn(classes, name)) return name;
+	}
+	const attributePattern = /\[\s*class\s*[~|^$*]?=\s*(["']?)([^\]"']+)\1\s*[is]?\s*\]/g;
+	while ((match = attributePattern.exec(selector)) !== null) {
+		const mapped = findMappedToken(match[2], classes);
+		if (mapped) return mapped;
+	}
+	return null;
+}
+/**
+* Locate the value of an attribute from its start offset (the attribute
+* name). Returns the index range of the value and its delimiter.
+*/
+function locateAttributeValue(code, attribute, start) {
+	let index = start + attribute.name.length;
+	while (index < code.length && /\s/.test(code[index])) index += 1;
+	if (code[index] !== "=") return null;
+	index += 1;
+	while (index < code.length && /\s/.test(code[index])) index += 1;
+	const delimiter = code[index];
+	if (delimiter === "\"" || delimiter === "'" || delimiter === "`") {
+		const end = code.indexOf(delimiter, index + 1);
+		return end < 0 ? null : {
+			start: index + 1,
+			end,
+			delimiter
+		};
+	}
+	if (delimiter === "{") {
+		const end = findBalancedEnd(code, index, "{", "}");
+		return end < 0 ? null : {
+			start: index + 1,
+			end: end - 1,
+			delimiter
+		};
+	}
+	return null;
+}
+const STRING_LITERAL = /^\s*(["'])((?:\\.|(?!\1)[^\\])*)\1\s*$/;
+/**
+* Create the `.astro` transformer. `parse` is `@astrojs/compiler`'s parse
+* function, injected so the plugin and the tests can supply their own copy.
+*/
+function createAstroTransformer({ parse, classes }) {
+	return async function transformAstro(code, id) {
+		const { ast } = await parse(code, { position: true });
+		const toIndex = byteToIndexMap(code);
+		const edits = [];
+		const offsetOf = (node) => toIndex[node.position.start.offset];
+		const stop = (mapped, where) => {
+			throw new Error(`[gustcss] mapped class "${mapped}" remains in ${where} in ${id}. Move it to a static class attribute or class:list literal, or add it to mangleExclude.`);
+		};
+		const fragmentEdits = (text, start, kind) => {
+			for (const edit of collectFragmentEdits(text, classes, `${id}#${kind}.ts`)) edits.push({
+				start: start + edit.start,
+				end: start + edit.end,
+				replacement: edit.replacement
+			});
+		};
+		const visitAttribute = (attribute, node) => {
+			const start = offsetOf(attribute);
+			const isComponent = node.type === "component";
+			const value = attribute.value || "";
+			if (attribute.name === "class") {
+				const location = locateAttributeValue(code, attribute, start);
+				if (location && attribute.kind === "quoted") {
+					collectClassListEdits(code.slice(location.start, location.end), classes, location.start, edits);
+					return;
+				}
+				if (location && attribute.kind === "expression") {
+					const expression = code.slice(location.start, location.end);
+					const literal = STRING_LITERAL.exec(expression);
+					if (literal) {
+						const inner = expression.indexOf(literal[1]) + 1;
+						collectClassListEdits(literal[2], classes, location.start + inner, edits);
+						return;
+					}
+				}
+				const mapped = findMappedToken(value, classes);
+				if (mapped) stop(mapped, `a dynamic class attribute (${attribute.kind})`);
+				return;
+			}
+			if (attribute.name === "class:list") {
+				const location = locateAttributeValue(code, attribute, start);
+				if (!location || attribute.kind !== "expression") {
+					const mapped = findMappedToken(value, classes);
+					if (mapped) stop(mapped, `a class:list attribute of kind ${attribute.kind}`);
+					return;
+				}
+				collectClassListExpressionEdits(code.slice(location.start, location.end), classes, location.start, edits, id);
+				return;
+			}
+			if (attribute.kind === "spread") {
+				const mapped = findMappedToken(`${attribute.name} ${value}`, classes);
+				if (mapped) stop(mapped, `a spread attribute on <${node.name}>`);
+				return;
+			}
+			if (attribute.name === "set:html" || attribute.name === "set:text" || isComponent) {
+				const mapped = findMappedToken(value, classes);
+				if (mapped) stop(mapped, isComponent ? `the "${attribute.name}" prop of <${node.name}>` : `a ${attribute.name} value`);
+			}
+		};
+		const visit = (node) => {
+			switch (node.type) {
+				case "frontmatter": {
+					const start = code.indexOf(node.value, offsetOf(node));
+					if (start >= 0) fragmentEdits(node.value, start, "frontmatter");
+					return;
+				}
+				case "comment":
+				case "text":
+				case "doctype": return;
+				case "expression":
+					for (const child of node.children) if (child.type === "text") {
+						const mapped = findMappedToken(child.value, classes);
+						if (mapped && /["'`]/.test(child.value)) stop(mapped, "a template expression");
+					} else visit(child);
+					return;
+				case "element":
+				case "component":
+				case "custom-element":
+				case "fragment":
+					for (const attribute of node.attributes) visitAttribute(attribute, node);
+					if (node.type === "element" && node.name === "style") {
+						for (const child of node.children) {
+							if (child.type !== "text") continue;
+							const mapped = findMappedClassInStylesheet(child.value, classes);
+							if (mapped) stop(mapped, "a <style> selector");
+						}
+						return;
+					}
+					if (node.type === "element" && node.name === "script") {
+						for (const child of node.children) if (child.type === "text") fragmentEdits(child.value, offsetOf(child), "script");
+						return;
+					}
+					for (const child of node.children) visit(child);
+					return;
+				default: for (const child of node.children || []) visit(child);
+			}
+		};
+		visit(ast);
+		const applied = applyEdits(code, edits);
+		return {
+			code: applied.code,
+			map: createSourceMap(code, applied.code, applied.origins, id)
+		};
+	};
+}
+//#endregion
 //#region src/index.js
 /**
 * @gustcss/vite - Vite plugin for CSS Utility Generator
@@ -733,18 +1316,183 @@ function createClassNameTransformer(classes) {
 * are provided by the developer in their build configuration. This plugin is
 * designed for build-time use only and should not process untrusted input.
 */
+const ASTRO_SOURCE = /\.astro(?:$|\?)/;
+const lintDebounceMs = 300;
+const ASTRO_MODULE = /^[^\0?]*\.astro$/;
+/**
+* Resolve @astrojs/compiler parse function from the project.
+*/
+async function resolveAstroCompiler(root) {
+	const projectRequire = createRequire(path.join(root, "package.json"));
+	const attempts = [
+		() => projectRequire.resolve("@astrojs/compiler"),
+		() => createRequire(projectRequire.resolve("astro/package.json")).resolve("@astrojs/compiler"),
+		() => createRequire(import.meta.url).resolve("@astrojs/compiler")
+	];
+	for (const attempt of attempts) try {
+		const mod = await import(pathToFileURL(attempt()).href);
+		if (typeof mod.parse === "function") return mod.parse;
+	} catch {}
+	return null;
+}
+/**
+* Vite logger へ出力する。テストなど logger が無い環境では console を使う。
+*/
+function lintLogger(server) {
+	const logger = server?.config?.logger;
+	return {
+		warn: (message) => logger?.warn ? logger.warn(message) : console.warn(message),
+		error: (message) => logger?.error ? logger.error(message) : console.error(message)
+	};
+}
+/**
+* Dev-server lint runner.
+*
+* Runs `gustcss lint --json` asynchronously and reports the diagnostics through
+* the logger. At most one lint process runs at a time; changes that arrive while
+* it runs are coalesced into one follow-up run. This keeps the dev server's
+* event loop free even on large projects.
+*/
+function createLintRunner({ cwd, binaryPath, configPath, logger, strict }) {
+	const maxOutput = 4194304;
+	const timeoutMs = 15e3;
+	let child = null;
+	let running = false;
+	let dirty = false;
+	let closed = false;
+	let lastSignature = null;
+	function report(code, stdout, stderr, aborted) {
+		if (aborted) return;
+		if (code !== 0 && code !== 1) {
+			logger.warn(`[gustcss] lint could not run: ${stderr.trim()}`);
+			return;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(stdout);
+		} catch {
+			logger.warn("[gustcss] lint output was not JSON");
+			return;
+		}
+		const diagnostics = Array.isArray(parsed?.diagnostics) ? parsed.diagnostics : [];
+		const signature = JSON.stringify(diagnostics.map((d) => [
+			d.file,
+			d.line,
+			d.column,
+			d.ruleId,
+			d.severity,
+			d.class,
+			d.message
+		]));
+		if (signature === lastSignature) return;
+		lastSignature = signature;
+		for (const d of diagnostics) {
+			const text = `[gustcss] ${d.line ? `${d.file}:${d.line}:${d.column}` : d.file} ${d.ruleId}: ${d.message}`;
+			if (d.severity === "error") logger.error(text);
+			else logger.warn(text);
+		}
+		const suppressed = parsed?.summary?.suppressed ?? 0;
+		if (diagnostics.length > 0 && suppressed > 0) logger.warn(`[gustcss] lint: ${suppressed} problem(s) suppressed by baseline or comments`);
+	}
+	let closing = false;
+	function runOnce() {
+		return new Promise((resolve) => {
+			const args = ["lint", "--json"];
+			if (configPath) args.push("--config", configPath);
+			if (strict) args.push("--strict");
+			let proc;
+			try {
+				proc = spawn(binaryPath, args, {
+					cwd,
+					stdio: [
+						"ignore",
+						"pipe",
+						"pipe"
+					]
+				});
+			} catch (error) {
+				logger.warn(`[gustcss] lint failed to run: ${error.message}`);
+				resolve();
+				return;
+			}
+			child = proc;
+			let stdout = "";
+			let stderr = "";
+			let settled = false;
+			let aborted = false;
+			const timer = setTimeout(() => {
+				aborted = true;
+				logger.warn("[gustcss] lint timed out; skipping this run");
+				proc.kill();
+			}, timeoutMs);
+			if (closing) {
+				aborted = true;
+				proc.kill();
+			}
+			const finish = (code) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				child = null;
+				report(code, stdout, stderr, aborted || closing);
+				resolve();
+			};
+			proc.stdout?.on("data", (chunk) => {
+				if (stdout.length < maxOutput) stdout += chunk;
+			});
+			proc.stderr?.on("data", (chunk) => {
+				if (stderr.length < maxOutput) stderr += chunk;
+			});
+			proc.on("error", (error) => {
+				aborted = true;
+				logger.warn(`[gustcss] lint failed to run: ${error.message}`);
+				finish(-1);
+			});
+			proc.on("close", (code) => finish(code ?? -1));
+		});
+	}
+	return {
+		async request() {
+			if (closed) return;
+			if (running) {
+				dirty = true;
+				return;
+			}
+			running = true;
+			do {
+				dirty = false;
+				await runOnce();
+			} while (dirty && !closed);
+			running = false;
+		},
+		close() {
+			closed = true;
+			dirty = false;
+			closing = true;
+			if (child) {
+				child.kill();
+				child = null;
+			}
+		}
+	};
+}
 function cssUtility(opts = {}) {
 	const output = opts.output || "src/styles/utility.css";
 	const content = opts.content || ["./src/**/*.{js,ts,jsx,tsx,astro,vue}"];
 	const configPath = opts.config;
 	const outputToCssLayers = opts.outputToCssLayers;
 	const mangleClassNames = opts.mangleClassNames === true;
+	const lintEnabled = opts.lint === true || typeof opts.lint === "object" && opts.lint !== null;
+	const lintOptions = typeof opts.lint === "object" && opts.lint !== null ? opts.lint : {};
+	const lintSource = /\.[cm]?[jt]sx?$|\.(?:astro|html|vue|svelte|mdx?)$/;
 	const mangleMap = opts.mangleMap || `${output}.classes.json`;
 	const mangleExclude = opts.mangleExclude || [];
 	let classNameTransformer = null;
 	let rollbackContext = null;
 	let manifestSnapshot = null;
 	let watchProcess = null;
+	const loadedAstroModules = /* @__PURE__ */ new Set();
+	let astroTransformer = null;
 	function findBinary(cwd) {
 		return import_runner.default.resolveBinary({
 			cwd,
@@ -816,15 +1564,19 @@ function cssUtility(opts = {}) {
 			fs
 		}, (tempConfigPath) => run(tempConfigPath));
 	}
+	let viteConfig = null;
 	return {
 		name: "gustcss",
 		...mangleClassNames ? { enforce: "pre" } : {},
 		configResolved(config) {
+			viteConfig = config;
 			const cwd = config.root || process.cwd();
 			const binaryPath = findBinary(cwd);
 			try {
 				const enableMangle = mangleClassNames && config.command === "build";
 				buildCSS(cwd, binaryPath, enableMangle);
+				loadedAstroModules.clear();
+				astroTransformer = null;
 				rollbackContext = enableMangle ? {
 					cwd,
 					binaryPath
@@ -834,8 +1586,30 @@ function cssUtility(opts = {}) {
 				throw error;
 			}
 		},
+		async load(id) {
+			if (!classNameTransformer || !ASTRO_MODULE.test(id)) return null;
+			const filePath = id.startsWith("/@fs/") ? id.slice(4) : id;
+			if (!fs.existsSync(filePath)) throw new Error(`[gustcss] cannot read ${id} to rewrite its class names for mangling. Disable mangleClassNames or exclude its classes with mangleExclude.`);
+			const code = fs.readFileSync(filePath, "utf-8");
+			loadedAstroModules.add(id);
+			if (!astroTransformer) {
+				const parse = await resolveAstroCompiler(viteConfig?.root || process.cwd());
+				if (!parse) throw new Error(`[gustcss] @astrojs/compiler could not be resolved from the project, so ${id} cannot be mangled. Install astro, or disable mangleClassNames.`);
+				astroTransformer = createAstroTransformer({
+					parse,
+					classes: classNameTransformer.classes
+				});
+			}
+			const result = await astroTransformer(code, filePath);
+			return result.code === code ? null : result;
+		},
 		transform(code, id) {
 			if (!classNameTransformer) return null;
+			if (ASTRO_MODULE.test(id)) {
+				if (!loadedAstroModules.has(id)) throw new Error(`[gustcss] ${id} was compiled without passing through the gustcss load hook, so its class names cannot be mangled safely. Disable mangleClassNames or move the plugin so it loads .astro sources first.`);
+				return null;
+			}
+			if (ASTRO_SOURCE.test(id)) return null;
 			const transformed = classNameTransformer.withSourceMap(code, id);
 			return transformed.code === code ? null : transformed;
 		},
@@ -895,16 +1669,52 @@ function cssUtility(opts = {}) {
 					}]
 				});
 			});
+			let lintTimer = null;
+			const lintRunner = lintEnabled ? createLintRunner({
+				cwd,
+				binaryPath,
+				configPath: watchConfigPath,
+				logger: lintLogger(server),
+				strict: lintOptions.strict === true
+			}) : null;
+			if (lintRunner) {
+				lintRunner.request();
+				const scheduleLint = (file) => {
+					if (typeof file === "string") {
+						if (file.includes("node_modules")) return;
+						if (!lintSource.test(file)) return;
+					}
+					if (lintTimer) clearTimeout(lintTimer);
+					lintTimer = setTimeout(() => {
+						lintTimer = null;
+						lintRunner.request();
+					}, lintDebounceMs);
+				};
+				server.watcher.on("change", scheduleLint);
+				server.watcher.on("add", scheduleLint);
+				server.watcher.on("unlink", scheduleLint);
+			}
 			const cleanup = () => {
+				if (lintTimer) {
+					clearTimeout(lintTimer);
+					lintTimer = null;
+				}
+				lintRunner?.close();
 				if (watchProcess) {
 					watchProcess.kill();
 					watchProcess = null;
 				}
 				if (tempConfigPath && fs.existsSync(tempConfigPath)) fs.unlinkSync(tempConfigPath);
 			};
+			const close = server.close.bind(server);
+			server.close = async () => {
+				cleanup();
+				return close();
+			};
 			server.httpServer?.on("close", cleanup);
 			process.once("SIGINT", cleanup);
 			process.once("SIGTERM", cleanup);
+			process.once("exit", cleanup);
 		},
 		writeBundle() {
 			if (!manifestSnapshot || fs.existsSync(manifestSnapshot.path)) return;