@tenphi/tasty 3.7.0 → 3.9.0

package/dist/chunks/css-definitions-D_it4XZH.js

@@ -0,0 +1,875 @@
+import { F as RE_RAW_UNIT, P as RE_NUMBER, a as customFunction, f as parseStyle } from "./dsl-C5yuAn41.js";
+import { C as STYLE_HANDLER_MAP, k as createStyle } from "./style-engine-C1ECBZxR.js";
+//#region src/functions/index.ts
+const FUNCTION_KEY = "@function";
+const RESERVED_KEYS = new Set([
+	"args",
+	"returns",
+	"result"
+]);
+function hasLocalFunctions(styles) {
+	return FUNCTION_KEY in styles;
+}
+function extractLocalFunctions(styles) {
+	const functions = styles[FUNCTION_KEY];
+	if (!functions || typeof functions !== "object") return null;
+	return functions;
+}
+function parseFunctionName(token) {
+	if (token.startsWith("$$")) return `--${token.slice(2)}`;
+	if (token.startsWith("$")) return `--${token.slice(1)}`;
+	if (token.startsWith("--")) return token;
+	return `--${token}`;
+}
+function parseParamName(token) {
+	if (token.startsWith("$")) return `--${token.slice(1)}`;
+	if (token.startsWith("--")) return token;
+	return `--${token}`;
+}
+function formatParameter(token, param) {
+	const name = parseParamName(token);
+	if (param === true) return name;
+	if (typeof param === "string") return param ? `${name} ${param}` : name;
+	let out = name;
+	if (param.syntax) out += ` ${param.syntax}`;
+	if (param.default !== void 0) out += `: ${parseStyle(param.default).output}`;
+	return out;
+}
+function formatFunctionPrelude(name, args, returns) {
+	const cssName = parseFunctionName(name);
+	let params = "";
+	if (Array.isArray(args)) params = args.map((token) => formatParameter(token, true)).join(", ");
+	else if (args) params = Object.entries(args).map(([token, param]) => formatParameter(token, param)).join(", ");
+	const returnsPart = returns ? ` returns ${returns}` : "";
+	return `@function ${cssName}(${params})${returnsPart}`;
+}
+function formatFunctionDeclarations(def) {
+	const parts = [];
+	for (const key of Object.keys(def)) {
+		if (RESERVED_KEYS.has(key) || !key.startsWith("$")) continue;
+		const value = def[key];
+		if (value === void 0) continue;
+		parts.push(`${parseParamName(key)}: ${parseStyle(value).output};`);
+	}
+	parts.push(`result: ${parseStyle(def.result).output};`);
+	return parts.join(" ");
+}
+function formatFunctionRule(name, def) {
+	return `${formatFunctionPrelude(name, def.args, def.returns)} { ${formatFunctionDeclarations(def)} }`;
+}
+function isCssFunctionKey(key) {
+	return key.startsWith("$") || key.startsWith("--");
+}
+function isParseFunction(value) {
+	return typeof value === "function";
+}
+function splitFunctions(map, onMismatch) {
+	const parseFuncs = {};
+	const functionDefs = {};
+	for (const [key, value] of Object.entries(map)) {
+		const cssKey = isCssFunctionKey(key);
+		if (isParseFunction(value)) {
+			if (cssKey) {
+				onMismatch?.(key, "expected-definition");
+				continue;
+			}
+			parseFuncs[key] = value;
+		} else {
+			if (!cssKey) {
+				onMismatch?.(key, "expected-parse-function");
+				continue;
+			}
+			functionDefs[key] = value;
+		}
+	}
+	return {
+		parseFuncs,
+		functionDefs
+	};
+}
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const paramBareName = (token) => parseParamName(token).slice(2);
+function prefixDeclaredVars(template, declared, prefixOf) {
+	let out = template;
+	for (const bare of declared) {
+		const re = new RegExp(`var\\(\\s*--${escapeRegExp(bare)}(?![\\w-])`, "g");
+		out = out.replace(re, `var(--${prefixOf(bare)}`);
+	}
+	return out;
+}
+function substituteVars(template, valueMap) {
+	let out = template;
+	for (let iter = 0; iter < 30; iter++) {
+		let changed = false;
+		for (const [name, value] of valueMap) {
+			const re = new RegExp(`var\\(\\s*--${escapeRegExp(name)}\\s*(?:,[^)]*)?\\)`, "g");
+			out = out.replace(re, () => {
+				changed = true;
+				return value;
+			});
+		}
+		if (!changed) break;
+	}
+	return out;
+}
+const inProgress = /* @__PURE__ */ new Set();
+function compileFunctionClosure(name, def) {
+	const cssName = parseFunctionName(name);
+	const prefixOf = (bare) => `tf-${cssName.slice(2)}-${bare}`;
+	const params = [];
+	if (Array.isArray(def.args)) for (const token of def.args) params.push({ prefixed: prefixOf(paramBareName(token)) });
+	else if (def.args) for (const [token, param] of Object.entries(def.args)) {
+		let dflt;
+		if (param && typeof param === "object" && param.default !== void 0) dflt = parseStyle(param.default).output;
+		params.push({
+			prefixed: prefixOf(paramBareName(token)),
+			default: dflt
+		});
+	}
+	const localKeys = Object.keys(def).filter((key) => !RESERVED_KEYS.has(key) && key.startsWith("$"));
+	const declared = [...Array.isArray(def.args) ? def.args.map(paramBareName) : def.args ? Object.keys(def.args).map(paramBareName) : [], ...localKeys.map(paramBareName)];
+	let built = false;
+	let resultTemplate = "";
+	const localTemplates = [];
+	const build = () => {
+		built = true;
+		resultTemplate = prefixDeclaredVars(parseStyle(def.result).output, declared, prefixOf);
+		for (const key of localKeys) {
+			const value = def[key];
+			if (value === void 0) continue;
+			localTemplates.push({
+				prefixed: prefixOf(paramBareName(key)),
+				value: prefixDeclaredVars(parseStyle(value).output, declared, prefixOf)
+			});
+		}
+	};
+	return (groups) => {
+		if (inProgress.has(cssName)) return "";
+		inProgress.add(cssName);
+		try {
+			if (!built) build();
+			const valueMap = /* @__PURE__ */ new Map();
+			params.forEach((param, index) => {
+				const arg = groups[index]?.output?.trim();
+				valueMap.set(param.prefixed, arg || param.default || "");
+			});
+			for (const local of localTemplates) valueMap.set(local.prefixed, local.value);
+			return substituteVars(resultTemplate, valueMap);
+		} finally {
+			inProgress.delete(cssName);
+		}
+	};
+}
+const registeredFunctionDefs = /* @__PURE__ */ new Map();
+function registerFunctionPolyfill(name, definition) {
+	const cssName = parseFunctionName(name);
+	const serialized = JSON.stringify(definition);
+	if (registeredFunctionDefs.get(cssName) === serialized) return;
+	registeredFunctionDefs.set(cssName, serialized);
+	customFunction(cssName, compileFunctionClosure(name, definition));
+}
+function registerLocalFunctionPolyfills(styles) {
+	const local = extractLocalFunctions(styles);
+	if (!local) return;
+	for (const [name, definition] of Object.entries(local)) registerFunctionPolyfill(name, definition);
+}
+function resetFunctionPolyfills() {
+	registeredFunctionDefs.clear();
+}
+//#endregion
+//#region src/properties/defaults.ts
+const DEFAULT_PROPERTIES = {
+	"#tasty-second-fill": {
+		inherits: false,
+		initialValue: "transparent"
+	},
+	"#current": {
+		inherits: true,
+		initialValue: "currentcolor"
+	},
+	"#white": {
+		inherits: true,
+		initialValue: "rgb(255 255 255)"
+	},
+	"#black": {
+		inherits: true,
+		initialValue: "rgb(0 0 0)"
+	},
+	"#clear": {
+		inherits: true,
+		initialValue: "transparent"
+	},
+	"#border": {
+		inherits: true,
+		initialValue: "rgb(0 0 0)"
+	},
+	$gap: {
+		syntax: "<length>",
+		inherits: true,
+		initialValue: "4px"
+	},
+	$radius: {
+		syntax: "<length>",
+		inherits: true,
+		initialValue: "6px"
+	},
+	"$border-width": {
+		syntax: "<length>",
+		inherits: true,
+		initialValue: "1px"
+	},
+	"$outline-width": {
+		syntax: "<length>",
+		inherits: true,
+		initialValue: "3px"
+	},
+	$transition: {
+		syntax: "<time>",
+		inherits: true,
+		initialValue: "80ms"
+	},
+	"$sharp-radius": {
+		syntax: "<length>",
+		inherits: true,
+		initialValue: "0px"
+	},
+	"$bold-font-weight": {
+		syntax: "<number>",
+		inherits: true,
+		initialValue: "700"
+	},
+	"$font-sans-fallback": {
+		syntax: "*",
+		inherits: true,
+		initialValue: "system-ui, -apple-system, \"Segoe UI\", Roboto, Helvetica, Arial, \"Apple Color Emoji\", \"Segoe UI Emoji\", sans-serif"
+	},
+	"$font-mono-fallback": {
+		syntax: "*",
+		inherits: true,
+		initialValue: "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, \"Liberation Mono\", \"Courier New\", monospace"
+	}
+};
+//#endregion
+//#region src/properties/index.ts
+const PROPERTIES_KEY = "@property";
+const VALID_PROPERTY_NAME_PATTERN = /^[a-z_][a-z0-9-_]*$/i;
+function isValidPropertyName(name) {
+	return VALID_PROPERTY_NAME_PATTERN.test(name);
+}
+function hasLocalProperties(styles) {
+	return PROPERTIES_KEY in styles;
+}
+function extractLocalProperties(styles) {
+	const properties = styles[PROPERTIES_KEY];
+	if (!properties || typeof properties !== "object") return null;
+	return properties;
+}
+function parsePropertyToken(token) {
+	if (!token || typeof token !== "string") return {
+		cssName: "",
+		isColor: false,
+		isValid: false,
+		error: "Property token must be a non-empty string"
+	};
+	let name;
+	let isColor;
+	if (token.startsWith("$")) {
+		name = token.slice(1);
+		isColor = false;
+	} else if (token.startsWith("#")) {
+		name = token.slice(1);
+		isColor = true;
+	} else if (token.startsWith("--")) {
+		name = token.slice(2);
+		isColor = token.endsWith("-color");
+	} else {
+		name = token;
+		isColor = token.endsWith("-color");
+	}
+	if (!name) return {
+		cssName: "",
+		isColor,
+		isValid: false,
+		error: "Property name cannot be empty"
+	};
+	if (!isValidPropertyName(name)) return {
+		cssName: "",
+		isColor,
+		isValid: false,
+		error: `Invalid property name "${name}". Must start with a letter or underscore, followed by letters, digits, hyphens, or underscores.`
+	};
+	let cssName;
+	if (token.startsWith("#")) cssName = `--${name}-color`;
+	else cssName = `--${name}`;
+	return {
+		cssName,
+		isColor,
+		isValid: true
+	};
+}
+function normalizePropertyDefinition(def) {
+	const normalized = {};
+	if (def.inherits !== void 0) normalized.inherits = def.inherits;
+	if (def.syntax !== void 0) normalized.syntax = def.syntax;
+	return JSON.stringify(normalized);
+}
+function getEffectiveDefinition(token, userDefinition) {
+	const parsed = parsePropertyToken(token);
+	if (!parsed.isValid) return {
+		cssName: "",
+		definition: userDefinition,
+		isValid: false,
+		error: parsed.error
+	};
+	if (parsed.isColor) return {
+		cssName: parsed.cssName,
+		definition: {
+			syntax: "<color>",
+			inherits: userDefinition.inherits,
+			initialValue: userDefinition.initialValue ?? "transparent"
+		},
+		isValid: true
+	};
+	return {
+		cssName: parsed.cssName,
+		definition: userDefinition,
+		isValid: true
+	};
+}
+const UNIT_TO_SYNTAX = {};
+const LENGTH_UNITS = [
+	"px",
+	"em",
+	"rem",
+	"vw",
+	"vh",
+	"vmin",
+	"vmax",
+	"ch",
+	"ex",
+	"cap",
+	"ic",
+	"lh",
+	"rlh",
+	"svw",
+	"svh",
+	"lvw",
+	"lvh",
+	"dvw",
+	"dvh",
+	"cqw",
+	"cqh",
+	"cqi",
+	"cqb",
+	"cqmin",
+	"cqmax"
+];
+const ANGLE_UNITS = [
+	"deg",
+	"rad",
+	"grad",
+	"turn"
+];
+const TIME_UNITS = ["ms", "s"];
+for (const u of LENGTH_UNITS) UNIT_TO_SYNTAX[u] = {
+	syntax: "<length-percentage>",
+	initialValue: "0px"
+};
+UNIT_TO_SYNTAX["%"] = {
+	syntax: "<length-percentage>",
+	initialValue: "0px"
+};
+for (const u of ANGLE_UNITS) UNIT_TO_SYNTAX[u] = {
+	syntax: "<angle>",
+	initialValue: "0deg"
+};
+for (const u of TIME_UNITS) UNIT_TO_SYNTAX[u] = {
+	syntax: "<time>",
+	initialValue: "0s"
+};
+function inferSyntaxFromValue(value) {
+	if (!value || typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	if (RE_NUMBER.test(trimmed)) {
+		if (parseFloat(trimmed) === 0) return null;
+		return {
+			syntax: "<number>",
+			initialValue: "0"
+		};
+	}
+	const unitMatch = trimmed.match(RE_RAW_UNIT);
+	if (unitMatch) {
+		const mapping = UNIT_TO_SYNTAX[unitMatch[2]];
+		if (mapping) return mapping;
+	}
+	return null;
+}
+//#endregion
+//#region src/utils/hash.ts
+function hashString(str) {
+	let hash = 5381;
+	for (let i = 0; i < str.length; i++) hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
+	return (hash >>> 0).toString(36);
+}
+//#endregion
+//#region src/utils/name-prefix.ts
+const DEFAULT_NAME_PREFIX = "t";
+const DEFAULT_ZERO_NAME_PREFIX = "ts";
+const NAME_PREFIX_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_-]{0,31}$/;
+function validateNamePrefix(prefix) {
+	if (typeof prefix !== "string") throw new TypeError(`[Tasty] namePrefix must be a string, got ${typeof prefix}.`);
+	if (!NAME_PREFIX_PATTERN.test(prefix)) throw new TypeError(`[Tasty] namePrefix "${prefix}" is invalid. It must start with a letter (a-z, A-Z) or "_", contain only letters, digits, "_" or "-", and be 1-32 characters long. Examples: "t", "ts", "myapp-", "_foo".`);
+}
+function makeClassName(prefix, hash) {
+	return `${prefix}${hash}`;
+}
+function makeKeyframeName(prefix, suffix) {
+	return `${prefix}k${suffix}`;
+}
+function makeCounterStyleName(prefix, suffix) {
+	return `${prefix}c${suffix}`;
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function tastyClassRegex(prefix) {
+	return new RegExp(`^${escapeRegex(prefix)}[a-z0-9]+$`);
+}
+function rscClassRegexGlobal(prefix) {
+	return new RegExp(`\\.(${escapeRegex(prefix)}[a-z0-9]+)\\.\\1`, "g");
+}
+//#endregion
+//#region src/properties/property-type-resolver.ts
+const CUSTOM_PROP_DECL = /^\s*(--[a-z0-9_-]+)\s*:\s*(\S|\S.*\S)\s*$/i;
+const SINGLE_VAR_REF = /^var\((--[a-z0-9_-]+)\)$/i;
+var PropertyTypeResolver = class {
+	pendingDeps = /* @__PURE__ */ new Map();
+	reverseDeps = /* @__PURE__ */ new Map();
+	scanDeclarations(declarations, isPropertyDefined, registerProperty) {
+		if (!declarations.includes("--")) return;
+		const parts = declarations.split(/;+/);
+		for (const part of parts) {
+			if (!part.trim()) continue;
+			const match = CUSTOM_PROP_DECL.exec(part);
+			if (!match) continue;
+			const propName = match[1];
+			const value = match[2].trim();
+			if (isPropertyDefined(propName)) continue;
+			if (propName.endsWith("-color")) {
+				registerProperty(propName, "<color>", "transparent");
+				continue;
+			}
+			if (propName.endsWith("-line-height")) {
+				registerProperty(propName, "<number> | <length-percentage>", "0");
+				continue;
+			}
+			if (propName.endsWith("-opacity")) {
+				registerProperty(propName, "<number> | <percentage>", "0");
+				continue;
+			}
+			const varMatch = SINGLE_VAR_REF.exec(value);
+			if (varMatch) {
+				const depName = varMatch[1];
+				this.addDependency(propName, depName);
+				continue;
+			}
+			if (this.isComplexValue(value)) continue;
+			const inferred = inferSyntaxFromValue(value);
+			if (!inferred) continue;
+			this.resolve(propName, inferred.syntax, inferred.initialValue, isPropertyDefined, registerProperty);
+		}
+	}
+	addDependency(propName, depName) {
+		if (propName === depName) return;
+		this.pendingDeps.set(propName, depName);
+		let dependents = this.reverseDeps.get(depName);
+		if (!dependents) {
+			dependents = [];
+			this.reverseDeps.set(depName, dependents);
+		}
+		if (!dependents.includes(propName)) dependents.push(propName);
+	}
+	resolve(propName, syntax, initialValue, isPropertyDefined, registerProperty, resolving) {
+		if (!resolving) resolving = /* @__PURE__ */ new Set();
+		if (resolving.has(propName)) return;
+		resolving.add(propName);
+		if (!isPropertyDefined(propName)) registerProperty(propName, syntax, initialValue);
+		const dependents = this.reverseDeps.get(propName);
+		if (dependents) {
+			this.reverseDeps.delete(propName);
+			for (const dependent of dependents) {
+				this.pendingDeps.delete(dependent);
+				if (isPropertyDefined(dependent)) continue;
+				this.resolve(dependent, syntax, initialValue, isPropertyDefined, registerProperty, resolving);
+			}
+		}
+	}
+	isComplexValue(value) {
+		if (value.includes("calc(")) return true;
+		const firstVar = value.indexOf("var(");
+		if (firstVar === -1) return false;
+		if (value.indexOf("var(", firstVar + 4) !== -1) return true;
+		return !SINGLE_VAR_REF.test(value);
+	}
+};
+//#endregion
+//#region src/font-face/index.ts
+const FONT_FACE_KEY = "@font-face";
+function hasLocalFontFace(styles) {
+	return FONT_FACE_KEY in styles;
+}
+function extractLocalFontFace(styles) {
+	const fontFace = styles[FONT_FACE_KEY];
+	if (!fontFace || typeof fontFace !== "object") return null;
+	return fontFace;
+}
+const FONT_FACE_DESCRIPTOR_MAP = {
+	fontWeight: "font-weight",
+	fontStyle: "font-style",
+	fontStretch: "font-stretch",
+	fontDisplay: "font-display",
+	unicodeRange: "unicode-range",
+	ascentOverride: "ascent-override",
+	descentOverride: "descent-override",
+	lineGapOverride: "line-gap-override",
+	sizeAdjust: "size-adjust",
+	fontFeatureSettings: "font-feature-settings",
+	fontVariationSettings: "font-variation-settings"
+};
+function formatFontFaceDeclarations(family, descriptors) {
+	const parts = [];
+	parts.push(`font-family: "${family}";`);
+	parts.push(`src: ${descriptors.src};`);
+	for (const [key, cssName] of Object.entries(FONT_FACE_DESCRIPTOR_MAP)) {
+		const value = descriptors[key];
+		if (value !== void 0) parts.push(`${cssName}: ${value};`);
+	}
+	return parts.join(" ");
+}
+function formatFontFaceRule(family, descriptors) {
+	return `@font-face { ${formatFontFaceDeclarations(family, descriptors)} }`;
+}
+function fontFaceContentHash(family, descriptors) {
+	return JSON.stringify({
+		family,
+		...descriptors
+	});
+}
+//#endregion
+//#region src/counter-style/index.ts
+const COUNTER_STYLE_KEY = "@counter-style";
+function hasLocalCounterStyle(styles) {
+	return COUNTER_STYLE_KEY in styles;
+}
+function extractLocalCounterStyle(styles) {
+	const counterStyle = styles[COUNTER_STYLE_KEY];
+	if (!counterStyle || typeof counterStyle !== "object") return null;
+	return counterStyle;
+}
+const COUNTER_STYLE_DESCRIPTOR_MAP = {
+	system: "system",
+	symbols: "symbols",
+	additiveSymbols: "additive-symbols",
+	prefix: "prefix",
+	suffix: "suffix",
+	negative: "negative",
+	range: "range",
+	pad: "pad",
+	fallback: "fallback",
+	speakAs: "speak-as"
+};
+function formatCounterStyleDeclarations(descriptors) {
+	const parts = [];
+	for (const [key, cssName] of Object.entries(COUNTER_STYLE_DESCRIPTOR_MAP)) {
+		const value = descriptors[key];
+		if (value !== void 0) parts.push(`${cssName}: ${value};`);
+	}
+	return parts.join(" ");
+}
+function formatCounterStyleRule(name, descriptors) {
+	return `@counter-style ${name} { ${formatCounterStyleDeclarations(descriptors)} }`;
+}
+//#endregion
+//#region src/keyframes/index.ts
+const KEYFRAMES_KEY = "@keyframes";
+const NON_NAME_KEYWORDS = new Set("none initial inherit unset revert auto normal running paused reverse alternate alternate-reverse forwards backwards both ease linear ease-in ease-out ease-in-out step-start step-end".split(" "));
+function hasLocalKeyframes(styles) {
+	return KEYFRAMES_KEY in styles;
+}
+function extractLocalKeyframes(styles) {
+	const keyframes = styles[KEYFRAMES_KEY];
+	if (!keyframes || typeof keyframes !== "object") return null;
+	return keyframes;
+}
+function mergeKeyframes(local, global) {
+	if (!local && !global) return null;
+	if (!local) return global;
+	if (!global) return local;
+	return {
+		...global,
+		...local
+	};
+}
+function extractAnimationNameFromValue(value) {
+	for (const part of value.trim().split(/\s+/)) {
+		const lower = part.toLowerCase();
+		if (NON_NAME_KEYWORDS.has(lower)) continue;
+		if (part === "infinite" || /^(?:-?[\d.]+m?s|\d+|(?:cubic-bezier|steps)\()/i.test(part)) continue;
+		const match = /^([a-zA-Z_-][a-zA-Z0-9_-]*)/.exec(part);
+		if (match) return match[1];
+	}
+	return null;
+}
+function collectAnimationNamesFromValue(value, names) {
+	for (const animation of value.split(",")) {
+		const name = extractAnimationNameFromValue(animation);
+		if (name) names.add(name);
+	}
+}
+function extractAnimationNamesFromStyleValue(value, names) {
+	if (typeof value === "string") collectAnimationNamesFromValue(value, names);
+	else if (Array.isArray(value)) for (const v of value) extractAnimationNamesFromStyleValue(v, names);
+	else if (value && typeof value === "object") for (const v of Object.values(value)) extractAnimationNamesFromStyleValue(v, names);
+}
+function collectAnimationNamesFromStyles(styles, names) {
+	if ("animation" in styles) extractAnimationNamesFromStyleValue(styles.animation, names);
+	if ("animationName" in styles) extractAnimationNamesFromStyleValue(styles.animationName, names);
+	for (const [key, value] of Object.entries(styles)) {
+		if (key === "$" || key === KEYFRAMES_KEY) continue;
+		if ((key.startsWith("&") || key.startsWith(".") || /^[A-Z]/.test(key)) && value && typeof value === "object") collectAnimationNamesFromStyles(value, names);
+	}
+}
+function extractAnimationNamesFromStyles(styles) {
+	const names = /* @__PURE__ */ new Set();
+	collectAnimationNamesFromStyles(styles, names);
+	return names;
+}
+function resolveKeyframesName(authored, steps) {
+	return `${authored}-${hashString(JSON.stringify(steps))}`;
+}
+function resolveKeyframesNames(used) {
+	const names = /* @__PURE__ */ new Map();
+	for (const [authored, steps] of Object.entries(used)) names.set(authored, resolveKeyframesName(authored, steps));
+	return names;
+}
+function replaceAnimationNames(declarations, nameMap, usedNames) {
+	if (nameMap.size === 0 || !declarations.includes("animation")) return declarations;
+	const parts = declarations.split(";");
+	let modified = false;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		const colonIdx = part.indexOf(":");
+		if (colonIdx === -1) continue;
+		const prop = part.slice(0, colonIdx).trim().toLowerCase();
+		if (prop === "animation" || prop === "animation-name") {
+			const prefix = part.slice(0, colonIdx + 1);
+			let value = part.slice(colonIdx + 1);
+			for (const original of nameMap.keys()) if (findWord(value, original) !== -1) usedNames.add(original);
+			for (const [original, injected] of nameMap) {
+				if (original === injected) continue;
+				const next = replaceWord(value, original, injected);
+				if (next !== value) {
+					value = next;
+					modified = true;
+				}
+			}
+			parts[i] = prefix + value;
+		}
+	}
+	return modified ? parts.join(";") : declarations;
+}
+function replaceWord(str, word, replacement) {
+	let result = str;
+	let idx = 0;
+	while ((idx = findWord(result, word, idx)) !== -1) {
+		result = result.slice(0, idx) + replacement + result.slice(idx + word.length);
+		idx += replacement.length;
+	}
+	return result;
+}
+function findWord(str, word, from = 0) {
+	let idx = from;
+	while ((idx = str.indexOf(word, idx)) !== -1) {
+		const before = idx === 0 ? " " : str[idx - 1];
+		const end = idx + word.length;
+		const after = end === str.length ? " " : str[end];
+		if (!/[\w-]/.test(before + after)) return idx;
+		idx = end;
+	}
+	return -1;
+}
+function filterUsedKeyframes(keyframes, usedNames) {
+	if (!keyframes || usedNames.size === 0) return null;
+	const used = {};
+	let hasAny = false;
+	for (const name of usedNames) if (keyframes[name]) {
+		used[name] = keyframes[name];
+		hasAny = true;
+	}
+	return hasAny ? used : null;
+}
+//#endregion
+//#region src/ssr/format-property.ts
+function formatPropertyCSS(token, definition) {
+	const result = getEffectiveDefinition(token, definition);
+	if (!result.isValid) return "";
+	return buildPropertyRule(result.cssName, result.definition);
+}
+function buildPropertyRule(cssName, definition) {
+	const parts = [];
+	if (definition.syntax != null) {
+		let syntax = String(definition.syntax).trim();
+		if (!/^['"]/u.test(syntax)) syntax = `"${syntax}"`;
+		parts.push(`syntax: ${syntax};`);
+	}
+	const inherits = definition.inherits ?? true;
+	parts.push(`inherits: ${inherits ? "true" : "false"};`);
+	if (definition.initialValue != null) {
+		let initialValueStr;
+		if (typeof definition.initialValue === "number") initialValueStr = String(definition.initialValue);
+		else initialValueStr = parseStyle(definition.initialValue).output;
+		parts.push(`initial-value: ${initialValueStr};`);
+	}
+	return `@property ${cssName} { ${parts.join(" ").trim()} }`;
+}
+//#endregion
+//#region src/ssr/format-keyframes.ts
+function stepsToCSS(steps) {
+	const rules = [];
+	for (const [key, value] of Object.entries(steps)) {
+		if (typeof value === "string") {
+			rules.push(`${key} { ${value.trim()} }`);
+			continue;
+		}
+		const styleMap = value || {};
+		const styleNames = Object.keys(styleMap).sort();
+		const handlerQueue = [];
+		const seenHandlers = /* @__PURE__ */ new Set();
+		styleNames.forEach((styleName) => {
+			let handlers = STYLE_HANDLER_MAP[styleName];
+			if (!handlers) handlers = STYLE_HANDLER_MAP[styleName] = [createStyle(styleName)];
+			handlers.forEach((handler) => {
+				if (!seenHandlers.has(handler)) {
+					seenHandlers.add(handler);
+					handlerQueue.push(handler);
+				}
+			});
+		});
+		const declarationPairs = [];
+		handlerQueue.forEach((handler) => {
+			const result = handler(handler.__lookupStyles.reduce((acc, name) => {
+				const v = styleMap[name];
+				if (v !== void 0) acc[name] = v;
+				return acc;
+			}, {}));
+			if (!result) return;
+			(Array.isArray(result) ? result : [result]).forEach((cssMap) => {
+				if (!cssMap || typeof cssMap !== "object") return;
+				const { $: _$, ...props } = cssMap;
+				Object.entries(props).forEach(([prop, val]) => {
+					if (val == null || val === "") return;
+					if (Array.isArray(val)) val.forEach((v) => {
+						if (v != null && v !== "") declarationPairs.push({
+							prop,
+							value: String(v)
+						});
+					});
+					else declarationPairs.push({
+						prop,
+						value: String(val)
+					});
+				});
+			});
+		});
+		const declarations = declarationPairs.map((d) => `${d.prop}: ${d.value}`).join("; ");
+		rules.push(`${key} { ${declarations.trim()} }`);
+	}
+	return rules.join(" ");
+}
+function formatKeyframesCSS(name, steps) {
+	return `@keyframes ${name} { ${stepsToCSS(steps)} }`;
+}
+//#endregion
+//#region src/ssr/format-rules.ts
+function resolveSelector(rule, className) {
+	let selector = rule.selector;
+	if (rule.needsClassName) {
+		const selectorParts = selector ? selector.split("|||") : [""];
+		const classPrefix = `.${className}.${className}`;
+		selector = selectorParts.map((part) => {
+			const classSelector = part ? `${classPrefix}${part}` : classPrefix;
+			if (rule.rootPrefix) return `${rule.rootPrefix} ${classSelector}`;
+			return classSelector;
+		}).join(", ");
+	}
+	return selector;
+}
+function groupRules(rules) {
+	const groupMap = /* @__PURE__ */ new Map();
+	const order = [];
+	const atKey = (at) => at && at.length ? at.join("|") : "";
+	for (const r of rules) {
+		const key = `${atKey(r.atRules)}||${r.selector}||${r.startingStyle ? "1" : "0"}`;
+		const existing = groupMap.get(key);
+		if (existing) existing.declarations = existing.declarations ? `${existing.declarations} ${r.declarations}` : r.declarations;
+		else {
+			groupMap.set(key, {
+				selector: r.selector,
+				atRules: r.atRules,
+				startingStyle: r.startingStyle,
+				declarations: r.declarations
+			});
+			order.push(key);
+		}
+	}
+	return order.map((key) => groupMap.get(key));
+}
+function formatRules(rules, className) {
+	if (rules.length === 0) return "";
+	const grouped = groupRules(rules.map((rule) => ({
+		selector: resolveSelector(rule, className),
+		declarations: rule.declarations,
+		atRules: rule.atRules,
+		startingStyle: rule.startingStyle
+	})));
+	const cssRules = [];
+	for (const rule of grouped) {
+		const innerContent = rule.startingStyle ? `@starting-style { ${rule.declarations} }` : rule.declarations;
+		const baseRule = `${rule.selector} { ${innerContent} }`;
+		let fullRule = baseRule;
+		if (rule.atRules && rule.atRules.length > 0) fullRule = rule.atRules.reduce((css, atRule) => `${atRule} { ${css} }`, baseRule);
+		cssRules.push(fullRule);
+	}
+	return cssRules.join("\n");
+}
+//#endregion
+//#region src/ssr/format-global-rules.ts
+function formatGlobalRules(rules) {
+	if (rules.length === 0) return "";
+	const cssRules = [];
+	for (const rule of rules) {
+		const baseRule = `${rule.rootPrefix ? `${rule.rootPrefix} ${rule.selector}` : rule.selector} { ${rule.declarations} }`;
+		let fullRule = baseRule;
+		if (rule.atRules && rule.atRules.length > 0) fullRule = rule.atRules.reduce((css, atRule) => `${atRule} { ${css} }`, baseRule);
+		cssRules.push(fullRule);
+	}
+	return cssRules.join("\n");
+}
+//#endregion
+//#region src/ssr/artifacts.ts
+function createServerStyleArtifact(kind, key, css, order) {
+	const content = `${kind}\0${key}\0${css}`;
+	return {
+		id: `${kind}:${hashString(content)}:${content.length.toString(36)}`,
+		kind,
+		css,
+		order
+	};
+}
+//#endregion
+export { validateNamePrefix as A, formatFunctionPrelude as B, DEFAULT_NAME_PREFIX as C, makeKeyframeName as D, makeCounterStyleName as E, normalizePropertyDefinition as F, registerLocalFunctionPolyfills as G, hasLocalFunctions as H, parsePropertyToken as I, resetFunctionPolyfills as K, DEFAULT_PROPERTIES as L, extractLocalProperties as M, getEffectiveDefinition as N, rscClassRegexGlobal as O, hasLocalProperties as P, extractLocalFunctions as R, PropertyTypeResolver as S, makeClassName as T, parseFunctionName as U, formatFunctionRule as V, registerFunctionPolyfill as W, extractLocalFontFace as _, formatPropertyCSS as a, formatFontFaceRule as b, filterUsedKeyframes as c, replaceAnimationNames as d, resolveKeyframesNames as f, hasLocalCounterStyle as g, formatCounterStyleRule as h, formatKeyframesCSS as i, hashString as j, tastyClassRegex as k, hasLocalKeyframes as l, formatCounterStyleDeclarations as m, formatGlobalRules as n, extractAnimationNamesFromStyles as o, extractLocalCounterStyle as p, splitFunctions as q, formatRules as r, extractLocalKeyframes as s, createServerStyleArtifact as t, mergeKeyframes as u, fontFaceContentHash as v, DEFAULT_ZERO_NAME_PREFIX as w, hasLocalFontFace as x, formatFontFaceDeclarations as y, formatFunctionDeclarations as z };
+
+//# sourceMappingURL=css-definitions-D_it4XZH.js.map