@luna_ui/luna 0.3.3 → 0.3.5

package/dist/cli.mjs

@@ -1,24 +1,906 @@
 #!/usr/bin/env node
-import * as fs from "node:fs";
-import * as path from "node:path";
+import * as fs$1 from "node:fs";
+import * as path$1 from "node:path";
 import { fileURLToPath } from "node:url";
+import fs from "fs";
+import path from "path";
 
+//#region src/css/extract.ts
+/**
+* Static CSS Extractor for Luna CSS Module
+*
+* Extracts all CSS declarations from .mbt files at build time.
+* This ensures all styles are collected regardless of runtime branches.
+*/
+const CSS_PATTERN = /\bcss\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const STYLES_PATTERN = /\bstyles\s*\(\s*\[([\s\S]*?)\]\s*\)/g;
+const STYLES_PAIR_PATTERN = /\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const HOVER_PATTERN = /\bhover\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const FOCUS_PATTERN = /\bfocus\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const ACTIVE_PATTERN = /\bactive\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const ON_PATTERN = /\bon\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const MEDIA_PATTERN = /\bmedia\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const AT_SM_PATTERN = /\bat_sm\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const AT_MD_PATTERN = /\bat_md\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const AT_LG_PATTERN = /\bat_lg\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const AT_XL_PATTERN = /\bat_xl\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const DARK_PATTERN = /\bdark\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const UCSS_PATTERN = /\bucss\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const USTYLES_PATTERN = /\bustyles\s*\(\s*\[([\s\S]*?)\]\s*\)/g;
+const UHOVER_PATTERN = /\buhover\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const UFOCUS_PATTERN = /\bufocus\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const UACTIVE_PATTERN = /\buactive\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const UON_PATTERN = /\buon\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const UAT_MD_PATTERN = /\buat_md\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const UAT_LG_PATTERN = /\buat_lg\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const UDARK_PATTERN = /\budark\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const ARG_PATTERN = `(?:"(?:[^"\\\\]|\\\\.)*"|[^,)]+)`;
+const WARN_PATTERNS = [
+	{
+		name: "css",
+		pattern: new RegExp(`\\b(u?css)\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2
+	},
+	{
+		name: "hover",
+		pattern: new RegExp(`\\b(u?hover)\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2
+	},
+	{
+		name: "focus",
+		pattern: new RegExp(`\\b(u?focus)\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2
+	},
+	{
+		name: "active",
+		pattern: new RegExp(`\\b(u?active)\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2
+	},
+	{
+		name: "at_sm",
+		pattern: new RegExp(`\\bat_sm\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2,
+		noPrefix: true
+	},
+	{
+		name: "at_md",
+		pattern: new RegExp(`\\b(u?at_md)\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2
+	},
+	{
+		name: "at_lg",
+		pattern: new RegExp(`\\b(u?at_lg)\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2
+	},
+	{
+		name: "at_xl",
+		pattern: new RegExp(`\\bat_xl\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2,
+		noPrefix: true
+	},
+	{
+		name: "dark",
+		pattern: new RegExp(`\\b(u?dark)\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 2
+	},
+	{
+		name: "on",
+		pattern: new RegExp(`\\b(u?on)\\s*\\(\\s*"(::?[^"]+)"\\s*,\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 3,
+		pseudoInMatch: true
+	},
+	{
+		name: "media",
+		pattern: new RegExp(`\\bmedia\\s*\\(\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*,\\s*(${ARG_PATTERN})\\s*\\)`, "g"),
+		args: 3,
+		noPrefix: true
+	}
+];
+function isStringLiteral(str) {
+	const trimmed = str.trim();
+	return trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'");
+}
+function isFunctionDefinition(code) {
+	return /:\s*String/.test(code);
+}
+function getLineNumber(content, position) {
+	return content.substring(0, position).split("\n").length;
+}
+function detectWarnings(content, filePath) {
+	const warnings = [];
+	for (const { name, pattern, args, noPrefix, pseudoInMatch } of WARN_PATTERNS) {
+		pattern.lastIndex = 0;
+		for (const match of content.matchAll(pattern)) {
+			const fullMatch = match[0];
+			const position = match.index;
+			const line = getLineNumber(content, position);
+			if (isFunctionDefinition(fullMatch)) continue;
+			const extractedArgs = [];
+			if (args === 2) {
+				const startIdx = noPrefix ? 1 : 2;
+				extractedArgs.push(match[startIdx], match[startIdx + 1]);
+			} else if (args === 3) if (pseudoInMatch) extractedArgs.push(match[3], match[4]);
+			else {
+				const startIdx = noPrefix ? 1 : 2;
+				extractedArgs.push(match[startIdx], match[startIdx + 1], match[startIdx + 2]);
+			}
+			for (let i = 0; i < extractedArgs.length; i++) {
+				const arg = extractedArgs[i];
+				if (arg && !isStringLiteral(arg)) {
+					const argNum = pseudoInMatch ? i + 2 : i + 1;
+					warnings.push({
+						file: filePath,
+						line,
+						func: name,
+						code: fullMatch.trim(),
+						reason: `Argument ${argNum} is not a string literal: ${arg.trim()}`
+					});
+					break;
+				}
+			}
+		}
+	}
+	return warnings;
+}
+function extractFromContent(content) {
+	const base = /* @__PURE__ */ new Set();
+	const pseudo = [];
+	const media = [];
+	function extractBase(pattern) {
+		for (const match of content.matchAll(pattern)) base.add(`${match[1]}:${match[2]}`);
+	}
+	function extractStyles(pattern) {
+		for (const match of content.matchAll(pattern)) {
+			const pairs = match[1];
+			for (const pair of pairs.matchAll(STYLES_PAIR_PATTERN)) base.add(`${pair[1]}:${pair[2]}`);
+		}
+	}
+	function extractPseudo(pattern, pseudoSelector) {
+		for (const match of content.matchAll(pattern)) pseudo.push({
+			pseudo: pseudoSelector,
+			property: match[1],
+			value: match[2]
+		});
+	}
+	function extractOn(pattern) {
+		for (const match of content.matchAll(pattern)) pseudo.push({
+			pseudo: match[1],
+			property: match[2],
+			value: match[3]
+		});
+	}
+	function extractMedia(pattern, condition = null) {
+		for (const match of content.matchAll(pattern)) if (condition) media.push({
+			condition,
+			property: match[1],
+			value: match[2]
+		});
+		else media.push({
+			condition: match[1],
+			property: match[2],
+			value: match[3]
+		});
+	}
+	extractBase(CSS_PATTERN);
+	extractBase(UCSS_PATTERN);
+	extractStyles(STYLES_PATTERN);
+	extractStyles(USTYLES_PATTERN);
+	extractPseudo(HOVER_PATTERN, ":hover");
+	extractPseudo(UHOVER_PATTERN, ":hover");
+	extractPseudo(FOCUS_PATTERN, ":focus");
+	extractPseudo(UFOCUS_PATTERN, ":focus");
+	extractPseudo(ACTIVE_PATTERN, ":active");
+	extractPseudo(UACTIVE_PATTERN, ":active");
+	extractOn(ON_PATTERN);
+	extractOn(UON_PATTERN);
+	extractMedia(MEDIA_PATTERN);
+	extractMedia(AT_SM_PATTERN, "min-width:640px");
+	extractMedia(AT_MD_PATTERN, "min-width:768px");
+	extractMedia(UAT_MD_PATTERN, "min-width:768px");
+	extractMedia(AT_LG_PATTERN, "min-width:1024px");
+	extractMedia(UAT_LG_PATTERN, "min-width:1024px");
+	extractMedia(AT_XL_PATTERN, "min-width:1280px");
+	extractMedia(DARK_PATTERN, "prefers-color-scheme:dark");
+	extractMedia(UDARK_PATTERN, "prefers-color-scheme:dark");
+	return {
+		base,
+		pseudo,
+		media
+	};
+}
+function findMbtFiles$1(dir) {
+	const files = [];
+	function walk(currentDir) {
+		const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				if (![
+					"node_modules",
+					".git",
+					"target",
+					".mooncakes"
+				].includes(entry.name)) walk(fullPath);
+			} else if (entry.isFile() && entry.name.endsWith(".mbt")) files.push(fullPath);
+		}
+	}
+	walk(dir);
+	return files;
+}
+/**
+* DJB2 hash function - must match MoonBit registry.mbt implementation
+*/
+function djb2Hash(s) {
+	let hash = 5381;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		hash = (hash << 5) + hash + c >>> 0;
+	}
+	return hash;
+}
+/**
+* Convert hash to base36 string (0-9a-z)
+* Takes lower 24 bits to keep class names short (4-5 chars)
+*/
+function toBase36(n) {
+	const chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+	n = n & 16777215;
+	if (n === 0) return "0";
+	let result = "";
+	while (n > 0) {
+		result = chars[n % 36] + result;
+		n = Math.floor(n / 36);
+	}
+	return result;
+}
+/**
+* Generate class name from declaration hash
+*/
+function hashClassName(decl) {
+	return "_" + toBase36(djb2Hash(decl));
+}
+function generateCSS(styles, options = {}) {
+	const { pretty = false } = options;
+	const mapping = {};
+	const parts = [];
+	for (const decl of styles.base) {
+		const cls = hashClassName(decl);
+		mapping[decl] = cls;
+		if (pretty) parts.push(`.${cls} { ${decl} }`);
+		else parts.push(`.${cls}{${decl}}`);
+	}
+	for (const { pseudo, property, value } of styles.pseudo) {
+		const hashKey = `${pseudo}:${property}:${value}`;
+		const cls = hashClassName(hashKey);
+		mapping[hashKey] = cls;
+		if (pretty) parts.push(`.${cls}${pseudo} { ${property}: ${value} }`);
+		else parts.push(`.${cls}${pseudo}{${property}:${value}}`);
+	}
+	const mediaGroups = /* @__PURE__ */ new Map();
+	for (const { condition, property, value } of styles.media) {
+		if (!mediaGroups.has(condition)) mediaGroups.set(condition, []);
+		mediaGroups.get(condition).push({
+			property,
+			value
+		});
+	}
+	for (const [condition, declarations] of mediaGroups) {
+		const rules = [];
+		for (const { property, value } of declarations) {
+			const hashKey = `@media(${condition}):${property}:${value}`;
+			const cls = hashClassName(hashKey);
+			mapping[hashKey] = cls;
+			if (pretty) rules.push(`  .${cls} { ${property}: ${value} }`);
+			else rules.push(`.${cls}{${property}:${value}}`);
+		}
+		if (pretty) parts.push(`@media (${condition}) {\n${rules.join("\n")}\n}`);
+		else parts.push(`@media(${condition}){${rules.join("")}}`);
+	}
+	const separator = pretty ? "\n" : "";
+	return {
+		css: parts.join(separator),
+		mapping
+	};
+}
+function extract(dir, options = {}) {
+	const { pretty = false, warn = true, strict = false, verbose = false } = options;
+	const files = findMbtFiles$1(dir);
+	if (verbose) console.error(`Found ${files.length} .mbt files`);
+	const combined = {
+		base: /* @__PURE__ */ new Set(),
+		pseudo: [],
+		media: []
+	};
+	const allWarnings = [];
+	for (const file of files) {
+		const content = fs.readFileSync(file, "utf-8");
+		const extracted = extractFromContent(content);
+		for (const decl of extracted.base) combined.base.add(decl);
+		combined.pseudo.push(...extracted.pseudo);
+		combined.media.push(...extracted.media);
+		if (warn) {
+			const warnings = detectWarnings(content, file);
+			allWarnings.push(...warnings);
+		}
+	}
+	if (warn && allWarnings.length > 0 && verbose) {
+		console.error(`\n⚠️  ${allWarnings.length} warning(s): non-literal CSS arguments detected\n`);
+		for (const w of allWarnings) {
+			console.error(`  ${w.file}:${w.line}`);
+			console.error(`    ${w.func}(...) - ${w.reason}`);
+			console.error(`    Code: ${w.code}`);
+			console.error("");
+		}
+		if (strict) throw new Error("Strict mode: non-literal CSS arguments detected");
+	}
+	if (verbose) {
+		console.error(`Extracted:`);
+		console.error(`  - ${combined.base.size} base declarations`);
+		console.error(`  - ${combined.pseudo.length} pseudo-class declarations`);
+		console.error(`  - ${combined.media.length} media query declarations`);
+	}
+	const { css, mapping } = generateCSS(combined, { pretty });
+	return {
+		css,
+		mapping,
+		stats: {
+			base: combined.base.size,
+			pseudo: combined.pseudo.length,
+			media: combined.media.length
+		},
+		warnings: warn ? allWarnings : void 0
+	};
+}
+/**
+* Extract CSS with split output by file or directory.
+* Shared CSS (used in 3+ files/dirs) is separated into a shared chunk.
+*/
+function extractSplit(dir, mode, options = {}) {
+	const { pretty = false, warn = true, strict = false, verbose = false, sharedThreshold = 3 } = options;
+	const files = findMbtFiles$1(dir);
+	if (verbose) console.error(`Found ${files.length} .mbt files`);
+	const declUsage = /* @__PURE__ */ new Map();
+	const pseudoUsage = /* @__PURE__ */ new Map();
+	const mediaUsage = /* @__PURE__ */ new Map();
+	const perChunk = /* @__PURE__ */ new Map();
+	const allWarnings = [];
+	for (const file of files) {
+		const content = fs.readFileSync(file, "utf-8");
+		const extracted = extractFromContent(content);
+		const relPath = path.relative(dir, file);
+		const chunkKey = mode === "file" ? relPath : path.dirname(relPath) || ".";
+		if (!perChunk.has(chunkKey)) perChunk.set(chunkKey, {
+			base: /* @__PURE__ */ new Set(),
+			pseudo: [],
+			media: []
+		});
+		const chunk = perChunk.get(chunkKey);
+		for (const decl of extracted.base) {
+			chunk.base.add(decl);
+			if (!declUsage.has(decl)) declUsage.set(decl, /* @__PURE__ */ new Set());
+			declUsage.get(decl).add(chunkKey);
+		}
+		for (const p of extracted.pseudo) {
+			const key = `${p.pseudo}:${p.property}:${p.value}`;
+			chunk.pseudo.push(p);
+			if (!pseudoUsage.has(key)) pseudoUsage.set(key, /* @__PURE__ */ new Set());
+			pseudoUsage.get(key).add(chunkKey);
+		}
+		for (const m of extracted.media) {
+			const key = `@media(${m.condition}):${m.property}:${m.value}`;
+			chunk.media.push(m);
+			if (!mediaUsage.has(key)) mediaUsage.set(key, /* @__PURE__ */ new Set());
+			mediaUsage.get(key).add(chunkKey);
+		}
+		if (warn) {
+			const warnings = detectWarnings(content, file);
+			allWarnings.push(...warnings);
+		}
+	}
+	const sharedBase = /* @__PURE__ */ new Set();
+	const sharedPseudo = [];
+	const sharedMedia = [];
+	for (const [decl, chunks] of declUsage) if (chunks.size >= sharedThreshold) sharedBase.add(decl);
+	const seenPseudo = /* @__PURE__ */ new Set();
+	for (const [key, chunks] of pseudoUsage) if (chunks.size >= sharedThreshold && !seenPseudo.has(key)) {
+		seenPseudo.add(key);
+		const [pseudo, property, value] = key.split(":");
+		sharedPseudo.push({
+			pseudo,
+			property,
+			value
+		});
+	}
+	const seenMedia = /* @__PURE__ */ new Set();
+	for (const [key, chunks] of mediaUsage) if (chunks.size >= sharedThreshold && !seenMedia.has(key)) {
+		seenMedia.add(key);
+		const match = key.match(/^@media\(([^)]+)\):([^:]+):(.+)$/);
+		if (match) sharedMedia.push({
+			condition: match[1],
+			property: match[2],
+			value: match[3]
+		});
+	}
+	const finalChunks = /* @__PURE__ */ new Map();
+	const chunkStats = /* @__PURE__ */ new Map();
+	for (const [chunkKey, chunk] of perChunk) {
+		const chunkOnlyBase = /* @__PURE__ */ new Set();
+		for (const decl of chunk.base) if (!sharedBase.has(decl)) chunkOnlyBase.add(decl);
+		const chunkOnlyPseudo = chunk.pseudo.filter((p) => {
+			const key = `${p.pseudo}:${p.property}:${p.value}`;
+			return !seenPseudo.has(key);
+		});
+		const chunkOnlyMedia = chunk.media.filter((m) => {
+			const key = `@media(${m.condition}):${m.property}:${m.value}`;
+			return !seenMedia.has(key);
+		});
+		const chunkStyles = {
+			base: chunkOnlyBase,
+			pseudo: chunkOnlyPseudo,
+			media: chunkOnlyMedia
+		};
+		const { css } = generateCSS(chunkStyles, { pretty });
+		finalChunks.set(chunkKey, {
+			css,
+			styles: chunkStyles
+		});
+		chunkStats.set(chunkKey, {
+			base: chunkOnlyBase.size,
+			pseudo: chunkOnlyPseudo.length,
+			media: chunkOnlyMedia.length
+		});
+	}
+	const sharedStyles = {
+		base: sharedBase,
+		pseudo: sharedPseudo,
+		media: sharedMedia
+	};
+	const { css: sharedCss, mapping } = generateCSS(sharedStyles, { pretty });
+	const combinedStyles = {
+		base: /* @__PURE__ */ new Set(),
+		pseudo: [],
+		media: []
+	};
+	for (const decl of sharedBase) combinedStyles.base.add(decl);
+	for (const [, chunk] of finalChunks) {
+		for (const decl of chunk.styles.base) combinedStyles.base.add(decl);
+		combinedStyles.pseudo.push(...chunk.styles.pseudo);
+		combinedStyles.media.push(...chunk.styles.media);
+	}
+	combinedStyles.pseudo.push(...sharedPseudo);
+	combinedStyles.media.push(...sharedMedia);
+	const { css: combinedCss, mapping: fullMapping } = generateCSS(combinedStyles, { pretty });
+	if (verbose) {
+		console.error(`Split mode: ${mode}`);
+		console.error(`Chunks: ${finalChunks.size}`);
+		console.error(`Shared declarations (≥${sharedThreshold} usages):`);
+		console.error(`  - ${sharedBase.size} base`);
+		console.error(`  - ${sharedPseudo.length} pseudo`);
+		console.error(`  - ${sharedMedia.length} media`);
+	}
+	if (warn && allWarnings.length > 0 && verbose) console.error(`\n⚠️  ${allWarnings.length} warning(s)\n`);
+	if (strict && allWarnings.length > 0) throw new Error("Strict mode: non-literal CSS arguments detected");
+	return {
+		chunks: finalChunks,
+		shared: {
+			css: sharedCss,
+			styles: sharedStyles
+		},
+		combined: combinedCss,
+		mapping: fullMapping,
+		stats: chunkStats,
+		warnings: warn ? allWarnings : void 0
+	};
+}
+
+//#endregion
+//#region src/css/minify.ts
+/**
+* Minify CSS content
+*/
+function minifyCSS(css) {
+	return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{};:,])\s*/g, "$1").replace(/;}/g, "}").replace(/\(\s+/g, "(").replace(/\s+\)/g, ")").trim();
+}
+/**
+* Format file size
+*/
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	return `${(bytes / 1024).toFixed(1)} KB`;
+}
+/**
+* Minify CSS and return result with stats
+*/
+function minify(css, options = {}) {
+	const originalSize = Buffer.byteLength(css, "utf-8");
+	const minified = minifyCSS(css);
+	const minifiedSize = Buffer.byteLength(minified, "utf-8");
+	const reduction = (1 - minifiedSize / originalSize) * 100;
+	if (options.verbose) console.error(`Minified: ${formatSize(originalSize)} → ${formatSize(minifiedSize)} (${reduction.toFixed(1)}% reduction)`);
+	return {
+		minified,
+		originalSize,
+		minifiedSize,
+		reduction
+	};
+}
+
+//#endregion
+//#region src/css/inline.ts
+/**
+* CSS Class Name Inliner
+*
+* Replaces CSS utility function calls with pre-computed class names.
+* This enables true zero-runtime CSS by eliminating runtime style registration.
+*/
+const REGISTER_DECL_PATTERN = /mizchi\$luna\$luna\$css\$\$register_decl\s*\(\s*"([^"]+)"\s*\)/g;
+const REGISTER_PSEUDO_PATTERN = /mizchi\$luna\$luna\$css\$\$register_pseudo\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+const REGISTER_MEDIA_PATTERN = /mizchi\$luna\$luna\$css\$\$register_media\s*\(\s*"([^"]+)"\s*,\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\)/g;
+/**
+* Replace CSS function calls with pre-computed class names
+*/
+function inlineCSS(code, mapping, options = {}) {
+	const { verbose = false } = options;
+	const replacements = [];
+	const originalSize = Buffer.byteLength(code, "utf-8");
+	let result = code;
+	result = result.replace(REGISTER_DECL_PATTERN, (match, decl) => {
+		const className = mapping[decl];
+		if (className) {
+			replacements.push({
+				type: "base",
+				from: match,
+				to: `"${className}"`,
+				decl
+			});
+			return `"${className}"`;
+		}
+		if (verbose) console.error(`Warning: No mapping for base declaration: ${decl}`);
+		return match;
+	});
+	result = result.replace(REGISTER_PSEUDO_PATTERN, (match, pseudo, property, value) => {
+		const key = `${pseudo}:${property}:${value}`;
+		const className = mapping[key];
+		if (className) {
+			replacements.push({
+				type: "pseudo",
+				from: match,
+				to: `"${className}"`,
+				key
+			});
+			return `"${className}"`;
+		}
+		if (verbose) console.error(`Warning: No mapping for pseudo: ${key}`);
+		return match;
+	});
+	result = result.replace(REGISTER_MEDIA_PATTERN, (match, condition, property, value) => {
+		const key = `@media(${condition}):${property}:${value}`;
+		const className = mapping[key];
+		if (className) {
+			replacements.push({
+				type: "media",
+				from: match,
+				to: `"${className}"`,
+				key
+			});
+			return `"${className}"`;
+		}
+		if (verbose) console.error(`Warning: No mapping for media: ${key}`);
+		return match;
+	});
+	const finalSize = Buffer.byteLength(result, "utf-8");
+	return {
+		code: result,
+		replacements,
+		originalSize,
+		finalSize
+	};
+}
+/**
+* Remove CSS registry code (dead code after inlining)
+*/
+function removeRegistryCode(code) {
+	const patterns = [
+		/const mizchi\$luna\$luna\$css\$\$registry\s*=\s*\{[^}]+\};?\n?/g,
+		/const mizchi\$luna\$luna\$css\$\$pseudo_registry\s*=\s*\{[^}]+\};?\n?/g,
+		/const mizchi\$luna\$luna\$css\$\$media_registry\s*=\s*\{[^}]+\};?\n?/g,
+		/const mizchi\$luna\$luna\$css\$\$class_chars\s*=\s*"[^"]+";?\n?/g,
+		/const mizchi\$luna\$luna\$css\$\$[a-z_]+\$46\$42\$bind[^;]+;?\n?/g
+	];
+	let result = code;
+	for (const pattern of patterns) result = result.replace(pattern, "");
+	return result;
+}
+/**
+* Inline CSS with mapping extracted from source directory
+*/
+function inlineFromSource(code, srcDir, options = {}) {
+	const { mapping } = extract(srcDir, { warn: false });
+	let result = inlineCSS(code, mapping, options);
+	if (options.removeRegistry) result = {
+		...result,
+		code: removeRegistryCode(result.code),
+		finalSize: Buffer.byteLength(removeRegistryCode(result.code), "utf-8")
+	};
+	return result;
+}
+
+//#endregion
+//#region src/css/inject.ts
+/**
+* CSS Injection into HTML files
+*
+* Replaces CSS between markers in HTML files with extracted CSS.
+* Supports inline embedding or external file generation.
+*/
+const CSS_START_MARKER = "/* LUNA_CSS_START */";
+const CSS_END_MARKER = "/* LUNA_CSS_END */";
+const LINK_MARKER = "<!-- LUNA_CSS_LINK -->";
+/**
+* Inject extracted CSS into HTML file between markers
+*/
+function injectCssToHtml(options) {
+	const { srcDir, htmlFile, mode = "inline", threshold = 4096, cssFileName = "luna.css", verbose = false } = options;
+	const { css } = extract(srcDir, { warn: false });
+	if (verbose) console.error(`Extracted CSS: ${css.length} bytes`);
+	const html = fs.readFileSync(htmlFile, "utf-8");
+	let actualMode = mode;
+	if (mode === "auto") {
+		actualMode = css.length > threshold ? "external" : "inline";
+		if (verbose) console.error(`Auto mode: ${css.length} bytes ${css.length > threshold ? ">" : "<="} ${threshold} threshold → ${actualMode}`);
+	}
+	if (actualMode === "external") return injectExternal(html, css, htmlFile, cssFileName, verbose);
+	else return injectInline(html, css, htmlFile, verbose);
+}
+/**
+* Inject CSS inline between markers
+*/
+function injectInline(html, css, htmlFile, verbose) {
+	const startIdx = html.indexOf(CSS_START_MARKER);
+	const endIdx = html.indexOf(CSS_END_MARKER);
+	if (startIdx === -1 || endIdx === -1) {
+		if (verbose) console.error(`Warning: Markers not found in ${htmlFile}. Add /* LUNA_CSS_START */ and /* LUNA_CSS_END */ to your HTML.`);
+		return {
+			html,
+			css,
+			replaced: false,
+			mode: "inline"
+		};
+	}
+	const newHtml = `${html.substring(0, startIdx + 20)}\n    ${css}\n    ${html.substring(endIdx)}`;
+	if (verbose) console.error(`Injected CSS inline into ${htmlFile}`);
+	return {
+		html: newHtml,
+		css,
+		replaced: true,
+		mode: "inline"
+	};
+}
+/**
+* Create external CSS file and add link tag
+*/
+function injectExternal(html, css, htmlFile, cssFileName, verbose) {
+	const htmlDir = path.dirname(htmlFile);
+	const cssFilePath = path.join(htmlDir, cssFileName);
+	const hasLinkMarker = html.includes(LINK_MARKER);
+	const startIdx = html.indexOf(CSS_START_MARKER);
+	const endIdx = html.indexOf(CSS_END_MARKER);
+	let newHtml = html;
+	let replaced = false;
+	if (hasLinkMarker) {
+		newHtml = html.replace(LINK_MARKER, `<link rel="stylesheet" href="${cssFileName}">`);
+		replaced = true;
+	} else if (startIdx !== -1 && endIdx !== -1) {
+		newHtml = `${html.substring(0, startIdx + 20)}\n    /* External: ${cssFileName} */\n    ${html.substring(endIdx)}`;
+		if (!newHtml.includes(`href="${cssFileName}"`)) newHtml = newHtml.replace("</head>", `  <link rel="stylesheet" href="${cssFileName}">\n</head>`);
+		replaced = true;
+	} else if (verbose) console.error(`Warning: No markers found in ${htmlFile}. Add <!-- LUNA_CSS_LINK --> or /* LUNA_CSS_START/END */ markers.`);
+	if (verbose && replaced) console.error(`Created external CSS: ${cssFilePath}`);
+	return {
+		html: newHtml,
+		css,
+		replaced,
+		cssFile: cssFilePath,
+		mode: "external"
+	};
+}
+/**
+* Inject CSS and write to file(s)
+*/
+function injectAndWrite(options) {
+	const result = injectCssToHtml(options);
+	const outputFile = options.outputFile || options.htmlFile;
+	if (result.replaced) {
+		fs.writeFileSync(outputFile, result.html);
+		if (options.verbose) console.error(`Written HTML to: ${outputFile}`);
+		if (result.mode === "external" && result.cssFile) {
+			fs.writeFileSync(result.cssFile, result.css);
+			if (options.verbose) console.error(`Written CSS to: ${result.cssFile}`);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/css-optimizer/moonbit-analyzer.ts
+/**
+* MoonBit Static Analyzer Integration
+*
+* Calls the MoonBit-based CSS static analyzer to extract class co-occurrences
+* from MoonBit source files.
+*/
+let analyzerModule = null;
+/**
+* Get the path to the MoonBit analyzer JS module
+*/
+function getAnalyzerPath() {
+	const __dirname = path$1.dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		path$1.resolve(__dirname, "../../../target/js/release/build/luna/css/analyzer/analyzer.js"),
+		path$1.resolve(__dirname, "../../../../target/js/release/build/luna/css/analyzer/analyzer.js"),
+		path$1.resolve(__dirname, "../moonbit/analyzer.js")
+	];
+	for (const candidate of candidates) if (fs$1.existsSync(candidate)) return candidate;
+	throw new Error(`MoonBit analyzer not found. Tried:\n${candidates.join("\n")}\nRun 'moon build --target js src/luna/css/analyzer' first.`);
+}
+/**
+* Load the MoonBit analyzer module
+*/
+async function loadAnalyzer() {
+	if (analyzerModule) return analyzerModule;
+	analyzerModule = await import(getAnalyzerPath());
+	return analyzerModule;
+}
+/**
+* Analyze a single MoonBit source file
+*/
+async function analyzeFile(source, filePath) {
+	const analyzer = await loadAnalyzer();
+	if (!analyzer) throw new Error("Failed to load MoonBit analyzer");
+	const jsonResult = analyzer.analyze_file_json(source, filePath);
+	return JSON.parse(jsonResult);
+}
+/**
+* Analyze all .mbt files in a directory
+*/
+async function analyzeDirectory(dir, options = {}) {
+	const { recursive = true } = options;
+	const allCooccurrences = [];
+	const allWarnings = [];
+	const files = findMbtFiles(dir, recursive);
+	for (const file of files) {
+		const result = await analyzeFile(fs$1.readFileSync(file, "utf-8"), file);
+		allCooccurrences.push(...result.cooccurrences);
+		allWarnings.push(...result.warnings);
+	}
+	return {
+		cooccurrences: allCooccurrences,
+		warnings: allWarnings
+	};
+}
+/**
+* Find all .mbt files in a directory
+*/
+function findMbtFiles(dir, recursive) {
+	const files = [];
+	function walk(currentDir) {
+		const entries = fs$1.readdirSync(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path$1.join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name === "node_modules" || entry.name === "target" || entry.name === ".git" || entry.name === ".mooncakes") continue;
+				if (recursive) walk(fullPath);
+			} else if (entry.isFile() && entry.name.endsWith(".mbt")) {
+				if (!entry.name.endsWith("_test.mbt")) files.push(fullPath);
+			}
+		}
+	}
+	walk(dir);
+	return files;
+}
+
+//#endregion
 //#region bin/cli.ts
