@gustcss/vite 0.9.1 → 0.10.0

package/dist/index.mjs

@@ -21,13 +21,13 @@ 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));
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.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
@@ -87,6 +87,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 = __require("fs") }) {
+		if (!configPath) return false;
+		try {
+			return JSON.parse(fs.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.
 	*
@@ -118,25 +136,590 @@ 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|astro|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 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);
+			index = commentEnd < 0 ? code.length : commentEnd + 3;
+			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
+	};
+}
+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) break;
+		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 js = 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];
+		}
+	}
+	return {
+		attributes: html.markup,
+		structure: structure.join(""),
+		inspection: inspection.join("")
+	};
+}
+function collectRecognizedContextEdits(code, classes, id) {
+	const edits = [];
+	const sources = sourcesForFile(code, id);
+	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 (!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 (!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 applyEdits(code, 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, Astro, 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;
+	return transform;
+}
+//#endregion
+//#region src/index.js
 /**
 * @gustcss/vite - Vite plugin for CSS Utility Generator
 *
@@ -155,6 +738,12 @@ function cssUtility(opts = {}) {
 	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;
 	function findBinary(cwd) {
 		return import_runner.default.resolveBinary({
@@ -169,14 +758,21 @@ function cssUtility(opts = {}) {
 			fs
 		});
 	}
-	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
+			});
 			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 = spawnSync(binaryPath, args, {
@@ -190,6 +786,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.resolve(cwd, mangleMap);
+					const manifestText = fs.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}`);
 			}
@@ -204,23 +818,38 @@ function cssUtility(opts = {}) {
 	}
 	return {
 		name: "gustcss",
+		...mangleClassNames ? { enforce: "pre" } : {},
 		configResolved(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);
+				rollbackContext = enableMangle ? {
+					cwd,
+					binaryPath
+				} : null;
 			} catch (error) {
 				console.error(`[gustcss] Failed to build CSS: ${error.message}`);
 				throw error;
 			}
 		},
+		transform(code, id) {
+			if (!classNameTransformer) 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.resolve(cwd, output);
 			try {
-				buildCSS(cwd, binaryPath);
+				buildCSS(cwd, binaryPath, false);
 			} catch (error) {
 				console.error(`[gustcss] Failed to build CSS: ${error.message}`);
 			}
@@ -232,13 +861,18 @@ function cssUtility(opts = {}) {
 				fs.writeFileSync(tempConfigPath, JSON.stringify({ content }), { flag: "wx" });
 				watchConfigPath = tempConfigPath;
 			}
-			watchProcess = 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
+				}) ? false : void 0
+			});
+			watchProcess = spawn(binaryPath, watchArgs, {
 				cwd,
 				stdio: [
 					"pipe",
@@ -272,11 +906,29 @@ function cssUtility(opts = {}) {
 			process.once("SIGINT", cleanup);
 			process.once("SIGTERM", cleanup);
 		},
-		buildEnd() {
+		writeBundle() {
+			if (!manifestSnapshot || fs.existsSync(manifestSnapshot.path)) return;
+			fs.mkdirSync(path.dirname(manifestSnapshot.path), { recursive: true });
+			fs.writeFileSync(manifestSnapshot.path, manifestSnapshot.text);
+		},
+		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.resolve(cwd, mangleMap);
+					if (fs.existsSync(manifestPath)) fs.unlinkSync(manifestPath);
+				} catch (rollbackError) {
+					console.error(`[gustcss] Failed to restore readable CSS: ${rollbackError.message}`);
+				}
+			} else rollbackContext = null;
 		}
 	};
 }