@luna_ui/luna 0.3.4 → 0.4.0

package/dist/vite-plugin.js

@@ -0,0 +1,1518 @@
+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(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$1(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$1(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$1(djb2Hash$1(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(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(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-optimizer/hash.ts
+/**
+* Hash functions for CSS class name generation
+*/
+/**
+* DJB2 hash function
+* A simple but effective string hashing algorithm
+*/
+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 a number 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 a merged class name from combined declarations
+* @param declarations - Array of CSS declarations
+* @param prefix - Class name prefix (default: "_m" for merged)
+*/
+function hashMergedClassName(declarations, prefix = "_m") {
+	return prefix + toBase36(djb2Hash(declarations.sort().join(";")));
+}
+
+//#endregion
+//#region src/css-optimizer/pattern.ts
+/**
+* Find frequent patterns (sets of classes that often appear together)
+* Uses a greedy enumeration approach for small pattern sizes
+*/
+function findFrequentPatterns(usages, minFrequency, maxSize) {
+	const patternCounts = /* @__PURE__ */ new Map();
+	for (const usage of usages) {
+		const classes = [...usage.classes].sort();
+		const n = classes.length;
+		for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+			const key = `${classes[i]}|${classes[j]}`;
+			patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
+		}
+		if (maxSize >= 3) for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) for (let k = j + 1; k < n; k++) {
+			const key = `${classes[i]}|${classes[j]}|${classes[k]}`;
+			patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
+		}
+		if (maxSize >= 4) for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) for (let k = j + 1; k < n; k++) for (let l = k + 1; l < n; l++) {
+			const key = `${classes[i]}|${classes[j]}|${classes[k]}|${classes[l]}`;
+			patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
+		}
+		if (maxSize >= 5) for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) for (let k = j + 1; k < n; k++) for (let l = k + 1; l < n; l++) for (let m = l + 1; m < n; m++) {
+			const key = `${classes[i]}|${classes[j]}|${classes[k]}|${classes[l]}|${classes[m]}`;
+			patternCounts.set(key, (patternCounts.get(key) || 0) + 1);
+		}
+	}
+	const patterns = [];
+	for (const [key, frequency] of patternCounts) if (frequency >= minFrequency) {
+		const originalClasses = key.split("|");
+		const classCount = originalClasses.length;
+		const bytesSaved = (classCount - 1) * 7 * frequency + (classCount - 1) * 25;
+		patterns.push({
+			originalClasses,
+			mergedClass: "",
+			declarations: [],
+			frequency,
+			bytesSaved
+		});
+	}
+	patterns.sort((a, b) => b.bytesSaved - a.bytesSaved);
+	return removeSubsumedPatterns(patterns);
+}
+/**
+* Remove patterns that are subsets of larger patterns with similar frequency
+* This prevents double-counting savings
+*/
+function removeSubsumedPatterns(patterns) {
+	const result = [];
+	for (let i = 0; i < patterns.length; i++) {
+		const pattern = patterns[i];
+		let isDominated = false;
+		for (let j = 0; j < patterns.length; j++) {
+			if (i === j) continue;
+			const other = patterns[j];
+			if (other.originalClasses.length > pattern.originalClasses.length && other.frequency >= pattern.frequency * .8) {
+				const patternSet = new Set(pattern.originalClasses);
+				const otherSet = new Set(other.originalClasses);
+				let isSubset = true;
+				for (const cls of patternSet) if (!otherSet.has(cls)) {
+					isSubset = false;
+					break;
+				}
+				if (isSubset) {
+					isDominated = true;
+					break;
+				}
+			}
+		}
+		if (!isDominated) result.push(pattern);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/css-optimizer/core.ts
+/**
+* Core optimizer - performs pattern analysis and CSS generation
+*
+* This is the framework-agnostic core that:
+* 1. Analyzes class usages to find frequent patterns
+* 2. Generates merged CSS rules
+* 3. Returns a merge map for HTML transformation
+*
+* @param usages - Array of class usages extracted from source
+* @param css - Original CSS content
+* @param classToDeclaration - Map from class name to CSS declaration
+* @param options - Optimization options
+*/
+function optimizeCore(usages, css, classToDeclaration, options = {}) {
+	const { minFrequency = 2, maxPatternSize = 5, pretty = false, verbose = false } = options;
+	const log = (msg) => {
+		if (verbose) console.log(`[css-optimizer] ${msg}`);
+	};
+	if (usages.length === 0) return {
+		css,
+		mergeMap: /* @__PURE__ */ new Map(),
+		patterns: [],
+		stats: {
+			originalClasses: classToDeclaration.size,
+			mergedPatterns: 0,
+			estimatedBytesSaved: 0
+		}
+	};
+	log(`Analyzing ${usages.length} class usage sites`);
+	const patterns = findFrequentPatterns(usages, minFrequency, maxPatternSize);
+	log(`Found ${patterns.length} frequent patterns`);
+	const mergeMap = /* @__PURE__ */ new Map();
+	const cssRules = [];
+	const usedClasses = /* @__PURE__ */ new Set();
+	let totalBytesSaved = 0;
+	for (const pattern of patterns) {
+		const declarations = [];
+		let allFound = true;
+		for (const cls of pattern.originalClasses) {
+			const decl = classToDeclaration.get(cls);
+			if (decl) declarations.push(decl);
+			else {
+				allFound = false;
+				break;
+			}
+		}
+		if (!allFound || declarations.length === 0) continue;
+		let hasConflict = false;
+		for (const cls of pattern.originalClasses) if (usedClasses.has(cls)) {
+			hasConflict = true;
+			break;
+		}
+		if (hasConflict) continue;
+		const mergedClass = hashMergedClassName(declarations);
+		pattern.mergedClass = mergedClass;
+		pattern.declarations = declarations;
+		const mergeKey = pattern.originalClasses.join(" ");
+		mergeMap.set(mergeKey, mergedClass);
+		for (const cls of pattern.originalClasses) usedClasses.add(cls);
+		const declStr = declarations.join(";");
+		if (pretty) cssRules.push(`.${mergedClass} { ${declStr.replace(/;/g, "; ")} }`);
+		else cssRules.push(`.${mergedClass}{${declStr}}`);
+		totalBytesSaved += pattern.bytesSaved;
+	}
+	const originalRules = [];
+	const rulePattern = /\.([a-zA-Z_][a-zA-Z0-9_-]*)\{([^}]+)\}/g;
+	let match;
+	rulePattern.lastIndex = 0;
+	while ((match = rulePattern.exec(css)) !== null) {
+		const cls = match[1];
+		if (!usedClasses.has(cls)) originalRules.push(match[0]);
+	}
+	const mediaPattern = /@media[^{]+\{[^}]+\}/g;
+	mediaPattern.lastIndex = 0;
+	while ((match = mediaPattern.exec(css)) !== null) originalRules.push(match[0]);
+	const pseudoPattern = /\.([a-zA-Z_][a-zA-Z0-9_-]*)(:[a-zA-Z-]+)\{([^}]+)\}/g;
+	pseudoPattern.lastIndex = 0;
+	while ((match = pseudoPattern.exec(css)) !== null) originalRules.push(match[0]);
+	const separator = pretty ? "\n" : "";
+	const optimizedCss = [...cssRules, ...originalRules].join(separator);
+	const actualPatterns = patterns.filter((p) => p.mergedClass !== "");
+	log(`Merged ${actualPatterns.length} patterns`);
+	log(`Estimated savings: ${totalBytesSaved} bytes`);
+	return {
+		css: optimizedCss,
+		mergeMap,
+		patterns: actualPatterns,
+		stats: {
+			originalClasses: classToDeclaration.size,
+			mergedPatterns: actualPatterns.length,
+			estimatedBytesSaved: totalBytesSaved
+		}
+	};
+}
+
+//#endregion
+//#region src/css-optimizer/extractors.ts
+/**
+* HTML Class Extractor
+*
+* Extracts class usages from HTML content by parsing class="" attributes.
+* Works with static HTML, SSR output, template strings, etc.
+*/
+var HtmlExtractor = class {
+	name = "html";
+	pattern = /class\s*=\s*"([^"]+)"/g;
+	extract(content, options = {}) {
+		const { classPrefix = "_", minClasses = 2, source = "html" } = options;
+		const usages = [];
+		let match;
+		this.pattern.lastIndex = 0;
+		while ((match = this.pattern.exec(content)) !== null) {
+			const classValue = match[1].trim();
+			if (!classValue) continue;
+			const classes = classValue.split(/\s+/).filter((c) => c.startsWith(classPrefix) && c.length > classPrefix.length);
+			if (classes.length >= minClasses) {
+				classes.sort();
+				usages.push({
+					classes,
+					source: `${source}:${match.index}`
+				});
+			}
+		}
+		return usages;
+	}
+};
+/**
+* JSX Class Extractor (simplified)
+*
+* Extracts class usages from JSX/TSX by finding className attributes.
+* Note: This is a simplified regex-based extractor. For full AST support,
+* consider using @babel/parser or TypeScript compiler.
+*/
+var JsxExtractor = class {
+	name = "jsx";
+	stringPattern = /className\s*=\s*"([^"]+)"/g;
+	templatePattern = /className\s*=\s*\{['"`]([^'"`]+)['"`]\}/g;
+	extract(content, options = {}) {
+		const { classPrefix = "_", minClasses = 2, source = "jsx" } = options;
+		const usages = [];
+		this.extractFromPattern(content, this.stringPattern, classPrefix, minClasses, source, usages);
+		this.extractFromPattern(content, this.templatePattern, classPrefix, minClasses, source, usages);
+		return usages;
+	}
+	extractFromPattern(content, pattern, classPrefix, minClasses, source, usages) {
+		let match;
+		pattern.lastIndex = 0;
+		while ((match = pattern.exec(content)) !== null) {
+			const classValue = match[1].trim();
+			if (!classValue) continue;
+			const classes = classValue.split(/\s+/).filter((c) => c.startsWith(classPrefix) && c.length > classPrefix.length);
+			if (classes.length >= minClasses) {
+				classes.sort();
+				usages.push({
+					classes,
+					source: `${source}:${match.index}`
+				});
+			}
+		}
+	}
+};
+/**
+* Svelte Class Extractor (simplified)
+*
+* Extracts class usages from Svelte templates.
+* Handles both class="..." and class:directive syntax.
+*/
+var SvelteExtractor = class {
+	name = "svelte";
+	classPattern = /class\s*=\s*"([^"]+)"/g;
+	extract(content, options = {}) {
+		const { classPrefix = "_", minClasses = 2, source = "svelte" } = options;
+		const usages = [];
+		let match;
+		this.classPattern.lastIndex = 0;
+		while ((match = this.classPattern.exec(content)) !== null) {
+			const classValue = match[1].trim();
+			if (!classValue) continue;
+			const classes = classValue.replace(/\{[^}]+\}/g, " ").split(/\s+/).filter((c) => c.startsWith(classPrefix) && c.length > classPrefix.length);
+			if (classes.length >= minClasses) {
+				classes.sort();
+				usages.push({
+					classes,
+					source: `${source}:${match.index}`
+				});
+			}
+		}
+		return usages;
+	}
+};
+/**
+* Multi-source extractor
+*
+* Combines usages from multiple sources/extractors.
+* Useful for analyzing entire projects with mixed file types.
+*/
+var MultiExtractor = class {
+	name = "multi";
+	extractors;
+	constructor() {
+		this.extractors = new Map([
+			["html", new HtmlExtractor()],
+			["jsx", new JsxExtractor()],
+			["tsx", new JsxExtractor()],
+			["svelte", new SvelteExtractor()]
+		]);
+	}
+	/**
+	* Register a custom extractor for a file extension
+	*/
+	register(extension, extractor) {
+		this.extractors.set(extension, extractor);
+	}
+	/**
+	* Extract from content using the appropriate extractor
+	*/
+	extract(content, options = {}) {
+		return this.extractors.get("html").extract(content, options);
+	}
+	/**
+	* Extract from content with explicit file type
+	*/
+	extractWithType(content, fileType, options = {}) {
+		return (this.extractors.get(fileType) || this.extractors.get("html")).extract(content, options);
+	}
+	/**
+	* Extract from multiple files
+	*/
+	extractFromFiles(files, options = {}) {
+		const allUsages = [];
+		for (const file of files) {
+			const ext = file.path.split(".").pop() || "html";
+			const usages = (this.extractors.get(ext) || this.extractors.get("html")).extract(file.content, {
+				...options,
+				source: file.path
+			});
+			allUsages.push(...usages);
+		}
+		return allUsages;
+	}
+};
+const htmlExtractor = new HtmlExtractor();
+const jsxExtractor = new JsxExtractor();
+const svelteExtractor = new SvelteExtractor();
+const multiExtractor = new MultiExtractor();
+
+//#endregion
+//#region src/css-optimizer/transformers.ts
+/**
+* HTML Transformer
+*
+* Transforms HTML by replacing class="" attribute values with merged classes.
+*/
+var HtmlTransformer = class {
+	name = "html";
+	pattern = /class\s*=\s*"([^"]+)"/g;
+	transform(content, mergeMap, options = {}) {
+		if (mergeMap.size === 0) return content;
+		const { classPrefix = "_" } = options;
+		const sortedKeys = [...mergeMap.keys()].sort((a, b) => b.length - a.length);
+		return content.replace(this.pattern, (match, classValue) => {
+			const classes = classValue.trim().split(/\s+/);
+			const prefixedClasses = classes.filter((c) => c.startsWith(classPrefix));
+			const otherClasses = classes.filter((c) => !c.startsWith(classPrefix));
+			prefixedClasses.sort();
+			let result = [...prefixedClasses];
+			const merged = [];
+			for (const key of sortedKeys) {
+				const patternClasses = key.split(" ");
+				const mergedClass = mergeMap.get(key);
+				let allPresent = true;
+				for (const cls of patternClasses) if (!result.includes(cls)) {
+					allPresent = false;
+					break;
+				}
+				if (allPresent) {
+					result = result.filter((c) => !patternClasses.includes(c));
+					merged.push(mergedClass);
+				}
+			}
+			return `class="${[
+				...merged,
+				...result,
+				...otherClasses
+			].join(" ")}"`;
+		});
+	}
+};
+/**
+* JSX Transformer
+*
+* Transforms JSX/TSX by replacing className attribute values.
+*/
+var JsxTransformer = class {
+	name = "jsx";
+	stringPattern = /className\s*=\s*"([^"]+)"/g;
+	transform(content, mergeMap, options = {}) {
+		if (mergeMap.size === 0) return content;
+		const { classPrefix = "_" } = options;
+		const sortedKeys = [...mergeMap.keys()].sort((a, b) => b.length - a.length);
+		return content.replace(this.stringPattern, (match, classValue) => {
+			const classes = classValue.trim().split(/\s+/);
+			const prefixedClasses = classes.filter((c) => c.startsWith(classPrefix));
+			const otherClasses = classes.filter((c) => !c.startsWith(classPrefix));
+			prefixedClasses.sort();
+			let result = [...prefixedClasses];
+			const merged = [];
+			for (const key of sortedKeys) {
+				const patternClasses = key.split(" ");
+				const mergedClass = mergeMap.get(key);
+				let allPresent = true;
+				for (const cls of patternClasses) if (!result.includes(cls)) {
+					allPresent = false;
+					break;
+				}
+				if (allPresent) {
+					result = result.filter((c) => !patternClasses.includes(c));
+					merged.push(mergedClass);
+				}
+			}
+			return `className="${[
+				...merged,
+				...result,
+				...otherClasses
+			].join(" ")}"`;
+		});
+	}
+};
+/**
+* Svelte Transformer
+*
+* Transforms Svelte templates by replacing class attribute values.
+* Preserves dynamic {expression} syntax.
+*/
+var SvelteTransformer = class {
+	name = "svelte";
+	pattern = /class\s*=\s*"([^"]+)"/g;
+	transform(content, mergeMap, options = {}) {
+		if (mergeMap.size === 0) return content;
+		const { classPrefix = "_" } = options;
+		const sortedKeys = [...mergeMap.keys()].sort((a, b) => b.length - a.length);
+		return content.replace(this.pattern, (match, classValue) => {
+			const expressions = [];
+			const classes = classValue.replace(/\{[^}]+\}/g, (expr) => {
+				expressions.push(expr);
+				return `__EXPR_${expressions.length - 1}__`;
+			}).trim().split(/\s+/);
+			const prefixedClasses = classes.filter((c) => c.startsWith(classPrefix) && !c.startsWith("__EXPR_"));
+			const otherClasses = classes.filter((c) => !c.startsWith(classPrefix) || c.startsWith("__EXPR_"));
+			prefixedClasses.sort();
+			let result = [...prefixedClasses];
+			const merged = [];
+			for (const key of sortedKeys) {
+				const patternClasses = key.split(" ");
+				const mergedClass = mergeMap.get(key);
+				let allPresent = true;
+				for (const cls of patternClasses) if (!result.includes(cls)) {
+					allPresent = false;
+					break;
+				}
+				if (allPresent) {
+					result = result.filter((c) => !patternClasses.includes(c));
+					merged.push(mergedClass);
+				}
+			}
+			let finalClasses = [
+				...merged,
+				...result,
+				...otherClasses
+			].join(" ");
+			expressions.forEach((expr, i) => {
+				finalClasses = finalClasses.replace(`__EXPR_${i}__`, expr);
+			});
+			return `class="${finalClasses}"`;
+		});
+	}
+};
+/**
+* Multi-format transformer
+*
+* Automatically selects the appropriate transformer based on content or file type.
+*/
+var MultiTransformer = class {
+	name = "multi";
+	transformers;
+	constructor() {
+		this.transformers = new Map([
+			["html", new HtmlTransformer()],
+			["jsx", new JsxTransformer()],
+			["tsx", new JsxTransformer()],
+			["svelte", new SvelteTransformer()]
+		]);
+	}
+	/**
+	* Register a custom transformer for a file extension
+	*/
+	register(extension, transformer) {
+		this.transformers.set(extension, transformer);
+	}
+	transform(content, mergeMap, options) {
+		return this.transformers.get("html").transform(content, mergeMap, options);
+	}
+	/**
+	* Transform with explicit file type
+	*/
+	transformWithType(content, mergeMap, fileType, options) {
+		return (this.transformers.get(fileType) || this.transformers.get("html")).transform(content, mergeMap, options);
+	}
+	/**
+	* Transform multiple files
+	*/
+	transformFiles(files, mergeMap, options) {
+		return files.map((file) => {
+			const ext = file.path.split(".").pop() || "html";
+			const transformer = this.transformers.get(ext) || this.transformers.get("html");
+			return {
+				path: file.path,
+				content: transformer.transform(file.content, mergeMap, options)
+			};
+		});
+	}
+};
+const htmlTransformer = new HtmlTransformer();
+const jsxTransformer = new JsxTransformer();
+const svelteTransformer = new SvelteTransformer();
+const multiTransformer = new MultiTransformer();
+
+//#endregion
+//#region src/css-optimizer/merge.ts
+/**
+* Optimize CSS by merging co-occurring classes (Luna convenience wrapper)
+*
+* This is a convenience function that:
+* 1. Extracts class usages from HTML using HtmlExtractor
+* 2. Converts Luna's declaration mapping format
+* 3. Calls the core optimizer
+*
+* For non-Luna projects, use the `optimize` function instead.
+*
+* @param css - Original CSS content
+* @param html - HTML content to analyze
+* @param declarationMapping - Luna's declaration -> class name mapping
+* @param options - Optimization options
+*/
+function optimizeCss(css, html, declarationMapping, options = {}) {
+	const { classPrefix = "_", verbose = false } = options;
+	const log = (msg) => {
+		if (verbose) console.log(`[optimizer] ${msg}`);
+	};
+	const usages = htmlExtractor.extract(html, {
+		classPrefix,
+		source: "html"
+	});
+	log(`Found ${usages.length} class usage sites`);
+	if (usages.length === 0) return {
+		css,
+		mergeMap: /* @__PURE__ */ new Map(),
+		patterns: [],
+		stats: {
+			originalClasses: Object.keys(declarationMapping).length,
+			mergedPatterns: 0,
+			estimatedBytesSaved: 0
+		}
+	};
+	const classToDecl = /* @__PURE__ */ new Map();
+	for (const [decl, cls] of Object.entries(declarationMapping)) classToDecl.set(cls, decl);
+	return optimizeCore(usages, css, classToDecl, options);
+}
+/**
+* Apply optimization to HTML by replacing class combinations (Luna convenience wrapper)
+*
+* This is a convenience function that uses HtmlTransformer.
+* For non-Luna projects, use the transformer directly.
+*
+* @param html - HTML content to transform
+* @param mergeMap - Merge map from optimizeCss result
+* @param classPrefix - Class prefix (default: "_")
+*/
+function optimizeHtml(html, mergeMap, classPrefix = "_") {
+	return htmlTransformer.transform(html, mergeMap, { classPrefix });
+}
+
+//#endregion
+//#region src/vite-plugin.ts
+const CSS_START_MARKER = "/* LUNA_CSS_START */";
+const CSS_END_MARKER = "/* LUNA_CSS_END */";
+const VIRTUAL_CSS_ID = "virtual:luna.css";
+const VIRTUAL_SHARED_CSS_ID = "virtual:luna-shared.css";
+const VIRTUAL_RUNTIME_ID = "virtual:luna-css-runtime";
+const RESOLVED_VIRTUAL_CSS_ID = "\0" + VIRTUAL_CSS_ID;
+const RESOLVED_VIRTUAL_SHARED_CSS_ID = "\0" + VIRTUAL_SHARED_CSS_ID;
+const RESOLVED_VIRTUAL_RUNTIME_ID = "\0" + VIRTUAL_RUNTIME_ID;
+/**
+* Generate inline dev runtime code
+* Uses import.meta.env.DEV for tree-shaking in production builds
+*/
+function generateRuntimeCode() {
+	return `
+// Luna CSS Dev Runtime - Auto-generated
+// Production: DCE removes dev-only code via import.meta.env.DEV
+
+// Hash functions (shared between dev and prod for class name generation)
+function djb2Hash(s) {
+  let hash = 5381;
+  for (let i = 0; i < s.length; i++) {
+    hash = ((hash << 5) + hash + s.charCodeAt(i)) >>> 0;
+  }
+  return hash;
+}
+
+function toBase36(n) {
+  const chars = "0123456789abcdefghijklmnopqrstuvwxyz";
+  n = n & 0xffffff;
+  if (n === 0) return "0";
+  let result = "";
+  while (n > 0) { result = chars[n % 36] + result; n = Math.floor(n / 36); }
+  return result;
+}
+
+function hashClassName(decl) { return "_" + toBase36(djb2Hash(decl)); }
+
+// Dev-only: runtime CSS injection
+let devState;
+let devInject;
+
+if (import.meta.env.DEV) {
+  devState = { rules: new Map(), styleEl: null, initialized: false };
+
+  const init = () => {
+    if (devState.initialized || typeof document === "undefined") return;
+    devState.styleEl = document.createElement("style");
+    devState.styleEl.id = "luna-dev-css";
+    document.head.appendChild(devState.styleEl);
+    devState.initialized = true;
+  };
+
+  devInject = (className, rule) => {
+    init();
+    if (devState.rules.has(className)) return;
+    devState.rules.set(className, rule);
+    if (devState.styleEl) devState.styleEl.textContent += rule;
+    console.warn("[luna-css] Generated at runtime:", rule, "\\n  → Run 'luna css extract' to pre-generate");
+  };
+}
+
+export function css(prop, val) {
+  const decl = prop + ":" + val;
+  const cls = hashClassName(decl);
+  if (import.meta.env.DEV && devInject) {
+    devInject(cls, "." + cls + "{" + decl + "}");
+  }
+  return cls;
+}
+
+export function styles(pairs) { return pairs.map(([p, v]) => css(p, v)).join(" "); }
+
+export function on(pseudo, prop, val) {
+  const key = pseudo + ":" + prop + ":" + val;
+  const cls = hashClassName(key);
+  if (import.meta.env.DEV && devInject) {
+    devInject(cls, "." + cls + pseudo + "{" + prop + ":" + val + "}");
+  }
+  return cls;
+}
+
+export function hover(p, v) { return on(":hover", p, v); }
+export function focus(p, v) { return on(":focus", p, v); }
+export function active(p, v) { return on(":active", p, v); }
+export function combine(classes) { return classes.filter(Boolean).join(" "); }
+
+// Dev-only utilities
+export function getGeneratedCount() {
+  if (import.meta.env.DEV && devState) {
+    return devState.rules.size;
+  }
+  return 0;
+}
+
+export function getGeneratedCss() {
+  if (import.meta.env.DEV && devState) {
+    return Array.from(devState.rules.values()).join("");
+  }
+  return "";
+}
+`;
+}
+/**
+* Inject dev runtime script into HTML
+*/
+function injectDevRuntime(html) {
+	return html.replace("</head>", "<script type=\"module\">\nimport { css, hover, focus, styles, combine } from \"virtual:luna-css-runtime\";\nwindow.__lunaCss = { css, hover, focus, styles, combine };\n<\/script>\n</head>");
+}
+/**
+* Luna CSS Vite Plugin
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { lunaCss } from "@luna_ui/luna/vite-plugin";
+*
+* export default defineConfig({
+*   plugins: [
+*     lunaCss({
+*       src: ["src/examples/todomvc"],
+*       mode: "auto",
+*       threshold: 4096,
+*     }),
+*   ],
+* });
+* ```
+*
+* @example
+* ```ts
+* // main.ts - Import virtual CSS like Tailwind
+* import "virtual:luna.css";
+* ```
+*
+* @example
+* ```ts
+* // Split mode with per-directory chunks
+* lunaCss({
+*   src: ["src"],
+*   split: true,
+*   sharedThreshold: 3,
+* })
+*
+* // In your entry:
+* import "virtual:luna.css";           // All CSS
+* // Or for fine-grained control:
+* import "virtual:luna-shared.css";    // Shared CSS only
+* import "virtual:luna-chunk/todomvc.css"; // Per-directory chunk
+* ```
+*/
+function lunaCss(options = {}) {
+	const { src = ["src"], mode = "auto", threshold = 4096, cssFileName = "luna", verbose = false, split = false, sharedThreshold = 3, devRuntime, injectRuntime = true, experimental = {} } = options;
+	const { optimize: enableOptimize = false, optimizeMinFrequency = 2, optimizeMaxPatternSize = 5 } = experimental;
+	const srcDirs = Array.isArray(src) ? src : [src];
+	let config;
+	let cachedCss = null;
+	let cachedSplitResult = null;
+	let cachedMapping = {};
+	let cachedMergeMap = null;
+	let cachedOptimizedCss = null;
+	let lastExtractTime = 0;
+	const pluginCwd = process.cwd();
+	const log = (msg) => {
+		if (verbose || enableOptimize) console.log(`[luna-css] ${msg}`);
+	};
+	const resolveSrcDir = (dir) => {
+		if (path.isAbsolute(dir)) return dir;
+		const configDir = config.configFile ? path.dirname(config.configFile) : pluginCwd;
+		return path.resolve(configDir, dir);
+	};
+	const extractCss = () => {
+		const now = Date.now();
+		if (cachedCss && now - lastExtractTime < 1e3) return {
+			css: cachedCss,
+			mapping: cachedMapping
+		};
+		let allCss = "";
+		const seenRules = /* @__PURE__ */ new Set();
+		const combinedMapping = {};
+		for (const dir of srcDirs) {
+			const fullPath = resolveSrcDir(dir);
+			if (fs.existsSync(fullPath)) {
+				const { css, mapping } = extract(fullPath, { warn: false });
+				Object.assign(combinedMapping, mapping);
+				for (const rule of css.split("}")) {
+					const trimmed = rule.trim();
+					if (trimmed && !seenRules.has(trimmed)) {
+						seenRules.add(trimmed);
+						allCss += trimmed + "}";
+					}
+				}
+			} else log(`Warning: Source directory not found: ${fullPath}`);
+		}
+		cachedCss = allCss;
+		cachedMapping = combinedMapping;
+		lastExtractTime = now;
+		log(`Extracted ${allCss.length} bytes of CSS from ${srcDirs.join(", ")}`);
+		return {
+			css: allCss,
+			mapping: combinedMapping
+		};
+	};
+	const findHtmlFiles = (dir) => {
+		const files = [];
+		const walk = (currentDir) => {
+			if (!fs.existsSync(currentDir)) return;
+			const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+			for (const entry of entries) {
+				const fullPath = path.join(currentDir, entry.name);
+				if (entry.isDirectory() && ![
+					"node_modules",
+					".git",
+					"dist",
+					"target"
+				].includes(entry.name)) walk(fullPath);
+				else if (entry.isFile() && entry.name.endsWith(".html")) files.push(fullPath);
+			}
+		};
+		walk(dir);
+		return files;
+	};
+	const runOptimization = () => {
+		if (!enableOptimize) return null;
+		const { css, mapping } = extractCss();
+		if (!css) return null;
+		const htmlFilePaths = findHtmlFiles(config.configFile ? path.dirname(config.configFile) : pluginCwd);
+		if (htmlFilePaths.length === 0) {
+			log("[experimental] No HTML files found for optimization");
+			return null;
+		}
+		let combinedHtml = "";
+		for (const htmlPath of htmlFilePaths) try {
+			combinedHtml += fs.readFileSync(htmlPath, "utf-8");
+		} catch (e) {}
+		if (!combinedHtml) return null;
+		log(`[experimental] Running CSS co-occurrence optimization on ${htmlFilePaths.length} HTML file(s)...`);
+		const optimizeResult = optimizeCss(css, combinedHtml, mapping, {
+			minFrequency: optimizeMinFrequency,
+			maxPatternSize: optimizeMaxPatternSize,
+			verbose
+		});
+		if (optimizeResult.patterns.length > 0) {
+			log(`[experimental] Merged ${optimizeResult.stats.mergedPatterns} patterns`);
+			log(`[experimental] Estimated savings: ${optimizeResult.stats.estimatedBytesSaved} bytes`);
+			for (const pattern of optimizeResult.patterns) log(`[experimental]   ${pattern.originalClasses.join(" ")} -> ${pattern.mergedClass} (${pattern.frequency}x)`);
+			return {
+				css: optimizeResult.css,
+				mergeMap: optimizeResult.mergeMap
+			};
+		}
+		log("[experimental] No patterns found for optimization");
+		return null;
+	};
+	const getOptimizedCss = () => {
+		if (!enableOptimize) return extractCss().css;
+		if (cachedOptimizedCss !== null && cachedMergeMap !== null) return cachedOptimizedCss;
+		const result = runOptimization();
+		if (result) {
+			cachedOptimizedCss = result.css;
+			cachedMergeMap = result.mergeMap;
+			return result.css;
+		}
+		return extractCss().css;
+	};
+	const extractSplitCss = () => {
+		const now = Date.now();
+		if (cachedSplitResult && now - lastExtractTime < 1e3) return cachedSplitResult;
+		const combinedChunks = /* @__PURE__ */ new Map();
+		let combinedSharedCss = "";
+		let combinedCss = "";
+		const combinedMapping = {};
+		const combinedStats = /* @__PURE__ */ new Map();
+		for (const dir of srcDirs) {
+			const fullPath = resolveSrcDir(dir);
+			if (fs.existsSync(fullPath)) {
+				const result = extractSplit(fullPath, "dir", {
+					warn: false,
+					sharedThreshold
+				});
+				for (const [key, chunk] of result.chunks) {
+					const prefixedKey = srcDirs.length > 1 ? `${dir}/${key}` : key;
+					combinedChunks.set(prefixedKey, chunk);
+				}
+				if (result.shared.css) combinedSharedCss += result.shared.css;
+				combinedCss += result.combined;
+				Object.assign(combinedMapping, result.mapping);
+				for (const [key, stat] of result.stats) {
+					const prefixedKey = srcDirs.length > 1 ? `${dir}/${key}` : key;
+					combinedStats.set(prefixedKey, stat);
+				}
+			}
+		}
+		cachedSplitResult = {
+			chunks: combinedChunks,
+			shared: {
+				css: combinedSharedCss,
+				styles: {
+					base: /* @__PURE__ */ new Set(),
+					pseudo: [],
+					media: []
+				}
+			},
+			combined: combinedCss,
+			mapping: combinedMapping,
+			stats: combinedStats
+		};
+		lastExtractTime = now;
+		log(`Split extracted: ${combinedChunks.size} chunks, ${combinedSharedCss.length} bytes shared`);
+		return cachedSplitResult;
+	};
+	const determineMode = (css) => {
+		if (mode === "auto") return css.length > threshold ? "external" : "inline";
+		return mode === "external" ? "external" : "inline";
+	};
+	const injectInline = (html, css) => {
+		const startIdx = html.indexOf(CSS_START_MARKER);
+		const endIdx = html.indexOf(CSS_END_MARKER);
+		if (startIdx === -1 || endIdx === -1) {
+			log("Warning: CSS markers not found in HTML");
+			return html;
+		}
+		return `${html.substring(0, startIdx + 20)}\n    ${css}\n    ${html.substring(endIdx)}`;
+	};
+	return {
+		name: "luna-css",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_CSS_ID) return RESOLVED_VIRTUAL_CSS_ID;
+			if (id === VIRTUAL_SHARED_CSS_ID) return RESOLVED_VIRTUAL_SHARED_CSS_ID;
+			if (id === VIRTUAL_RUNTIME_ID) return RESOLVED_VIRTUAL_RUNTIME_ID;
+			if (id.startsWith("virtual:luna-chunk/")) return "\0" + id;
+		},
+		load(id) {
+			if (id === RESOLVED_VIRTUAL_CSS_ID) {
+				if (split) return extractSplitCss().combined;
+				if (config.command === "build" && enableOptimize) return getOptimizedCss();
+				return extractCss().css;
+			}
+			if (id === RESOLVED_VIRTUAL_SHARED_CSS_ID) {
+				if (!split) {
+					log("Warning: virtual:luna-shared.css used without split mode");
+					return "";
+				}
+				return extractSplitCss().shared.css;
+			}
+			if (id === RESOLVED_VIRTUAL_RUNTIME_ID) return generateRuntimeCode();
+			if (id.startsWith("\0virtual:luna-chunk/")) {
+				const chunkName = id.replace("\0virtual:luna-chunk/", "").replace(".css", "");
+				if (!split) {
+					log(`Warning: virtual:luna-chunk/${chunkName}.css used without split mode`);
+					return "";
+				}
+				const chunk = extractSplitCss().chunks.get(chunkName);
+				if (chunk) return chunk.css;
+				log(`Warning: Chunk "${chunkName}" not found`);
+				return "";
+			}
+		},
+		transformIndexHtml: {
+			order: "pre",
+			handler(html, ctx) {
+				const isBuild = config.command === "build";
+				const isDev = !isBuild;
+				const shouldInjectRuntime = injectRuntime && (devRuntime ?? isDev) && isDev;
+				if (split && isBuild) {
+					const result$1 = extractSplitCss();
+					const sharedCss = result$1.shared.css;
+					const combinedCss = result$1.combined;
+					log(`Split mode build: ${result$1.chunks.size} chunks, ${sharedCss.length} bytes shared`);
+					return injectInline(html, combinedCss);
+				}
+				const { css } = extractCss();
+				if (!css) {
+					if (shouldInjectRuntime) return injectDevRuntime(html);
+					return html;
+				}
+				let finalCss = css;
+				let finalHtml = html;
+				if (enableOptimize && isBuild) {
+					finalCss = getOptimizedCss();
+					if (cachedMergeMap && cachedMergeMap.size > 0) finalHtml = optimizeHtml(html, cachedMergeMap);
+				}
+				log(`Mode: ${determineMode(finalCss)}, Build: ${isBuild} (${finalCss.length} bytes)`);
+				let result = injectInline(finalHtml, finalCss);
+				if (shouldInjectRuntime) result = injectDevRuntime(result);
+				return result;
+			}
+		},
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				if (req.url === `/${cssFileName}.css`) {
+					const { css } = extractCss();
+					res.setHeader("Content-Type", "text/css");
+					res.setHeader("Cache-Control", "no-cache");
+					res.end(css);
+					return;
+				}
+				next();
+			});
+			for (const dir of srcDirs) {
+				const fullPath = resolveSrcDir(dir);
+				if (fs.existsSync(fullPath)) server.watcher.add(`${fullPath}/**/*.mbt`);
+			}
+			server.watcher.on("change", (file) => {
+				if (file.endsWith(".mbt")) {
+					log(`File changed: ${file}`);
+					cachedCss = null;
+					cachedSplitResult = null;
+					cachedMergeMap = null;
+					cachedOptimizedCss = null;
+					const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_CSS_ID);
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					const sharedMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_SHARED_CSS_ID);
+					if (sharedMod) server.moduleGraph.invalidateModule(sharedMod);
+					server.ws.send({ type: "full-reload" });
+				}
+			});
+		}
+	};
+}
+var vite_plugin_default = lunaCss;
+
+//#endregion
+export { vite_plugin_default as default, lunaCss };