-path.dirname(fileURLToPath(import.meta.url));
-function printHelp() {
+path$1.dirname(fileURLToPath(import.meta.url));
+function printMainHelp() {
 	console.log(`
 @luna_ui/luna CLI
 
 Usage:
-  npx @luna_ui/luna new <project-name> [options]
+  luna <command> [options]
+
+Commands:
+  new <name>      Create a new Luna project
+  css             CSS utilities (extract, minify, inline)
+
+Options:
+  --help, -h      Show this help message
+
+Examples:
+  luna new myapp              # Create TSX project
+  luna new myapp --mbt        # Create MoonBit project
+  luna css extract src        # Extract CSS from source
+  luna css minify style.css   # Minify CSS file
+`);
+}
+function printNewHelp() {
+	console.log(`
+luna new - Create a new Luna project
+
+Usage:
+  luna new <project-name> [options]
 
 Options:
   --mbt       Generate MoonBit template (default: TSX)
   --help, -h  Show this help message
 
 Examples:
-  npx @luna_ui/luna new myapp         # TSX template
-  npx @luna_ui/luna new myapp --mbt   # MoonBit template
+  luna new myapp         # TSX template
+  luna new myapp --mbt   # MoonBit template
+`);
+}
+function printCssHelp() {
+	console.log(`
+luna css - CSS utilities
+
+Usage:
+  luna css <subcommand> [options]
+
+Subcommands:
+  extract <dir>     Extract CSS from .mbt files
+  minify <file>     Minify CSS file
+  inline <file>     Inline CSS class names into compiled JS
+  inject <html>     Inject extracted CSS into HTML file
+  analyze-mbt <dir> Analyze MoonBit source for CSS co-occurrences
+
+Extract Options:
+  -o, --output <file>   Output file (default: stdout)
+  --pretty              Pretty print output
+  --json                Output as JSON with mapping
+  -v, --verbose         Show extraction details
+  --no-warn             Disable non-literal argument warnings
+  --strict              Exit with error if warnings found
+  --split               Split CSS by file (outputs to --output-dir)
+  --split-dir           Split CSS by directory (outputs to --output-dir)
+  --output-dir <dir>    Output directory for split mode
+  --shared-threshold <n>  Min usages to be "shared" (default: 3)
+
+Minify Options:
+  -o, --output <file>   Output file (default: stdout)
+  -v, --verbose         Show minification stats
+
+Inline Options:
+  -m, --mapping <file>  JSON file with css -> classname mapping
+  --extract-from <dir>  Extract mapping from source directory
+  -o, --output <file>   Output file (default: stdout)
+  --remove-registry     Remove CSS registry code after inlining
+  -v, --verbose         Show replacement details
+  --dry-run             Show what would be replaced
+
+Inject Options:
+  --src <dir>           Source directory for CSS extraction (required)
+  -o, --output <file>   Output file (default: modify in-place)
+  -m, --mode <mode>     Output mode: inline, external, or auto (default: inline)
+  -t, --threshold <n>   Size threshold for auto mode in bytes (default: 4096)
+  --css-file <name>     CSS filename for external mode (default: luna.css)
+  -v, --verbose         Show injection details
+
+Analyze-mbt Options:
+  -o, --output <file>   Output file (default: stdout)
+  --no-recursive        Don't search recursively
+  -v, --verbose         Show analysis details
+
+Examples:
+  luna css extract src -o dist/styles.css
+  luna css extract src --json -o mapping.json
+  luna css extract src --split --output-dir dist/css
+  luna css extract src --split-dir --output-dir dist/css --shared-threshold 2
+  luna css minify input.css -o output.min.css
+  luna css inline bundle.js --extract-from src -o bundle.inlined.js
+  luna css inject index.html --src src
+  luna css inject index.html --src src --mode external --css-file styles.css
+  luna css inject index.html --src src --mode auto --threshold 2048
+  luna css analyze-mbt src/luna -o cooccurrences.json
 `);
 }
 function getTsxTemplates(projectName) {
@@ -303,35 +1185,28 @@ target
 	];
 }
 function createProject(projectName, templates, targetDir) {
-	if (fs.existsSync(targetDir)) {
+	if (fs$1.existsSync(targetDir)) {
 		console.error(`Error: Directory "${projectName}" already exists.`);
 		process.exit(1);
 	}
-	fs.mkdirSync(targetDir, { recursive: true });
+	fs$1.mkdirSync(targetDir, { recursive: true });
 	for (const template of templates) {
-		const filePath = path.join(targetDir, template.path);
-		const dir = path.dirname(filePath);
-		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-		fs.writeFileSync(filePath, template.content);
+		const filePath = path$1.join(targetDir, template.path);
+		const dir = path$1.dirname(filePath);
+		if (!fs$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+		fs$1.writeFileSync(filePath, template.content);
 		console.log(`  Created: ${template.path}`);
 	}
 }
-function main() {
-	const args = process.argv.slice(2);
-	if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-		printHelp();
+function handleNew(args) {
+	if (args.includes("--help") || args.includes("-h")) {
+		printNewHelp();
 		process.exit(0);
 	}
-	const command = args[0];
-	if (command !== "new") {
-		console.error(`Unknown command: ${command}`);
-		printHelp();
-		process.exit(1);
-	}
-	const projectName = args[1];
+	const projectName = args.find((a) => !a.startsWith("-"));
 	if (!projectName) {
 		console.error("Error: Project name is required.");
-		printHelp();
+		printNewHelp();
 		process.exit(1);
 	}
 	if (!/^[a-zA-Z0-9_-]+$/.test(projectName)) {
@@ -339,7 +1214,7 @@ function main() {
 		process.exit(1);
 	}
 	const useMbt = args.includes("--mbt");
-	const targetDir = path.resolve(process.cwd(), projectName);
+	const targetDir = path$1.resolve(process.cwd(), projectName);
 	console.log(`\nCreating ${useMbt ? "MoonBit" : "TSX"} project: ${projectName}\n`);
 	createProject(projectName, useMbt ? getMbtTemplates(projectName) : getTsxTemplates(projectName), targetDir);
 	console.log(`\nDone! To get started:\n`);
@@ -355,7 +1230,369 @@ function main() {
 	}
 	console.log();
 }
-main();
+function handleCssExtract(args) {
+	let dir = ".";
+	let outputFile = null;
+	let outputDir = null;
+	let pretty = false;
+	let jsonOutput = false;
+	let verbose = false;
+	let warn = true;
+	let strict = false;
+	let splitMode = null;
+	let sharedThreshold = 3;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--output" || arg === "-o") outputFile = args[++i];
+		else if (arg === "--output-dir") outputDir = args[++i];
+		else if (arg === "--pretty") pretty = true;
+		else if (arg === "--json") jsonOutput = true;
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
+		else if (arg === "--no-warn") warn = false;
+		else if (arg === "--strict") {
+			strict = true;
+			warn = true;
+		} else if (arg === "--split") splitMode = "file";
+		else if (arg === "--split-dir") splitMode = "dir";
+		else if (arg === "--shared-threshold") {
+			sharedThreshold = parseInt(args[++i], 10);
+			if (isNaN(sharedThreshold) || sharedThreshold < 1) {
+				console.error("Error: --shared-threshold must be a positive number");
+				process.exit(1);
+			}
+		} else if (!arg.startsWith("-")) dir = arg;
+	}
+	try {
+		if (splitMode) {
+			if (!outputDir) {
+				console.error("Error: --output-dir is required for split mode");
+				process.exit(1);
+			}
+			const result$1 = extractSplit(dir, splitMode, {
+				pretty,
+				warn,
+				strict,
+				verbose,
+				sharedThreshold
+			});
+			fs$1.mkdirSync(outputDir, { recursive: true });
+			const sharedPath = path$1.join(outputDir, "_shared.css");
+			fs$1.writeFileSync(sharedPath, result$1.shared.css);
+			if (verbose) console.error(`Written shared CSS to ${sharedPath}`);
+			for (const [chunkKey, chunk] of result$1.chunks) {
+				if (!chunk.css) continue;
+				let chunkPath;
+				if (splitMode === "file") chunkPath = path$1.join(outputDir, chunkKey.replace(/\.mbt$/, ".css"));
+				else {
+					const dirName = chunkKey === "." ? "root" : chunkKey.replace(/\//g, "_");
+					chunkPath = path$1.join(outputDir, `${dirName}.css`);
+				}
+				fs$1.mkdirSync(path$1.dirname(chunkPath), { recursive: true });
+				fs$1.writeFileSync(chunkPath, chunk.css);
+				if (verbose) console.error(`Written chunk CSS to ${chunkPath}`);
+			}
+			if (jsonOutput) {
+				const mappingPath = path$1.join(outputDir, "mapping.json");
+				const mappingData = {
+					mapping: result$1.mapping,
+					chunks: Object.fromEntries(Array.from(result$1.chunks.entries()).map(([k, v]) => [k, { size: v.css.length }])),
+					shared: { size: result$1.shared.css.length },
+					warnings: result$1.warnings
+				};
+				fs$1.writeFileSync(mappingPath, JSON.stringify(mappingData, null, pretty ? 2 : 0));
+				if (verbose) console.error(`Written mapping to ${mappingPath}`);
+			}
+			if (verbose) {
+				console.error("\nSplit extraction summary:");
+				console.error(`  Shared: ${result$1.shared.css.length} bytes`);
+				for (const [chunkKey, chunk] of result$1.chunks) console.error(`  ${chunkKey}: ${chunk.css.length} bytes`);
+				console.error(`  Combined: ${result$1.combined.length} bytes`);
+			}
+			if (warn && result$1.warnings && result$1.warnings.length > 0) printWarnings(result$1.warnings, strict);
+			return;
+		}
+		const result = extract(dir, {
+			pretty,
+			warn,
+			strict,
+			verbose
+		});
+		let output;
+		if (jsonOutput) output = JSON.stringify({
+			css: result.css,
+			mapping: result.mapping,
+			stats: result.stats,
+			warnings: result.warnings
+		}, null, pretty ? 2 : 0);
+		else output = result.css;
+		if (outputFile) {
+			fs$1.writeFileSync(outputFile, output);
+			if (verbose) console.error(`Written to ${outputFile}`);
+		} else console.log(output);
+		if (warn && result.warnings && result.warnings.length > 0) printWarnings(result.warnings, strict);
+	} catch (err) {
+		console.error(`Error: ${err.message}`);
+		process.exit(1);
+	}
+}
+function printWarnings(warnings, strict) {
+	console.error(`\n⚠️  ${warnings.length} warning(s): non-literal CSS arguments detected\n`);
+	for (const w of warnings) {
+		console.error(`  ${w.file}:${w.line}`);
+		console.error(`    ${w.func}(...) - ${w.reason}`);
+		console.error(`    Code: ${w.code}`);
+		console.error("");
+	}
+	if (strict) {
+		console.error("❌ Strict mode: exiting with error due to warnings.");
+		process.exit(1);
+	}
+}
+function handleCssMinify(args) {
+	let inputFile = null;
+	let outputFile = null;
+	let verbose = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--output" || arg === "-o") outputFile = args[++i];
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
+		else if (!arg.startsWith("-")) inputFile = arg;
+	}
+	if (!inputFile) {
+		console.error("Error: No input file specified");
+		printCssHelp();
+		process.exit(1);
+	}
+	try {
+		const result = minify(fs$1.readFileSync(inputFile, "utf-8"), { verbose });
+		if (outputFile) {
+			fs$1.writeFileSync(outputFile, result.minified);
+			console.error(`Minified: ${formatSize(result.originalSize)} → ${formatSize(result.minifiedSize)} (${result.reduction.toFixed(1)}% reduction)`);
+			console.error(`Written to: ${outputFile}`);
+		} else console.log(result.minified);
+	} catch (err) {
+		console.error(`Error: ${err.message}`);
+		process.exit(1);
+	}
+}
+function handleCssInline(args) {
+	let inputFile = null;
+	let outputFile = null;
+	let mappingFile = null;
+	let extractFrom = null;
+	let verbose = false;
+	let dryRun = false;
+	let removeRegistry = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--mapping" || arg === "-m") mappingFile = args[++i];
+		else if (arg === "--extract-from") extractFrom = args[++i];
+		else if (arg === "--output" || arg === "-o") outputFile = args[++i];
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
+		else if (arg === "--dry-run") {
+			dryRun = true;
+			verbose = true;
+		} else if (arg === "--remove-registry") removeRegistry = true;
+		else if (!arg.startsWith("-")) inputFile = arg;
+	}
+	if (!inputFile) {
+		console.error("Error: No input file specified");
+		printCssHelp();
+		process.exit(1);
+	}
+	if (!mappingFile && !extractFrom) {
+		console.error("Error: Must specify --mapping or --extract-from");
+		printCssHelp();
+		process.exit(1);
+	}
+	try {
+		const code = fs$1.readFileSync(inputFile, "utf-8");
+		let result;
+		if (extractFrom) result = inlineFromSource(code, extractFrom, {
+			verbose,
+			dryRun,
+			removeRegistry
+		});
+		else {
+			const mappingContent = fs$1.readFileSync(mappingFile, "utf-8");
+			const mappingData = JSON.parse(mappingContent);
+			result = inlineCSS(code, mappingData.mapping || mappingData, {
+				verbose,
+				dryRun
+			});
+			if (removeRegistry) result = {
+				...result,
+				code: removeRegistryCode(result.code),
+				finalSize: Buffer.byteLength(removeRegistryCode(result.code), "utf-8")
+			};
+		}
+		if (verbose) {
+			console.error(`Loaded mapping, found ${result.replacements.length} replacements`);
+			for (const r of result.replacements) console.error(`  [${r.type}] ${r.key || r.decl} → ${r.to}`);
+			console.error(`\nSize: ${result.originalSize} → ${result.finalSize} (${((1 - result.finalSize / result.originalSize) * 100).toFixed(1)}% reduction)`);
+		}
+		if (dryRun) console.error("\n[Dry run - no files modified]");
+		else if (outputFile) {
+			fs$1.writeFileSync(outputFile, result.code);
+			if (verbose) console.error(`Written to ${outputFile}`);
+		} else console.log(result.code);
+	} catch (err) {
+		console.error(`Error: ${err.message}`);
+		process.exit(1);
+	}
+}
+function handleCssInject(args) {
+	let htmlFile = null;
+	let srcDir = null;
+	let outputFile = null;
+	let mode = "inline";
+	let threshold = 4096;
+	let cssFileName = "luna.css";
+	let verbose = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--src") srcDir = args[++i];
+		else if (arg === "--output" || arg === "-o") outputFile = args[++i];
+		else if (arg === "--mode" || arg === "-m") {
+			const m = args[++i];
+			if (m === "inline" || m === "external" || m === "auto") mode = m;
+			else {
+				console.error(`Error: Invalid mode "${m}". Use inline, external, or auto.`);
+				process.exit(1);
+			}
+		} else if (arg === "--threshold" || arg === "-t") {
+			threshold = parseInt(args[++i], 10);
+			if (isNaN(threshold)) {
+				console.error("Error: --threshold must be a number");
+				process.exit(1);
+			}
+		} else if (arg === "--css-file") cssFileName = args[++i];
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
+		else if (!arg.startsWith("-")) htmlFile = arg;
+	}
+	if (!htmlFile) {
+		console.error("Error: No HTML file specified");
+		printCssHelp();
+		process.exit(1);
+	}
+	if (!srcDir) {
+		console.error("Error: --src <dir> is required");
+		printCssHelp();
+		process.exit(1);
+	}
+	try {
+		const result = injectAndWrite({
+			srcDir,
+			htmlFile,
+			outputFile: outputFile || void 0,
+			mode,
+			threshold,
+			cssFileName,
+			verbose
+		});
+		if (!result.replaced) {
+			console.error("Warning: CSS markers not found. Add /* LUNA_CSS_START */ and /* LUNA_CSS_END */ to your HTML.");
+			process.exit(1);
+		}
+		if (verbose) {
+			console.error(`Mode: ${result.mode}, injected ${result.css.length} bytes of CSS`);
+			if (result.cssFile) console.error(`External CSS file: ${result.cssFile}`);
+		}
+	} catch (err) {
+		console.error(`Error: ${err.message}`);
+		process.exit(1);
+	}
+}
+async function handleCssAnalyzeMbt(args) {
+	let dir = ".";
+	let outputFile = null;
+	let recursive = true;
+	let verbose = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--output" || arg === "-o") outputFile = args[++i];
+		else if (arg === "--no-recursive") recursive = false;
+		else if (arg === "--verbose" || arg === "-v") verbose = true;
+		else if (!arg.startsWith("-")) dir = arg;
+	}
+	try {
+		if (verbose) console.error(`Analyzing MoonBit files in: ${dir}`);
+		const result = await analyzeDirectory(dir, { recursive });
+		const output = JSON.stringify(result, null, 2);
+		if (outputFile) {
+			fs$1.writeFileSync(outputFile, output);
+			if (verbose) console.error(`Written to ${outputFile}`);
+		} else console.log(output);
+		if (verbose) {
+			console.error(`\nFound ${result.cooccurrences.length} class co-occurrences`);
+			if (result.warnings.length > 0) {
+				console.error(`Warnings: ${result.warnings.length}`);
+				for (const w of result.warnings) console.error(`  ${w.file}:${w.line} - ${w.kind}: ${w.message}`);
+			}
+		}
+	} catch (err) {
+		console.error(`Error: ${err.message}`);
+		process.exit(1);
+	}
+}
+async function handleCss(args) {
+	if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+		printCssHelp();
+		process.exit(0);
+	}
+	const subcommand = args[0];
+	const subArgs = args.slice(1);
+	switch (subcommand) {
+		case "extract":
+			handleCssExtract(subArgs);
+			break;
+		case "minify":
+			handleCssMinify(subArgs);
+			break;
+		case "inline":
+			handleCssInline(subArgs);
+			break;
+		case "inject":
+			handleCssInject(subArgs);
+			break;
+		case "analyze-mbt":
+			await handleCssAnalyzeMbt(subArgs);
+			break;
+		default:
+			console.error(`Unknown css subcommand: ${subcommand}`);
+			printCssHelp();
+			process.exit(1);
+	}
+}
+async function main() {
+	const args = process.argv.slice(2);
+	if (args.length === 0) {
+		printMainHelp();
+		process.exit(0);
+	}
+	const command = args[0];
+	if (command === "--help" || command === "-h") {
+		printMainHelp();
+		process.exit(0);
+	}
+	const commandArgs = args.slice(1);
+	switch (command) {
+		case "new":
+			handleNew(commandArgs);
+			break;
+		case "css":
+			await handleCss(commandArgs);
+			break;
+		default:
+			console.error(`Unknown command: ${command}`);
+			printMainHelp();
+			process.exit(1);
+	}
+}
+main().catch((err) => {
+	console.error(`Error: ${err.message}`);
+	process.exit(1);
+});
 
 //#endregion
 export {  };