@gustcss/vite 0.9.2 → 0.10.1

package/dist/index.cjs

@@ -20,7 +20,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -31,8 +31,10 @@ path = __toESM(path, 1);
 let fs = require("fs");
 fs = __toESM(fs, 1);
 let crypto = require("crypto");
+let node_module = require("node:module");
+let node_url = require("node:url");
 //#endregion
-//#region src/index.js
+//#region src/mangle.js
 var import_runner = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* gustcss shared runner — helpers for the @gustcss/postcss and @gustcss/vite
@@ -92,6 +94,24 @@ var import_runner = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 		return null;
 	}
 	/**
+	* Report whether a resolved gustcss.config.json turns on class-name mangling.
+	*
+	* Callers that cannot rewrite source (dev server, PostCSS) use this to decide
+	* whether they must pass `--mangle-class-names=false`. Only passing the flag
+	* when needed keeps older CLI binaries that predate the flag working.
+	*
+	* @param {{ configPath: string|null, fs?: { readFileSync: Function } }} options
+	* @returns {boolean}
+	*/
+	function configEnablesMangling({ configPath, fs: fs$4 = require("fs") }) {
+		if (!configPath) return false;
+		try {
+			return JSON.parse(fs$4.readFileSync(configPath, "utf-8"))?.mangleClassNames === true;
+		} catch {
+			return false;
+		}
+	}
+	/**
 	* Write a temporary config file ({ content }) at <cwd>/<prefix>.<random8hex>.tmp.json,
 	* invoke `fn` with the temp file path, and always clean the file up afterwards.
 	*
@@ -104,14 +124,14 @@ var import_runner = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 	* @param {(tempConfigPath: string) => any} fn
 	* @returns {any} whatever `fn` returns
 	*/
-	function withTempConfig({ cwd, content, prefix, fs: fs$4 = require("fs") }, fn) {
+	function withTempConfig({ cwd, content, prefix, fs: fs$5 = require("fs") }, fn) {
 		const tmpName = `${prefix}.${crypto$1.randomBytes(8).toString("hex")}.tmp.json`;
 		const tempConfigPath = path$2.join(cwd, tmpName);
-		fs$4.writeFileSync(tempConfigPath, JSON.stringify({ content }), { flag: "wx" });
+		fs$5.writeFileSync(tempConfigPath, JSON.stringify({ content }), { flag: "wx" });
 		try {
 			return fn(tempConfigPath);
 		} finally {
-			if (fs$4.existsSync(tempConfigPath)) fs$4.unlinkSync(tempConfigPath);
+			if (fs$5.existsSync(tempConfigPath)) fs$5.unlinkSync(tempConfigPath);
 		}
 	}
 	/**
@@ -123,25 +143,1023 @@ var import_runner = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 	* @param {string} [options.output]         output path (required for 'output' mode)
 	* @param {boolean} [options.cssLayers]     append --css-layers when truthy
 	* @param {boolean} [options.watch]         append --watch when truthy
+	* @param {boolean} [options.mangleClassNames] explicitly enable or disable mangling
+	* @param {string} [options.mangleMap]      class-name manifest output path
+	* @param {string[]} [options.mangleExclude] class names to preserve
 	* @param {string|null} [options.configPath] append --config <path> when present
 	* @returns {string[]}
 	*/
-	function buildArgs({ mode, output, cssLayers, configPath, watch }) {
+	function buildArgs({ mode, output, cssLayers, configPath, watch, mangleClassNames, mangleMap, mangleExclude }) {
 		const args = ["build"];
 		if (watch) args.push("--watch");
 		if (mode === "stdout") args.push("--stdout");
 		else args.push("-o", output);
 		if (cssLayers) args.push("--css-layers");
+		if (mangleClassNames !== void 0) args.push(`--mangle-class-names=${mangleClassNames}`);
+		if (mangleMap) args.push("--mangle-map", mangleMap);
+		if (mangleExclude?.length) args.push("--mangle-exclude", mangleExclude.join(","));
 		if (configPath) args.push("--config", configPath);
 		return args;
 	}
 	module.exports = {
 		resolveBinary,
 		resolveConfig,
+		configEnablesMangling,
 		withTempConfig,
 		buildArgs
 	};
 })))(), 1);
