@vueland/utils-jit 0.2.0

package/dist/index.cjs

@@ -0,0 +1,840 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+//#region src/core.ts
+const DEFAULT_INCLUDE = [/\.(vue|js|ts|jsx|tsx|html)$/];
+const DEFAULT_EXCLUDE = [
+	/(^|[/\\])node_modules([/\\]|$)/,
+	/(^|[/\\])\.git([/\\]|$)/,
+	/(^|[/\\])dist([/\\]|$)/,
+	/(^|[/\\])build([/\\]|$)/,
+	/(^|[/\\])coverage([/\\]|$)/,
+	/(^|[/\\])\.output([/\\]|$)/,
+	/(^|[/\\])\.nuxt([/\\]|$)/,
+	/(^|[/\\])\.turbo([/\\]|$)/,
+	/(^|[/\\])\.generated([/\\]|$)/,
+	/(^|[/\\])storybook-static([/\\]|$)/,
+	/(^|[/\\])playwright-report([/\\]|$)/
+];
+const DEFAULT_BREAKPOINTS = {
+	sm: 640,
+	md: 768,
+	lg: 1024,
+	xl: 1280,
+	"2xl": 1536
+};
+const DEFAULT_VARIANTS = {
+	hover: {
+		kind: "pseudo",
+		value: "hover"
+	},
+	focus: {
+		kind: "pseudo",
+		value: "focus"
+	},
+	"focus-visible": {
+		kind: "pseudo",
+		value: "focus-visible"
+	},
+	"focus-within": {
+		kind: "pseudo",
+		value: "focus-within"
+	},
+	active: {
+		kind: "pseudo",
+		value: "active"
+	},
+	disabled: {
+		kind: "pseudo",
+		value: "disabled"
+	},
+	checked: {
+		kind: "pseudo",
+		value: "checked"
+	},
+	visited: {
+		kind: "pseudo",
+		value: "visited"
+	},
+	first: {
+		kind: "pseudo",
+		value: "first-child"
+	},
+	last: {
+		kind: "pseudo",
+		value: "last-child"
+	},
+	odd: {
+		kind: "pseudo",
+		value: "nth-child(odd)"
+	},
+	even: {
+		kind: "pseudo",
+		value: "nth-child(even)"
+	}
+};
+const MIN_TOKEN_LENGTH = 5;
+const MAX_TOKEN_LENGTH = 180;
+const MAX_VALUE_LENGTH = 160;
+function normalizePath$1(value) {
+	return value.replace(/\\/g, "/");
+}
+function matchesPattern$1(value, pattern) {
+	const normalized = normalizePath$1(value);
+	if (typeof pattern === "string") return normalized.includes(normalizePath$1(pattern));
+	pattern.lastIndex = 0;
+	return pattern.test(normalized);
+}
+function shouldProcess(id, include = DEFAULT_INCLUDE, exclude = []) {
+	const cleanId = id.split("?")[0];
+	if (!cleanId) return false;
+	if (exclude.some((pattern) => matchesPattern$1(cleanId, pattern))) return false;
+	return include.some((pattern) => matchesPattern$1(cleanId, pattern));
+}
+function escapeCssSelector(value) {
+	return value.replace(/[^a-zA-Z0-9_-]/g, (char) => `\\${char}`);
+}
+function normalizeValue(value) {
+	return value.trim().replace(/\s+/g, " ");
+}
+function isSafeCssValue(value) {
+	const normalized = normalizeValue(value);
+	if (!normalized) return false;
+	if (normalized.length > MAX_VALUE_LENGTH) return false;
+	if (/[;{}<>]/.test(normalized)) return false;
+	if (/\/\*/.test(normalized) || /\*\//.test(normalized)) return false;
+	if (!/[a-zA-Z0-9]/.test(normalized)) return false;
+	return /^[-a-zA-Z0-9.%_(),+/*\s[\]#]+$/.test(normalized);
+}
+function stripEdgeGarbage(token) {
+	return token.replace(/^['"`{(]+|['"`})>,;]+$/g, "");
+}
+function looksLikeArbitraryUtility(token) {
+	if (!token) return false;
+	if (token.length < MIN_TOKEN_LENGTH || token.length > MAX_TOKEN_LENGTH) return false;
+	if (!token.includes("-[") || !token.endsWith("]")) return false;
+	if (token.startsWith("<") || token.startsWith(">")) return false;
+	return token.indexOf("-[") > 0;
+}
+function stripComments(code) {
+	return code.replace(/<!--[\s\S]*?-->/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/.*$/gm, "$1 ");
+}
+function extractClassCandidates(code) {
+	const candidates = [];
+	for (const pattern of [
+		/(?:^|[\s<]):class\s*=\s*"([^"]*)"/g,
+		/(?:^|[\s<]):class\s*=\s*'([^']*)'/g,
+		/(?:^|[\s<])class\s*=\s*"([^"]*)"/g,
+		/(?:^|[\s<])class\s*=\s*'([^']*)'/g
+	]) for (const match of code.matchAll(pattern)) {
+		const value = match[1];
+		if (value) candidates.push(value);
+	}
+	return candidates;
+}
+function tokenizeChunk(code) {
+	const result = /* @__PURE__ */ new Set();
+	for (const match of code.matchAll(/(?:[a-zA-Z0-9_-]+:)*[a-zA-Z][a-zA-Z0-9_-]*-\[[^\]\s]+(?:\s+[^\]\s]+)*\]/g)) {
+		const raw = match[0];
+		const token = stripEdgeGarbage(raw);
+		if (looksLikeArbitraryUtility(token)) result.add(token);
+	}
+	return result;
+}
+function tokenize(code) {
+	const cleanCode = stripComments(code);
+	const classCandidates = extractClassCandidates(cleanCode);
+	if (classCandidates.length > 0) {
+		const result = /* @__PURE__ */ new Set();
+		for (const candidate of classCandidates) for (const token of tokenizeChunk(candidate)) result.add(token);
+		if (result.size > 0) return result;
+	}
+	return tokenizeChunk(cleanCode);
+}
+function parseToken(token) {
+	const parts = token.split(":").filter(Boolean);
+	if (!parts.length) return null;
+	const utility = parts[parts.length - 1];
+	const variants = parts.slice(0, -1);
+	if (!utility.includes("-[") || !utility.endsWith("]")) return null;
+	return {
+		raw: token,
+		variants,
+		utility
+	};
+}
+function camelToKebab(value) {
+	if (value.startsWith("--")) return value;
+	return value.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+}
+function withImportant(value, important) {
+	const normalized = String(value);
+	if (!important) return normalized;
+	if (/\s!important\s*$/i.test(normalized)) return normalized;
+	return `${normalized} !important`;
+}
+function objectToDeclarations(declaration, important) {
+	return Object.entries(declaration).map(([prop, value]) => {
+		return `${camelToKebab(prop)}: ${withImportant(value, important)};`;
+	});
+}
+function normalizeDeclarations(declaration, important) {
+	if (Array.isArray(declaration)) return declaration;
+	return objectToDeclarations(declaration, important);
+}
+function defineRule(options) {
+	const important = options.important ?? true;
+	return {
+		name: options.name,
+		match(utility) {
+			options.matcher.lastIndex = 0;
+			const match = utility.match(options.matcher);
+			if (!match) return null;
+			const rawValue = match[1];
+			if (!rawValue) return null;
+			const value = normalizeValue(rawValue);
+			if (!value || !isSafeCssValue(value)) return null;
+			if (options.validate && !options.validate(value)) return null;
+			return { declarations: normalizeDeclarations(options.declaration(value), important) };
+		}
+	};
+}
+const createArbitraryRule = defineRule;
+function resolveRule(utility, rules) {
+	for (const rule of rules) {
+		const match = rule.match(utility);
+		if (match) return { declarations: match.declarations };
+	}
+	return null;
+}
+function formatMathFunctions(value) {
+	return value.replace(/\b(calc|min|max|clamp)\(([^()]+)\)/g, (_match, fn, expr) => {
+		return `${fn}(${expr.replace(/\s*([+\-*/])\s*/g, " $1 ").replace(/\s+/g, " ").trim()})`;
+	});
+}
+function applySelectorVariant(selector, variant) {
+	if (variant.kind === "pseudo") return `${selector}:${variant.value}`;
+	if (variant.kind === "selector") {
+		const template = String(variant.value);
+		return template.includes("&") ? template.replace(/&/g, selector) : `${template} ${selector}`;
+	}
+	if (variant.kind === "attribute") return `${selector}${variant.value}`;
+	return null;
+}
+function buildCssRule(parsed, cssBody, breakpoints = DEFAULT_BREAKPOINTS, variants = DEFAULT_VARIANTS) {
+	let selector = `.${escapeCssSelector(parsed.raw)}`;
+	const mediaVariants = [];
+	for (const variantName of parsed.variants) {
+		if (variantName in breakpoints) {
+			mediaVariants.push(variantName);
+			continue;
+		}
+		const variant = variants[variantName];
+		if (!variant) return null;
+		if (variant.kind === "media") {
+			mediaVariants.push(variantName);
+			continue;
+		}
+		const nextSelector = applySelectorVariant(selector, variant);
+		if (!nextSelector) return null;
+		selector = nextSelector;
+	}
+	const body = cssBody.declarations.map((decl) => {
+		return decl.replace(/:\s*([^;]+)(;?)$/, (_match, value, semicolon) => {
+			return `: ${formatMathFunctions(value.trim())}${semicolon}`;
+		});
+	}).join("");
+	let result = `${selector}{${body}}`;
+	for (const variantName of mediaVariants.reverse()) {
+		const customVariant = variants[variantName];
+		const minWidth = typeof customVariant?.value === "number" ? customVariant.value : breakpoints[variantName];
+		if (typeof minWidth !== "number") return null;
+		result = `@media (min-width: ${minWidth}px) { ${result} }`;
+	}
+	return result;
+}
+//#endregion
+//#region src/validators.ts
+const CSS_NUMBER_RE = /^-?(?:\d+|\d*\.\d+)$/;
+const CSS_LENGTH_RE = new RegExp(`^-?(?:\\d+|\\d*\\.\\d+)${/(?:px|r?em|%|vw|vh|svw|svh|lvw|lvh|dvw|dvh|vmin|vmax|ch|ex|cm|mm|in|pt|pc)/.source}$`);
+const CSS_COLOR_KEYWORDS = new Set([
+	"transparent",
+	"currentColor",
+	"inherit",
+	"initial",
+	"unset",
+	"revert"
+]);
+const CSS_GLOBAL_VALUES = new Set([
+	"inherit",
+	"initial",
+	"unset",
+	"revert",
+	"revert-layer"
+]);
+function isNumberValue(value) {
+	return CSS_NUMBER_RE.test(value);
+}
+function isZeroValue(value) {
+	return value === "0" || value === "-0";
+}
+function isCssGlobalValue(value) {
+	return CSS_GLOBAL_VALUES.has(value);
+}
+function isFunctionalCssValue(value) {
+	return /^(?:calc|min|max|clamp|var)\(.+\)$/.test(value);
+}
+function isLengthLikeValue(value) {
+	return isZeroValue(value) || CSS_LENGTH_RE.test(value) || isFunctionalCssValue(value);
+}
+function isLengthListValue(value, maxItems = 4) {
+	const items = value.trim().split(/\s+/);
+	if (items.length === 0 || items.length > maxItems) return false;
+	return items.every((item) => isLengthLikeValue(item));
+}
+function isSizeValue(value) {
+	return isCssGlobalValue(value) || value === "auto" || isLengthLikeValue(value);
+}
+function isPaddingValue(value) {
+	return isCssGlobalValue(value) || isLengthListValue(value, 4);
+}
+function isMarginValue(value) {
+	if (isCssGlobalValue(value)) return true;
+	const items = value.trim().split(/\s+/);
+	if (items.length === 0 || items.length > 4) return false;
+	return items.every((item) => item === "auto" || isLengthLikeValue(item));
+}
+function isRadiusValue(value) {
+	return isCssGlobalValue(value) || isLengthListValue(value, 4);
+}
+function isPositionValue(value) {
+	return isCssGlobalValue(value) || value === "auto" || isLengthLikeValue(value);
+}
+function isZIndexValue(value) {
+	return isCssGlobalValue(value) || value === "auto" || CSS_NUMBER_RE.test(value) || /^var\(.+\)$/.test(value);
+}
+function isOpacityValue(value) {
+	if (isCssGlobalValue(value)) return true;
+	if (!CSS_NUMBER_RE.test(value)) return /^var\(.+\)$/.test(value);
+	const numeric = Number(value);
+	return numeric >= 0 && numeric <= 1;
+}
+function isColorValue(value) {
+	return isCssGlobalValue(value) || CSS_COLOR_KEYWORDS.has(value) || /^#[0-9a-fA-F]{3,8}$/.test(value) || /^(?:rgb|rgba|hsl|hsla|oklch|oklab|color)\(.+\)$/.test(value) || /^var\(.+\)$/.test(value);
+}
+//#endregion
+//#region src/rules.ts
+const defaultRules = [
+	defineRule({
+		name: "width",
+		matcher: /^w-\[(.+)\]$/,
+		validate: isSizeValue,
+		declaration: (value) => ({ width: value })
+	}),
+	defineRule({
+		name: "height",
+		matcher: /^h-\[(.+)\]$/,
+		validate: isSizeValue,
+		declaration: (value) => ({ height: value })
+	}),
+	defineRule({
+		name: "min-width",
+		matcher: /^min-w-\[(.+)\]$/,
+		validate: isSizeValue,
+		declaration: (value) => ({ minWidth: value })
+	}),
+	defineRule({
+		name: "max-width",
+		matcher: /^max-w-\[(.+)\]$/,
+		validate: isSizeValue,
+		declaration: (value) => ({ maxWidth: value })
+	}),
+	defineRule({
+		name: "min-height",
+		matcher: /^min-h-\[(.+)\]$/,
+		validate: isSizeValue,
+		declaration: (value) => ({ minHeight: value })
+	}),
+	defineRule({
+		name: "max-height",
+		matcher: /^max-h-\[(.+)\]$/,
+		validate: isSizeValue,
+		declaration: (value) => ({ maxHeight: value })
+	}),
+	defineRule({
+		name: "z-index",
+		matcher: /^z-\[(.+)\]$/,
+		validate: isZIndexValue,
+		declaration: (value) => ({ zIndex: value })
+	}),
+	defineRule({
+		name: "margin",
+		matcher: /^ma-\[(.+)\]$/,
+		validate: isMarginValue,
+		declaration: (value) => ({ margin: value })
+	}),
+	defineRule({
+		name: "margin-x",
+		matcher: /^mx-\[(.+)\]$/,
+		validate: isMarginValue,
+		declaration: (value) => ({
+			marginLeft: value,
+			marginRight: value
+		})
+	}),
+	defineRule({
+		name: "margin-y",
+		matcher: /^my-\[(.+)\]$/,
+		validate: isMarginValue,
+		declaration: (value) => ({
+			marginTop: value,
+			marginBottom: value
+		})
+	}),
+	defineRule({
+		name: "margin-bottom",
+		matcher: /^mb-\[(.+)\]$/,
+		validate: isMarginValue,
+		declaration: (value) => ({ marginBottom: value })
+	}),
+	defineRule({
+		name: "margin-top",
+		matcher: /^mt-\[(.+)\]$/,
+		validate: isMarginValue,
+		declaration: (value) => ({ marginTop: value })
+	}),
+	defineRule({
+		name: "margin-left",
+		matcher: /^ml-\[(.+)\]$/,
+		validate: isMarginValue,
+		declaration: (value) => ({ marginLeft: value })
+	}),
+	defineRule({
+		name: "margin-right",
+		matcher: /^mr-\[(.+)\]$/,
+		validate: isMarginValue,
+		declaration: (value) => ({ marginRight: value })
+	}),
+	defineRule({
+		name: "padding",
+		matcher: /^pa-\[(.+)\]$/,
+		validate: isPaddingValue,
+		declaration: (value) => ({ padding: value })
+	}),
+	defineRule({
+		name: "padding-x",
+		matcher: /^px-\[(.+)\]$/,
+		validate: isPaddingValue,
+		declaration: (value) => ({
+			paddingLeft: value,
+			paddingRight: value
+		})
+	}),
+	defineRule({
+		name: "padding-y",
+		matcher: /^py-\[(.+)\]$/,
+		validate: isPaddingValue,
+		declaration: (value) => ({
+			paddingTop: value,
+			paddingBottom: value
+		})
+	}),
+	defineRule({
+		name: "padding-bottom",
+		matcher: /^pb-\[(.+)\]$/,
+		validate: isPaddingValue,
+		declaration: (value) => ({ paddingBottom: value })
+	}),
+	defineRule({
+		name: "padding-top",
+		matcher: /^pt-\[(.+)\]$/,
+		validate: isPaddingValue,
+		declaration: (value) => ({ paddingTop: value })
+	}),
+	defineRule({
+		name: "padding-left",
+		matcher: /^pl-\[(.+)\]$/,
+		validate: isPaddingValue,
+		declaration: (value) => ({ paddingLeft: value })
+	}),
+	defineRule({
+		name: "padding-right",
+		matcher: /^pr-\[(.+)\]$/,
+		validate: isPaddingValue,
+		declaration: (value) => ({ paddingRight: value })
+	}),
+	defineRule({
+		name: "left",
+		matcher: /^left-\[(.+)\]$/,
+		validate: isPositionValue,
+		declaration: (value) => ({ left: value })
+	}),
+	defineRule({
+		name: "right",
+		matcher: /^right-\[(.+)\]$/,
+		validate: isPositionValue,
+		declaration: (value) => ({ right: value })
+	}),
+	defineRule({
+		name: "top",
+		matcher: /^top-\[(.+)\]$/,
+		validate: isPositionValue,
+		declaration: (value) => ({ top: value })
+	}),
+	defineRule({
+		name: "bottom",
+		matcher: /^bottom-\[(.+)\]$/,
+		validate: isPositionValue,
+		declaration: (value) => ({ bottom: value })
+	}),
+	defineRule({
+		name: "inset",
+		matcher: /^inset-\[(.+)\]$/,
+		validate: isPositionValue,
+		declaration: (value) => ({ inset: value })
+	}),
+	defineRule({
+		name: "radius",
+		matcher: /^radius-\[(.+)\]$/,
+		validate: isRadiusValue,
+		declaration: (value) => ({ borderRadius: value })
+	}),
+	defineRule({
+		name: "radius-top-left",
+		matcher: /^radius-tl-\[(.+)\]$/,
+		validate: isRadiusValue,
+		declaration: (value) => ({ borderTopLeftRadius: value })
+	}),
+	defineRule({
+		name: "radius-top-right",
+		matcher: /^radius-tr-\[(.+)\]$/,
+		validate: isRadiusValue,
+		declaration: (value) => ({ borderTopRightRadius: value })
+	}),
+	defineRule({
+		name: "radius-bottom-left",
+		matcher: /^radius-bl-\[(.+)\]$/,
+		validate: isRadiusValue,
+		declaration: (value) => ({ borderBottomLeftRadius: value })
+	}),
+	defineRule({
+		name: "radius-bottom-right",
+		matcher: /^radius-br-\[(.+)\]$/,
+		validate: isRadiusValue,
+		declaration: (value) => ({ borderBottomRightRadius: value })
+	}),
+	defineRule({
+		name: "opacity",
+		matcher: /^opacity-\[(.+)\]$/,
+		validate: isOpacityValue,
+		declaration: (value) => ({ opacity: value })
+	}),
+	defineRule({
+		name: "color",
+		matcher: /^color-\[(.+)\]$/,
+		validate: isColorValue,
+		declaration: (value) => ({ color: value })
+	}),
+	defineRule({
+		name: "background-color",
+		matcher: /^bg-\[(.+)\]$/,
+		validate: isColorValue,
+		declaration: (value) => ({ backgroundColor: value })
+	})
+];
+//#endregion
+//#region src/plugin.ts
+function resolveOptions(options = {}) {
+	return {
+		include: options.include ?? DEFAULT_INCLUDE,
+		exclude: [...DEFAULT_EXCLUDE, ...options.exclude ?? []],
+		outFile: options.outFile ?? "src/.generated/utils-jit.css",
+		breakpoints: {
+			...DEFAULT_BREAKPOINTS,
+			...options.breakpoints ?? {}
+		},
+		rules: options.rules ?? [],
+		variants: {
+			...DEFAULT_VARIANTS,
+			...options.variants ?? {}
+		},
+		banner: options.banner ?? "/* @vueland/utils-jit: generated utilities */",
+		emitEmptyFile: options.emitEmptyFile ?? true,
+		debug: options.debug ?? false
+	};
+}
+function normalizePath(value) {
+	return value.replace(/\\/g, "/");
+}
+function isSameFile(a, b) {
+	return normalizePath(node_path.resolve(a)) === normalizePath(node_path.resolve(b));
+}
+function matchesPattern(value, pattern) {
+	const normalized = normalizePath(value);
+	if (typeof pattern === "string") return normalized.includes(normalizePath(pattern));
+	pattern.lastIndex = 0;
+	return pattern.test(normalized);
+}
+function isExcluded(file, exclude) {
+	return exclude.some((pattern) => matchesPattern(file, pattern));
+}
+function collectProjectFiles(root, options, outFile) {
+	const files = [];
+	function walk(dir) {
+		if (isExcluded(dir, options.exclude)) return;
+		let entries;
+		try {
+			entries = node_fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = node_path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				walk(fullPath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			if (isSameFile(fullPath, outFile)) continue;
+			if (shouldProcess(fullPath, options.include, options.exclude)) files.push(fullPath);
+		}
+	}
+	walk(root);
+	return files;
+}
+function readFileSafe(file) {
+	try {
+		return node_fs.readFileSync(file, "utf8");
+	} catch {
+		return null;
+	}
+}
+function utilsJIT(options) {
+	const resolvedOptions = resolveOptions(options);
+	let root = process.cwd();
+	let outFile = "";
+	let devServer = null;
+	let currentCss = "";
+	const allRules = [...defaultRules, ...resolvedOptions.rules];
+	const fileToTokens = /* @__PURE__ */ new Map();
+	const tokenRefCount = /* @__PURE__ */ new Map();
+	const tokenParseCache = /* @__PURE__ */ new Map();
+	const tokenCssCache = /* @__PURE__ */ new Map();
+	const activeCssRules = /* @__PURE__ */ new Map();
+	function debug(message) {
+		if (resolvedOptions.debug) console.info(`[utils-jit] ${message}`);
+	}
+	function notifyCssChanged() {
+		if (!devServer || !outFile) return;
+		devServer.watcher.emit("change", outFile);
+	}
+	function getParsedToken(token) {
+		if (tokenParseCache.has(token)) return tokenParseCache.get(token) ?? null;
+		const parsed = parseToken(token);
+		tokenParseCache.set(token, parsed);
+		return parsed;
+	}
+	function getCssRuleForToken(token) {
+		if (tokenCssCache.has(token)) return tokenCssCache.get(token) ?? null;
+		const parsed = getParsedToken(token);
+		if (!parsed) {
+			tokenCssCache.set(token, null);
+			return null;
+		}
+		const cssBody = resolveRule(parsed.utility, allRules);
+		if (!cssBody) {
+			tokenCssCache.set(token, null);
+			return null;
+		}
+		const cssRule = buildCssRule(parsed, cssBody, resolvedOptions.breakpoints, resolvedOptions.variants);
+		tokenCssCache.set(token, cssRule);
+		return cssRule;
+	}
+	function buildFinalCss() {
+		if (!activeCssRules.size) return resolvedOptions.emitEmptyFile ? "/* @vueland/utils-jit: no utilities found */\n" : "";
+		const sortedRules = Array.from(activeCssRules.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([, cssRule]) => cssRule);
+		return [
+			resolvedOptions.banner,
+			...sortedRules,
+			""
+		].join("\n");
+	}
+	function writeCssFile(notify = false) {
+		if (!outFile) return;
+		const nextCss = buildFinalCss();
+		if (nextCss === currentCss) return;
+		currentCss = nextCss;
+		node_fs.mkdirSync(node_path.dirname(outFile), { recursive: true });
+		node_fs.writeFileSync(outFile, currentCss, "utf8");
+		if (devServer) devServer.watcher.add(outFile);
+		if (notify) notifyCssChanged();
+		debug(`wrote ${normalizePath(node_path.relative(root, outFile))}`);
+	}
+	function activateToken(token) {
+		const prevCount = tokenRefCount.get(token) ?? 0;
+		const nextCount = prevCount + 1;
+		tokenRefCount.set(token, nextCount);
+		if (prevCount === 0) {
+			const cssRule = getCssRuleForToken(token);
+			if (cssRule) activeCssRules.set(token, cssRule);
+		}
+	}
+	function deactivateToken(token) {
+		const prevCount = tokenRefCount.get(token) ?? 0;
+		if (prevCount <= 0) return;
+		const nextCount = prevCount - 1;
+		if (nextCount === 0) {
+			tokenRefCount.delete(token);
+			activeCssRules.delete(token);
+			return;
+		}
+		tokenRefCount.set(token, nextCount);
+	}
+	function applyFileTokens(file, nextTokens) {
+		const normalizedFile = normalizePath(file);
+		const prevTokens = fileToTokens.get(normalizedFile) ?? /* @__PURE__ */ new Set();
+		for (const token of prevTokens) if (!nextTokens.has(token)) deactivateToken(token);
+		for (const token of nextTokens) if (!prevTokens.has(token)) activateToken(token);
+		if (nextTokens.size > 0) fileToTokens.set(normalizedFile, nextTokens);
+		else fileToTokens.delete(normalizedFile);
+	}
+	function rebuildAll(notify = false) {
+		fileToTokens.clear();
+		tokenRefCount.clear();
+		activeCssRules.clear();
+		const files = collectProjectFiles(root, resolvedOptions, outFile);
+		for (const file of files) {
+			const code = readFileSafe(file);
+			if (code === null) continue;
+			const tokens = tokenize(code);
+			if (tokens.size > 0) {
+				fileToTokens.set(normalizePath(file), tokens);
+				for (const token of tokens) {
+					const count = tokenRefCount.get(token) ?? 0;
+					tokenRefCount.set(token, count + 1);
+				}
+			}
+		}
+		for (const [token, count] of tokenRefCount) {
+			if (count <= 0) continue;
+			const cssRule = getCssRuleForToken(token);
+			if (cssRule) activeCssRules.set(token, cssRule);
+		}
+		writeCssFile(notify);
+		debug(`scanned ${files.length} files, found ${activeCssRules.size} utilities`);
+	}
+	function rebuildOne(file, code, notify = false) {
+		if (isSameFile(file, outFile)) return;
+		if (!shouldProcess(file, resolvedOptions.include, resolvedOptions.exclude)) return;
+		applyFileTokens(file, tokenize(code));
+		writeCssFile(notify);
+	}
+	function removeOne(file, notify = false) {
+		if (isSameFile(file, outFile)) return;
+		const normalizedFile = normalizePath(file);
+		const prevTokens = fileToTokens.get(normalizedFile);
+		if (!prevTokens) return;
+		for (const token of prevTokens) deactivateToken(token);
+		fileToTokens.delete(normalizedFile);
+		writeCssFile(notify);
+	}
+	return {
+		name: "utils-jit",
+		enforce: "pre",
+		configResolved(config) {
+			root = config.root;
+			outFile = node_path.resolve(root, resolvedOptions.outFile);
+			rebuildAll(false);
+		},
+		configureServer(server) {
+			devServer = server;
+			if (outFile) server.watcher.add(outFile);
+		},
+		buildStart() {
+			rebuildAll(false);
+		},
+		transform(code, id) {
+			const file = id.split("?")[0];
+			if (!file || isSameFile(file, outFile)) return null;
+			rebuildOne(file, code, false);
+			return null;
+		},
+		async handleHotUpdate(ctx) {
+			const { file } = ctx;
+			if (isSameFile(file, outFile)) return;
+			if (!shouldProcess(file, resolvedOptions.include, resolvedOptions.exclude)) return;
+			rebuildOne(file, await ctx.read(), true);
+		},
+		watchChange(id, change) {
+			const file = id.split("?")[0];
+			if (!file || isSameFile(file, outFile)) return;
+			if (change.event === "delete") {
+				removeOne(file, true);
+				return;
+			}
+			if (!shouldProcess(file, resolvedOptions.include, resolvedOptions.exclude)) return;
+			const code = readFileSafe(file);
+			if (code !== null) rebuildOne(file, code, true);
+		}
+	};
+}
+//#endregion
+exports.DEFAULT_BREAKPOINTS = DEFAULT_BREAKPOINTS;
+exports.DEFAULT_EXCLUDE = DEFAULT_EXCLUDE;
+exports.DEFAULT_INCLUDE = DEFAULT_INCLUDE;
+exports.DEFAULT_VARIANTS = DEFAULT_VARIANTS;
+exports.buildCssRule = buildCssRule;
+exports.camelToKebab = camelToKebab;
+exports.createArbitraryRule = createArbitraryRule;
+exports.defaultRules = defaultRules;
+exports.defineRule = defineRule;
+exports.escapeCssSelector = escapeCssSelector;
+exports.extractClassCandidates = extractClassCandidates;
+exports.isColorValue = isColorValue;
+exports.isCssGlobalValue = isCssGlobalValue;
+exports.isFunctionalCssValue = isFunctionalCssValue;
+exports.isLengthLikeValue = isLengthLikeValue;
+exports.isLengthListValue = isLengthListValue;
+exports.isMarginValue = isMarginValue;
+exports.isNumberValue = isNumberValue;
+exports.isOpacityValue = isOpacityValue;
+exports.isPaddingValue = isPaddingValue;
+exports.isPositionValue = isPositionValue;
+exports.isRadiusValue = isRadiusValue;
+exports.isSafeCssValue = isSafeCssValue;
+exports.isSizeValue = isSizeValue;
+exports.isZIndexValue = isZIndexValue;
+exports.isZeroValue = isZeroValue;
+exports.normalizeValue = normalizeValue;
+exports.parseToken = parseToken;
+exports.resolveRule = resolveRule;
+exports.shouldProcess = shouldProcess;
+exports.stripComments = stripComments;
+exports.tokenize = tokenize;
+exports.utilsJIT = utilsJIT;
+
+//# sourceMappingURL=index.cjs.map