+const SUPPORTED_SOURCE = /\.(?:[cm]?[jt]sx?|html)(?:$|\?)/;
+const HTML_SOURCE = /\.html(?:$|\?)/;
+const UNSUPPORTED_FRAMEWORK_SOURCE = /\.(?:vue|svelte)(?:$|\?)/;
+const DEPENDENCY_SOURCE = /(?:^|[\\/])node_modules[\\/]/;
+function hasOwn(classes, token) {
+	return Object.hasOwn(classes, token);
+}
+function collectClassListEdits(value, classes, baseOffset, edits) {
+	for (const match of value.matchAll(/\S+/g)) {
+		const replacement = classes[match[0]];
+		if (hasOwn(classes, match[0]) && replacement !== match[0]) edits.push({
+			start: baseOffset + match.index,
+			end: baseOffset + match.index + match[0].length,
+			replacement
+		});
+	}
+}
+function maskRange(chars, code, start, end) {
+	for (let index = start; index < end; index += 1) if (code[index] !== "\n" && code[index] !== "\r") chars[index] = " ";
+}
+function copyRange(chars, code, start, end) {
+	for (let index = start; index < end; index += 1) chars[index] = code[index];
+}
+function findHtmlTagEnd(code, start) {
+	let quote = null;
+	for (let index = start + 1; index < code.length; index += 1) {
+		const char = code[index];
+		if (quote !== null) {
+			if (char === quote) quote = null;
+		} else if (char === "\"" || char === "'") quote = char;
+		else if (char === ">") return index + 1;
+	}
+	return -1;
+}
+function findRawTextClosing(code, tagName, start) {
+	const lower = code.toLowerCase();
+	const needle = `</${tagName}`;
+	let index = lower.indexOf(needle, start);
+	while (index >= 0) {
+		const after = lower[index + needle.length];
+		if (after === void 0 || /[\s>]/.test(after)) return index;
+		index = lower.indexOf(needle, index + 1);
+	}
+	return -1;
+}
+function analyzeHtml(code, id) {
+	const markup = new Array(code.length).fill(" ");
+	const scriptRanges = [];
+	const commentRanges = [];
+	const exampleStack = [];
+	let index = 0;
+	while (index < code.length) {
+		const open = code.indexOf("<", index);
+		if (open < 0) break;
+		if (code.startsWith("<!--", open)) {
+			const commentEnd = code.indexOf("-->", open + 4);
+			const end = commentEnd < 0 ? code.length : commentEnd + 3;
+			commentRanges.push({
+				start: open,
+				end
+			});
+			index = end;
+			continue;
+		}
+		const tagEnd = findHtmlTagEnd(code, open);
+		if (tagEnd < 0) break;
+		const tag = code.slice(open, tagEnd);
+		const closingMatch = tag.match(/^<\s*\/\s*([A-Za-z][\w:-]*)/);
+		const openingMatch = closingMatch ? null : tag.match(/^<\s*([A-Za-z][\w:-]*)/);
+		const tagName = (closingMatch?.[1] ?? openingMatch?.[1] ?? "").toLowerCase();
+		if (!tagName) {
+			index = tagEnd;
+			continue;
+		}
+		const isClosing = closingMatch !== null;
+		const selfClosing = !isClosing && /\/\s*>$/.test(tag);
+		const isExampleTag = tagName === "code" || tagName === "pre";
+		if (exampleStack.length === 0 || isExampleTag) copyRange(markup, code, open, tagEnd);
+		if (isClosing && isExampleTag) {
+			if (exampleStack.at(-1) !== tagName) throw new Error(`[gustcss] mismatched </${tagName}> in ${id}`);
+			exampleStack.pop();
+		} else if (!isClosing && isExampleTag && !selfClosing) exampleStack.push(tagName);
+		if (!isClosing && !selfClosing && exampleStack.length === 0 && (tagName === "script" || tagName === "style")) {
+			const rawEnd = findRawTextClosing(code, tagName, tagEnd);
+			const contentEnd = rawEnd < 0 ? code.length : rawEnd;
+			if (tagName === "script") scriptRanges.push({
+				start: tagEnd,
+				end: contentEnd
+			});
+			index = contentEnd;
+			continue;
+		}
+		index = tagEnd;
+	}
+	if (exampleStack.length > 0) throw new Error(`[gustcss] unclosed <${exampleStack.at(-1)}> in ${id}`);
+	return {
+		markup: markup.join(""),
+		scriptRanges,
+		commentRanges
+	};
+}
+function canStartRegex(code, index, previous) {
+	if (previous === void 0 || /[({[,:;=!?&|+\-*%^~<>]/.test(previous)) return true;
+	return /\b(?:return|throw|case|delete|void|typeof|instanceof|in|of|yield|await)\s*$/.test(code.slice(Math.max(0, index - 24), index));
+}
+function isJsxAttributeAt(structure, index) {
+	const before = structure.slice(0, index);
+	const open = before.lastIndexOf("<");
+	if (open < 0 || open < before.lastIndexOf(">")) return false;
+	return /^<\s*[A-Za-z][\w.$:-]*(?:\s|$)/.test(before.slice(open));
+}
+function createJsMasks(code) {
+	const structure = code.split("");
+	const inspection = code.split("");
+	let index = 0;
+	let previousSignificant;
+	while (index < code.length) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (char === "/" && next === "/") {
+			const end = code.indexOf("\n", index + 2);
+			const stop = end < 0 ? code.length : end;
+			maskRange(structure, code, index, stop);
+			maskRange(inspection, code, index, stop);
+			index = stop;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			const end = code.indexOf("*/", index + 2);
+			const stop = end < 0 ? code.length : end + 2;
+			maskRange(structure, code, index, stop);
+			maskRange(inspection, code, index, stop);
+			index = stop;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			const quote = char;
+			const start = index;
+			index += 1;
+			let escaped = false;
+			while (index < code.length) {
+				const current = code[index];
+				if (escaped) escaped = false;
+				else if (current === "\\") escaped = true;
+				else if (current === quote) {
+					index += 1;
+					break;
+				}
+				index += 1;
+			}
+			maskRange(structure, code, start, index);
+			previousSignificant = quote;
+			continue;
+		}
+		if (char === "/" && canStartRegex(code, index, previousSignificant)) {
+			const start = index;
+			index += 1;
+			let escaped = false;
+			let characterClass = false;
+			while (index < code.length) {
+				const current = code[index];
+				if (escaped) escaped = false;
+				else if (current === "\\") escaped = true;
+				else if (current === "[") characterClass = true;
+				else if (current === "]") characterClass = false;
+				else if (current === "/" && !characterClass) {
+					index += 1;
+					while (/[A-Za-z]/.test(code[index] ?? "")) index += 1;
+					break;
+				} else if (current === "\n" || current === "\r") break;
+				index += 1;
+			}
+			maskRange(structure, code, start, index);
+			maskRange(inspection, code, start, index);
+			previousSignificant = "/";
+			continue;
+		}
+		if (!/\s/.test(char)) previousSignificant = char;
+		index += 1;
+	}
+	return {
+		structure: structure.join(""),
+		inspection: inspection.join("")
+	};
+}
+const classNameTrieCache = /* @__PURE__ */ new WeakMap();
+function classNameTrie(classes) {
+	let root = classNameTrieCache.get(classes);
+	if (root) return root;
+	root = /* @__PURE__ */ new Map();
+	for (const className of Object.keys(classes)) {
+		let node = root;
+		for (const char of className) {
+			if (!node.has(char)) node.set(char, /* @__PURE__ */ new Map());
+			node = node.get(char);
+		}
+		node.className = className;
+	}
+	classNameTrieCache.set(classes, root);
+	return root;
+}
+function isBeforeBoundary(char) {
+	return char === void 0 || !/[A-Za-z0-9_@:/-]/.test(char);
+}
+function isAfterBoundary(char, before, beforeBefore) {
+	if (char === void 0 || char === ":") return true;
+	if (char === ".") return before === "." && (beforeBefore === void 0 || !/[A-Za-z0-9_/\\.]/.test(beforeBefore));
+	return !/[A-Za-z0-9_@/-]/.test(char);
+}
+function findMappedToken(value, classes) {
+	const trie = classNameTrie(classes);
+	let found = null;
+	for (let start = 0; start < value.length; start += 1) {
+		const before = start === 0 ? void 0 : value[start - 1];
+		if (!isBeforeBoundary(before)) continue;
+		const beforeBefore = start < 2 ? void 0 : value[start - 2];
+		let node = trie;
+		for (let end = start; end < value.length; end += 1) {
+			node = node.get(value[end]);
+			if (!node) break;
+			if (!node.className) continue;
+			const afterIndex = end + 1;
+			if (!isAfterBoundary(afterIndex === value.length ? void 0 : value[afterIndex], before, beforeBefore)) continue;
+			if (found === null || node.className.length > found.length || node.className.length === found.length && node.className.localeCompare(found) < 0) found = node.className;
+		}
+	}
+	return found;
+}
+function scanQuotedSegments(value, visitor) {
+	let index = 0;
+	while (index < value.length) {
+		const quote = value[index];
+		if (quote !== "\"" && quote !== "'" && quote !== "`") {
+			index += 1;
+			continue;
+		}
+		const start = index;
+		index += 1;
+		let escaped = false;
+		while (index < value.length) {
+			const char = value[index];
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) {
+				index += 1;
+				visitor({
+					start,
+					end: index,
+					quote,
+					contents: value.slice(start + 1, index - 1)
+				});
+				break;
+			}
+			index += 1;
+		}
+	}
+}
+function findMappedInQuotedSegments(value, classes) {
+	let found = null;
+	scanQuotedSegments(value, ({ contents }) => {
+		if (found === null) found = findMappedToken(contents, classes);
+	});
+	return found;
+}
+function stripQuotedSegments(value) {
+	let output = "";
+	let cursor = 0;
+	scanQuotedSegments(value, ({ start, end }) => {
+		output += value.slice(cursor, start);
+		output += " ".repeat(end - start);
+		cursor = end;
+	});
+	return output + value.slice(cursor);
+}
+function collectTemplateBodyEdits(body, classes, baseOffset, edits) {
+	let staticStart = 0;
+	let index = 0;
+	while (index < body.length) {
+		if (body[index] !== "$" || body[index + 1] !== "{") {
+			index += 1;
+			continue;
+		}
+		collectClassListEdits(body.slice(staticStart, index), classes, baseOffset + staticStart, edits);
+		index += 2;
+		let depth = 1;
+		let quote = null;
+		let escaped = false;
+		while (index < body.length && depth > 0) {
+			const char = body[index];
+			if (quote !== null) {
+				if (escaped) escaped = false;
+				else if (char === "\\") escaped = true;
+				else if (char === quote) quote = null;
+			} else if (char === "\"" || char === "'" || char === "`") quote = char;
+			else if (char === "{") depth += 1;
+			else if (char === "}") depth -= 1;
+			index += 1;
+		}
+		staticStart = index;
+	}
+	collectClassListEdits(body.slice(staticStart), classes, baseOffset + staticStart, edits);
+}
+function findBalancedEnd(code, open, opening, closing) {
+	let index = open + 1;
+	let depth = 1;
+	let quote = null;
+	let escaped = false;
+	while (index < code.length && depth > 0) {
+		const char = code[index];
+		if (quote !== null) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) quote = null;
+		} else if (char === "\"" || char === "'" || char === "`") quote = char;
+		else if (char === opening) depth += 1;
+		else if (char === closing) depth -= 1;
+		index += 1;
+	}
+	return depth === 0 ? index : -1;
+}
+function rejectAmbiguousClassExpressions(code, structure, classes, id) {
+	const pattern = /(?<![:\w-])class(?:Name)?\s*=\s*\{/g;
+	let match;
+	while ((match = pattern.exec(structure)) !== null) {
+		const open = code.indexOf("{", match.index);
+		const end = findBalancedEnd(code, open, "{", "}");
+		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;
+	}
+}
+function collectClassListCallEdits(code, structure, classes, id, edits) {
+	const pattern = /\.classList\.(?:add|remove|toggle|contains|replace)\s*\(/g;
+	let match;
+	while ((match = pattern.exec(structure)) !== null) {
+		const open = code.indexOf("(", match.index);
+		const end = findBalancedEnd(code, open, "(", ")");
+		if (end < 0) break;
+		const args = code.slice(open + 1, end - 1);
+		const withoutStrings = stripQuotedSegments(args);
+		const dynamic = findMappedToken(withoutStrings, classes);
+		if (dynamic) throw new Error(`[gustcss] mapped class "${dynamic}" remains in a dynamic classList argument in ${id}. Pass it as a direct string argument, or add it to mangleExclude.`);
+		if (withoutStrings.includes("(")) {
+			const ambiguous = findMappedInQuotedSegments(args, classes);
+			if (ambiguous) throw new Error(`[gustcss] mapped class "${ambiguous}" is nested in a classList call in ${id}. Pass it as a direct string argument, or add it to mangleExclude.`);
+		}
+		scanQuotedSegments(args, ({ start, contents }) => {
+			collectClassListEdits(contents, classes, open + 1 + start + 1, edits);
+		});
+		pattern.lastIndex = end;
+	}
+}
+function rejectDynamicSetAttributeCalls(code, structure, classes, id) {
+	const pattern = /\.setAttribute\s*\(/g;
+	let match;
+	while ((match = pattern.exec(structure)) !== null) {
+		const open = code.indexOf("(", match.index);
+		const end = findBalancedEnd(code, open, "(", ")");
+		if (end < 0) break;
+		const args = code.slice(open + 1, end - 1);
+		if (!/^\s*(["'])class\1\s*,/.test(args)) {
+			pattern.lastIndex = end;
+			continue;
+		}
+		const withoutStrings = stripQuotedSegments(args);
+		const dynamic = findMappedToken(withoutStrings, classes);
+		const nested = withoutStrings.includes("(") ? findMappedInQuotedSegments(args, classes) : null;
+		const ambiguous = dynamic ?? nested;
+		if (ambiguous) throw new Error(`[gustcss] mapped class "${ambiguous}" remains in a dynamic setAttribute in ${id}. Pass a direct class string, or add it to mangleExclude.`);
+		pattern.lastIndex = end;
+	}
+}
+function rejectDynamicClassNameAssignments(code, structure, classes, id) {
+	const pattern = /\.className\s*=(?!=)\s*/g;
+	while (pattern.exec(structure) !== null) {
+		const start = pattern.lastIndex;
+		const candidates = [code.indexOf(";", start), code.indexOf("\n", start)].filter((index) => index >= 0);
+		const end = candidates.length > 0 ? Math.min(...candidates) : code.length;
+		const ambiguous = findMappedToken(code.slice(start, end), classes);
+		if (ambiguous) throw new Error(`[gustcss] mapped class "${ambiguous}" remains in a dynamic className assignment in ${id}. Assign a direct class string, or add it to mangleExclude.`);
+		pattern.lastIndex = end;
+	}
+}
+function applyEdits(code, edits) {
+	const sorted = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+	let output = "";
+	let cursor = 0;
+	const origins = [];
+	for (const edit of sorted) {
+		if (edit.start < cursor) throw new Error("[gustcss] overlapping class-name rewrites");
+		output += code.slice(cursor, edit.start);
+		for (let index = cursor; index < edit.start; index += 1) origins.push(index);
+		const sourceLength = Math.max(1, edit.end - edit.start);
+		if (edit.replacement.length > sourceLength) throw new Error("[gustcss] class-name replacement must not exceed its source length");
+		output += edit.replacement;
+		for (let index = 0; index < edit.replacement.length; index += 1) origins.push(edit.start + Math.min(index, sourceLength - 1));
+		cursor = edit.end;
+	}
+	output += code.slice(cursor);
+	for (let index = cursor; index < code.length; index += 1) origins.push(index);
+	return {
+		code: output,
+		origins
+	};
+}
+function sourcesForFile(code, id) {
+	if (!HTML_SOURCE.test(id)) {
+		const js = createJsMasks(code);
+		return {
+			attributes: code,
+			structure: js.structure,
+			inspection: js.inspection
+		};
+	}
+	const html = analyzeHtml(code, id);
+	const structure = new Array(code.length).fill(" ");
+	const inspection = new Array(code.length).fill(" ");
+	for (const range of html.scriptRanges) {
+		const script = code.slice(range.start, range.end);
+		const jsScript = createJsMasks(script);
+		for (let offset = 0; offset < script.length; offset += 1) {
+			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 collectEdits(code, classes, id) {
+	const edits = [];
+	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);
+	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 edits;
+}
+function collectRecognizedContextEdits(code, classes, id) {
+	return applyEdits(code, collectEdits(code, classes, id));
+}
+/**
+* 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 edits = collectEdits(code, classes, id);
+	const rewritten = applyEdits(code, edits).code;
+	const sources = sourcesForFile(rewritten, id);
+	rejectDynamicSetAttributeCalls(rewritten, sources.structure, classes, id);
+	rejectDynamicClassNameAssignments(rewritten, sources.structure, classes, id);
+	rejectAmbiguousClassExpressions(rewritten, sources.structure, classes, id);
+	const ambiguous = findMappedInQuotedSegments(sources.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 edits;
+}
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeVLQ(value) {
+	let encoded = "";
+	let vlq = Math.abs(value) * 2 + (value < 0 ? 1 : 0);
+	do {
+		let digit = vlq % 32;
+		vlq = Math.floor(vlq / 32);
+		if (vlq > 0) digit += 32;
+		encoded += BASE64[digit];
+	} while (vlq > 0);
+	return encoded;
+}
+function createSourceMap(original, generated, origins, id) {
+	const originalPositions = new Array(original.length);
+	let originalLine = 0;
+	let originalColumn = 0;
+	for (let index = 0; index < original.length; index += 1) {
+		originalPositions[index] = {
+			line: originalLine,
+			column: originalColumn
+		};
+		if (original[index] === "\n") {
+			originalLine += 1;
+			originalColumn = 0;
+		} else originalColumn += 1;
+	}
+	const lines = [""];
+	let generatedLine = 0;
+	let generatedColumn = 0;
+	let previousGeneratedColumn = 0;
+	let previousSource = 0;
+	let previousOriginalLine = 0;
+	let previousOriginalColumn = 0;
+	for (let index = 0; index < generated.length; index += 1) {
+		if (generated[index] === "\n") {
+			generatedLine += 1;
+			generatedColumn = 0;
+			previousGeneratedColumn = 0;
+			lines.push("");
+			continue;
+		}
+		const originalPosition = originalPositions[origins[index]];
+		if (!originalPosition) {
+			generatedColumn += 1;
+			continue;
+		}
+		const segment = encodeVLQ(generatedColumn - previousGeneratedColumn) + encodeVLQ(0 - previousSource) + encodeVLQ(originalPosition.line - previousOriginalLine) + encodeVLQ(originalPosition.column - previousOriginalColumn);
+		lines[generatedLine] += `${lines[generatedLine] ? "," : ""}${segment}`;
+		previousGeneratedColumn = generatedColumn;
+		previousSource = 0;
+		previousOriginalLine = originalPosition.line;
+		previousOriginalColumn = originalPosition.column;
+		generatedColumn += 1;
+	}
+	return {
+		version: 3,
+		sources: [id],
+		sourcesContent: [original],
+		names: [],
+		mappings: lines.join(";")
+	};
+}
+function transformSource(code, classes, id) {
+	const transformed = collectRecognizedContextEdits(code, classes, id);
+	const rewritten = transformed.code;
+	const sources = sourcesForFile(rewritten, id);
+	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
+	};
+}
+function findAmbiguousMappedClass(code, classes) {
+	return findMappedInQuotedSegments(code, classes);
+}
+/**
+* Create a fail-closed source transformer for a GustCSS class manifest.
+* Only unambiguous class-name contexts are rewritten automatically.
+*/
+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 or Svelte templates yet (${id}). Add "${referenced}" to mangleExclude or disable mangleClassNames.`);
+			return {
+				code,
+				map: null
+			};
+		}
+		if (DEPENDENCY_SOURCE.test(id) || !SUPPORTED_SOURCE.test(id)) return {
+			code,
+			map: null
+		};
+		const result = transformSource(code, classes, id);
+		const ambiguous = findAmbiguousMappedClass(result.inspection, classes, id);
+		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 {
+			code: result.code,
+			map: result.map
+		};
+	};
+	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
 *
@@ -155,12 +1173,38 @@ var import_runner = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exp
 * 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 ASTRO_MODULE = /^[^\0?]*\.astro$/;
+/**
+* Resolve @astrojs/compiler parse function from the project.
+*/
+async function resolveAstroCompiler(root) {
+	const projectRequire = (0, node_module.createRequire)(path.default.join(root, "package.json"));
+	const attempts = [
+		() => projectRequire.resolve("@astrojs/compiler"),
+		() => (0, node_module.createRequire)(projectRequire.resolve("astro/package.json")).resolve("@astrojs/compiler"),
+		() => (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve("@astrojs/compiler")
+	];
+	for (const attempt of attempts) try {
+		const mod = await import((0, node_url.pathToFileURL)(attempt()).href);
+		if (typeof mod.parse === "function") return mod.parse;
+	} catch {}
+	return 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 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,
@@ -174,14 +1218,21 @@ function cssUtility(opts = {}) {
 			fs: fs.default
 		});
 	}
-	function buildCSS(cwd, binaryPath) {
+	function buildCSS(cwd, binaryPath, enableMangle) {
 		const resolvedConfigPath = findConfigFile(cwd);
 		const run = (cfgPath) => {
+			const disableConfigMangle = !enableMangle && import_runner.default.configEnablesMangling({
+				configPath: cfgPath,
+				fs: fs.default
+			});
 			const args = import_runner.default.buildArgs({
 				mode: "output",
 				output,
 				cssLayers: outputToCssLayers,
-				configPath: cfgPath
+				configPath: cfgPath,
+				mangleClassNames: enableMangle ? true : disableConfigMangle ? false : void 0,
+				mangleMap: enableMangle ? mangleMap : void 0,
+				mangleExclude: enableMangle ? mangleExclude : void 0
 			});
 			try {
 				const result = (0, child_process.spawnSync)(binaryPath, args, {
@@ -195,6 +1246,24 @@ function cssUtility(opts = {}) {
 				});
 				if (result.status !== 0) throw new Error(`gustcss build failed: ${result.stderr}`);
 				if (result.stderr) process.stderr.write(result.stderr);
+				if (enableMangle) {
+					const manifestPath = path.default.resolve(cwd, mangleMap);
+					const manifestText = fs.default.readFileSync(manifestPath, "utf-8");
+					const manifest = JSON.parse(manifestText);
+					const classes = manifest?.classes;
+					const entries = classes && !Array.isArray(classes) ? Object.entries(classes) : [];
+					const shortNames = entries.map(([, short]) => short);
+					const validEntries = entries.every(([original, short]) => original.length > 0 && typeof short === "string" && /^[A-Za-z]+$/.test(short));
+					if (manifest?.version !== 1 || !classes || Array.isArray(classes) || !validEntries || new Set(shortNames).size !== shortNames.length) throw new Error(`invalid class-name manifest: ${manifestPath}`);
+					classNameTransformer = createClassNameTransformer(manifest.classes);
+					manifestSnapshot = {
+						path: manifestPath,
+						text: manifestText
+					};
+				} else {
+					classNameTransformer = null;
+					manifestSnapshot = null;
+				}
 			} catch (error) {
 				throw new Error(`gustcss build failed: ${error.message}`);
 			}
@@ -207,25 +1276,66 @@ function cssUtility(opts = {}) {
 			fs: fs.default
 		}, (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 {
-				buildCSS(cwd, binaryPath);
+				const enableMangle = mangleClassNames && config.command === "build";
+				buildCSS(cwd, binaryPath, enableMangle);
+				loadedAstroModules.clear();
+				astroTransformer = null;
+				rollbackContext = enableMangle ? {
+					cwd,
+					binaryPath
+				} : null;
 			} catch (error) {
 				console.error(`[gustcss] Failed to build CSS: ${error.message}`);
 				throw error;
 			}
 		},
+		async load(id) {
+			if (!classNameTransformer || !ASTRO_MODULE.test(id)) return null;
+			const filePath = id.startsWith("/@fs/") ? id.slice(4) : id;
+			if (!fs.default.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.default.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;
+		},
+		transformIndexHtml(html, context) {
+			if (!classNameTransformer) return html;
+			return classNameTransformer(html, context?.filename || "index.html");
+		},
 		configureServer(server) {
 			const cwd = server.config.root || process.cwd();
 			const binaryPath = findBinary(cwd);
 			const resolvedConfigPath = findConfigFile(cwd);
 			const outputPath = path.default.resolve(cwd, output);
 			try {
-				buildCSS(cwd, binaryPath);
+				buildCSS(cwd, binaryPath, false);
 			} catch (error) {
 				console.error(`[gustcss] Failed to build CSS: ${error.message}`);
 			}
@@ -237,13 +1347,18 @@ function cssUtility(opts = {}) {
 				fs.default.writeFileSync(tempConfigPath, JSON.stringify({ content }), { flag: "wx" });
 				watchConfigPath = tempConfigPath;
 			}
-			watchProcess = (0, child_process.spawn)(binaryPath, import_runner.default.buildArgs({
+			const watchArgs = import_runner.default.buildArgs({
 				mode: "output",
 				output,
 				cssLayers: outputToCssLayers,
 				configPath: watchConfigPath,
-				watch: true
-			}), {
+				watch: true,
+				mangleClassNames: import_runner.default.configEnablesMangling({
+					configPath: watchConfigPath,
+					fs: fs.default
+				}) ? false : void 0
+			});
+			watchProcess = (0, child_process.spawn)(binaryPath, watchArgs, {
 				cwd,
 				stdio: [
 					"pipe",
@@ -273,15 +1388,39 @@ function cssUtility(opts = {}) {
 				}
 				if (tempConfigPath && fs.default.existsSync(tempConfigPath)) fs.default.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.default.existsSync(manifestSnapshot.path)) return;
+			fs.default.mkdirSync(path.default.dirname(manifestSnapshot.path), { recursive: true });
+			fs.default.writeFileSync(manifestSnapshot.path, manifestSnapshot.text);
 		},
-		buildEnd() {
+		buildEnd(error) {
 			if (watchProcess) {
 				watchProcess.kill();
 				watchProcess = null;
 			}
+			if (error && rollbackContext) {
+				const { cwd, binaryPath } = rollbackContext;
+				rollbackContext = null;
+				classNameTransformer = null;
+				manifestSnapshot = null;
+				try {
+					buildCSS(cwd, binaryPath, false);
+					const manifestPath = path.default.resolve(cwd, mangleMap);
+					if (fs.default.existsSync(manifestPath)) fs.default.unlinkSync(manifestPath);
+				} catch (rollbackError) {
+					console.error(`[gustcss] Failed to restore readable CSS: ${rollbackError.message}`);
+				}
+			} else rollbackContext = null;
 		}
 	};
 }