@tenphi/tasty 0.0.0-snapshot.27b6708 → 0.0.0-snapshot.28eb83c

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

@@ -0,0 +1,1284 @@
+import { F as RE_NUMBER, I as RE_RAW_UNIT, o as customFunction, p as parseStyle } from "./dsl-CXvoaLnj.js";
+import { C as STYLE_HANDLER_MAP, k as createStyle } from "./style-engine-CBuOt1e4.js";
+//#region src/functions/index.ts
+const FUNCTION_KEY = "@function";
+/** Descriptor keys that are not local-variable declarations. */
+const RESERVED_KEYS = new Set([
+	"args",
+	"returns",
+	"result"
+]);
+/**
+* Check if styles object has a local @function definition.
+*/
+function hasLocalFunctions(styles) {
+	return FUNCTION_KEY in styles;
+}
+/**
+* Extract local @function definitions from a styles object.
+* Returns null if none (fast path).
+*/
+function extractLocalFunctions(styles) {
+	const functions = styles[FUNCTION_KEY];
+	if (!functions || typeof functions !== "object") return null;
+	return functions;
+}
+/**
+* Parse a function name token into its CSS custom name.
+* Accepts `$$name`, `$name`, `--name`, or bare `name` → `--name`.
+*/
+function parseFunctionName(token) {
+	if (token.startsWith("$$")) return `--${token.slice(2)}`;
+	if (token.startsWith("$")) return `--${token.slice(1)}`;
+	if (token.startsWith("--")) return token;
+	return `--${token}`;
+}
+/**
+* Parse a parameter / local-variable name token into its CSS custom name.
+* Accepts `$name`, `--name`, or bare `name` → `--name`.
+*/
+function parseParamName(token) {
+	if (token.startsWith("$")) return `--${token.slice(1)}`;
+	if (token.startsWith("--")) return token;
+	return `--${token}`;
+}
+/**
+* Format a single parameter (`--name <type>: default`).
+*/
+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;
+}
+/**
+* Format the function prelude: `@function --name(params) returns <type>`.
+*/
+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}`;
+}
+/**
+* Format the inner declarations of a @function rule (local variables + result).
+*/
+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(" ");
+}
+/**
+* Format a complete @function rule as CSS.
+*/
+function formatFunctionRule(name, def) {
+	return `${formatFunctionPrelude(name, def.args, def.returns)} { ${formatFunctionDeclarations(def)} }`;
+}
+/** A key is a CSS-function key when it carries the `$`/`--` prefix. */
+function isCssFunctionKey(key) {
+	return key.startsWith("$") || key.startsWith("--");
+}
+/** Discriminate a unified `functions` entry by its value type. */
+function isParseFunction(value) {
+	return typeof value === "function";
+}
+/**
+* Split the unified `functions` map into the two internal registries:
+* - `parseFuncs`: JS parse functions (bare keys).
+* - `functionDefs`: declarative CSS `@function` definitions (`$$` keys).
+*
+* Entries whose key prefix does not match the value type are reported via
+* `onMismatch` and skipped.
+*/
+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);
+/**
+* Rewrite `var(--name)` references for declared parameter/local names to a
+* collision-resistant, function-scoped prefix. This guarantees that later
+* value substitution only ever targets the function's own variables and can
+* never accidentally match a real element-level `var(--name)` introduced by an
+* argument value (e.g. the `--gap` used by Tasty units). Blanket prefix — no
+* exact-collision detection.
+*/
+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;
+}
+/**
+* Replace the prefixed `var(--<prefixed>)` / `var(--<prefixed>, fallback)`
+* references with their mapped values, iterating so that local variables that
+* reference parameters (or other locals) resolve fully.
+*/
+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;
+}
+/** Function names currently being expanded, to guard against recursion cycles. */
+const inProgress = /* @__PURE__ */ new Set();
+/**
+* Compile a declarative `@function` definition into a parse-function closure
+* that fully inlines the call into plain CSS (the `@function` polyfill).
+*
+* Parameters and local variables are substituted directly with their values,
+* so no function-internal custom properties are emitted (collisions are
+* structurally impossible). Self/mutually-recursive functions are not expanded:
+* the cycle guard bails and the call is left untouched.
+*/
+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);
+		}
+	};
+}
+/** CSS function name -> serialized definition, to dedupe polyfill registration. */
+const registeredFunctionDefs = /* @__PURE__ */ new Map();
+/**
+* Register a declarative `@function` as a parse-function closure so the parser
+* inlines its call sites. Deduplicated by name + definition; a later, different
+* definition of the same name overrides the previous one (local wins).
+*/
+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));
+}
+/** Register all local `@function` definitions from a styles object (polyfill). */
+function registerLocalFunctionPolyfills(styles) {
+	const local = extractLocalFunctions(styles);
+	if (!local) return;
+	for (const [name, definition] of Object.entries(local)) registerFunctionPolyfill(name, definition);
+}
+/** Clear polyfill registration bookkeeping (used by resetConfig in tests). */
+function resetFunctionPolyfills() {
+	registeredFunctionDefs.clear();
+}
+//#endregion
+//#region src/properties/index.ts
+const PROPERTIES_KEY = "@property";
+/**
+* Valid CSS custom property name pattern (after the -- prefix).
+* Must start with a letter or underscore, followed by letters, digits, hyphens, or underscores.
+*/
+const VALID_PROPERTY_NAME_PATTERN = /^[a-z_][a-z0-9-_]*$/i;
+/**
+* Validate a CSS custom property name (the part after --).
+* Returns true if the name is valid for use as a CSS custom property.
+*/
+function isValidPropertyName(name) {
+	return VALID_PROPERTY_NAME_PATTERN.test(name);
+}
+/**
+* Check if styles object has local @property definition.
+* Fast path: single property lookup.
+*/
+function hasLocalProperties(styles) {
+	return PROPERTIES_KEY in styles;
+}
+/**
+* Extract local @property from styles object.
+* Returns null if no local properties (fast path).
+*/
+function extractLocalProperties(styles) {
+	const properties = styles[PROPERTIES_KEY];
+	if (!properties || typeof properties !== "object") return null;
+	return properties;
+}
+/**
+* Parse a property token name and return the CSS property name and whether it's a color.
+* Supports tasty token syntax and validates the property name.
+*
+* Token formats:
+* - `$name` → { cssName: '--name', isColor: false }
+* - `#name` → { cssName: '--name-color', isColor: true }
+* - `--name` → { cssName: '--name', isColor: false } (legacy, auto-detect color by suffix)
+* - `name` → { cssName: '--name', isColor: false } (legacy)
+*
+* @param token - The property token to parse
+* @returns Parsed result with cssName, isColor, isValid, and optional error
+*/
+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
+	};
+}
+/**
+* Normalize a property definition to a consistent string representation.
+* Used for comparing definitions to detect type conflicts.
+*
+* Only `syntax` and `inherits` are compared — `initialValue` is intentionally
+* excluded because different components may set different defaults for the
+* same typed property (e.g. auto-inferred `0px` vs explicit `6px`).
+*
+* Keys are sorted alphabetically to ensure consistent comparison:
+* { inherits: true, syntax: '<color>' } === { syntax: '<color>', inherits: 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);
+}
+/**
+* Get the effective property definition for a token.
+* For color tokens (#name), auto-sets syntax to '<color>' and defaults initialValue to 'transparent'.
+*
+* @param token - Property token ($name, #name, --name, or plain name)
+* @param userDefinition - User-provided definition options
+* @returns Effective definition with cssName, definition, isValid, and optional error
+*/
+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"
+};
+/**
+* Infer CSS @property syntax from a concrete value.
+* Detects numeric types: \<number\>, \<length-percentage\>, \<angle\>, \<time\>.
+* Length and percentage values both map to \<length-percentage\> for maximum flexibility.
+* Color properties are handled separately via the #name token convention
+* (--name-color gets \<color\> syntax automatically in getEffectiveDefinition).
+*
+* @param value - The CSS value to infer from (e.g. '10px', '1', '45deg')
+* @returns Inferred syntax and initial value, or null if not inferable
+*/
+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
+/**
+* Fast string hash (djb2) for deduplication keys.
+* Not cryptographic — just collision-resistant enough for cache keys.
+*/
+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
+/**
+* Name prefix utilities for generated identifiers.
+*
+* Tasty generates three kinds of identifiers from content hashes:
+* - class names (used in DOM `class` attribute)
+* - keyframe names (used in CSS `animation`)
+* - counter-style names (used in CSS `list-style-type`)
+*
+* All three derive from a single configurable prefix so that an app
+* can namespace every identifier under one string. Discriminator letters
+* (`k`, `c`) keep the three kinds visually distinct in devtools — they
+* are not required for correctness (CSS keeps these in separate
+* namespaces), only for readability.
+*
+* The runtime / SSR / RSC paths must agree on the prefix; otherwise the
+* client-side hash for a given style will not match the server-rendered
+* class and hydration breaks. The zero-runtime build path uses a
+* different default (`'ts'`) so its classes can't collide with runtime
+* (`'t'`) classes when both are loaded on the same page.
+*/
+/** Default prefix used by the runtime / SSR / RSC paths. */
+const DEFAULT_NAME_PREFIX = "t";
+/** Default prefix used by the zero-runtime (`tastyStatic`) build path. */
+const DEFAULT_ZERO_NAME_PREFIX = "ts";
+/**
+* Allowed shape: starts with a letter or underscore, then letters/
+* digits/underscore/hyphen. Length capped at 32 to keep generated
+* names sane. Matches the CSS identifier rules for the common case
+* while keeping the surface conservative.
+*/
+const NAME_PREFIX_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_-]{0,31}$/;
+/**
+* Validate a `namePrefix` value.
+* Throws a TypeError with a descriptive message on invalid input so
+* misconfiguration fails loudly at `configure()` time rather than
+* surfacing later as broken hydration.
+*/
+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".`);
+}
+/**
+* Build a class name: `${prefix}${hash}`.
+* The hash is appended verbatim — supply a separator inside the prefix
+* itself if you want one (e.g. `'myapp-'`).
+*/
+function makeClassName(prefix, hash) {
+	return `${prefix}${hash}`;
+}
+/**
+* Build a keyframe name: `${prefix}k${suffix}`.
+* The `k` discriminator keeps keyframe names visually distinct from
+* class names sharing the same prefix. `suffix` is typically a content
+* hash but may be a counter for ad-hoc allocation.
+*/
+function makeKeyframeName(prefix, suffix) {
+	return `${prefix}k${suffix}`;
+}
+/**
+* Build a counter-style name: `${prefix}c${suffix}`.
+* The `c` discriminator keeps counter-style names visually distinct
+* from class names sharing the same prefix.
+*/
+function makeCounterStyleName(prefix, suffix) {
+	return `${prefix}c${suffix}`;
+}
+/** Escape a string for safe inclusion in a regex literal. */
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Regex matching any tasty class for the given prefix.
+* Used by the runtime GC's DOM scan and class-allocation bookkeeping.
+*/
+function tastyClassRegex(prefix) {
+	return new RegExp(`^${escapeRegex(prefix)}[a-z0-9]+$`);
+}
+/**
+* Global regex extracting tasty class names from RSC-inlined CSS.
+* Looks for the doubled-specificity pattern `.cls.cls` that
+* `formatRules()` always emits, which makes extraction reliable.
+*/
+function rscClassRegexGlobal(prefix) {
+	return new RegExp(`\\.(${escapeRegex(prefix)}[a-z0-9]+)\\.\\1`, "g");
+}
+//#endregion
+//#region src/properties/property-type-resolver.ts
+/**
+* PropertyTypeResolver
+*
+* Automatically infers CSS @property types from custom property values.
+* Supports deferred resolution for var() reference chains of arbitrary depth.
+*/
+/**
+* One `--name: value` declaration, with the surrounding whitespace dropped.
+*
+* The value is anchored on `\S` at both ends so no two quantifiers can claim
+* the same character. A lazy `(.+?)\s*$` is quadratic on a value of nothing
+* but spaces — every split point gets tried (CodeQL `js/polynomial-redos`).
+*/
+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 {
+	/** propName → the prop it depends on */
+	pendingDeps = /* @__PURE__ */ new Map();
+	/** propName → list of props waiting on it */
+	reverseDeps = /* @__PURE__ */ new Map();
+	/**
+	* Scan CSS declarations and auto-register @property for custom properties
+	* whose types can be inferred from their values.
+	*/
+	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";
+/**
+* Check if styles object has local @font-face definition.
+*/
+function hasLocalFontFace(styles) {
+	return FONT_FACE_KEY in styles;
+}
+/**
+* Extract local @font-face from styles object.
+* Returns null if no local font faces (fast path).
+*/
+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"
+};
+/**
+* Format the inner declarations of a @font-face rule (no wrapper).
+* Used by the injector which needs selector and declarations separately.
+*/
+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(" ");
+}
+/**
+* Format a single @font-face rule as CSS.
+*/
+function formatFontFaceRule(family, descriptors) {
+	return `@font-face { ${formatFontFaceDeclarations(family, descriptors)} }`;
+}
+/**
+* Generate a content hash for deduplication of a single font-face rule.
+*/
+function fontFaceContentHash(family, descriptors) {
+	return JSON.stringify({
+		family,
+		...descriptors
+	});
+}
+//#endregion
+//#region src/counter-style/index.ts
+const COUNTER_STYLE_KEY = "@counter-style";
+/**
+* Check if styles object has local @counter-style definition.
+*/
+function hasLocalCounterStyle(styles) {
+	return COUNTER_STYLE_KEY in styles;
+}
+/**
+* Extract local @counter-style from styles object.
+* Returns null if no local counter styles (fast path).
+*/
+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"
+};
+/**
+* Format the inner declarations of a @counter-style rule (no wrapper).
+* Used by the injector which needs selector and declarations separately.
+*/
+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(" ");
+}
+/**
+* Format a @counter-style rule as CSS.
+*/
+function formatCounterStyleRule(name, descriptors) {
+	return `@counter-style ${name} { ${formatCounterStyleDeclarations(descriptors)} }`;
+}
+//#endregion
+//#region src/properties/defaults.ts
+/**
+* Default properties shipped with Tasty.
+*
+* Kept with the property formatter so runtime and build-time configuration
+* paths can share the same list without importing the browser runtime.
+*/
+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/keyframes/index.ts
+const KEYFRAMES_KEY = "@keyframes";
+/**
+* Pattern to extract animation names from CSS animation property values.
+* Animation name is typically the first identifier in the shorthand.
+* Handles: "fadeIn 300ms ease-in", "pulse 1s infinite", etc.
+*
+* CSS animation shorthand order (all optional except name):
+* animation: name | duration | timing | delay | iteration | direction | fill-mode | play-state
+*
+* Animation names must:
+* - Start with a letter, underscore, or hyphen (but not a digit or CSS keyword)
+* - Not be CSS keywords: none, initial, inherit, unset, revert
+*/
+const CSS_KEYWORDS = new Set([
+	"none",
+	"initial",
+	"inherit",
+	"unset",
+	"revert",
+	"auto",
+	"normal",
+	"running",
+	"paused"
+]);
+/**
+* Pattern to match animation name at the start of an animation value.
+* Must start with letter, underscore, or hyphen (not digit).
+*/
+const ANIMATION_NAME_PATTERN = /^([a-zA-Z_-][a-zA-Z0-9_-]*)/;
+/**
+* Check if styles object has local @keyframes definition.
+* Fast path: single property lookup.
+*/
+function hasLocalKeyframes(styles) {
+	return KEYFRAMES_KEY in styles;
+}
+/**
+* Extract local @keyframes from styles object.
+* Returns null if no local keyframes (fast path).
+*/
+function extractLocalKeyframes(styles) {
+	const keyframes = styles[KEYFRAMES_KEY];
+	if (!keyframes || typeof keyframes !== "object") return null;
+	return keyframes;
+}
+/**
+* Merge local and global keyframes.
+* Local keyframes take priority over global.
+* Returns null if no keyframes exist (fast path).
+*/
+function mergeKeyframes(local, global) {
+	if (!local && !global) return null;
+	if (!local) return global;
+	if (!global) return local;
+	return {
+		...global,
+		...local
+	};
+}
+/**
+* Extract animation name from a single animation value.
+* Returns null if no valid name found.
+*
+* Examples:
+* - "fadeIn 300ms ease-in" → "fadeIn"
+* - "1s pulse infinite" → "pulse" (name can be anywhere)
+* - "none" → null (CSS keyword)
+* - "300ms ease-in" → null (no name, just duration/timing)
+*/
+function extractAnimationNameFromValue(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	const parts = trimmed.split(/\s+/);
+	for (const part of parts) {
+		if (CSS_KEYWORDS.has(part.toLowerCase())) continue;
+		if (/^-?[\d.]+m?s$/i.test(part)) continue;
+		if (part === "infinite" || /^\d+$/.test(part)) continue;
+		if ([
+			"normal",
+			"reverse",
+			"alternate",
+			"alternate-reverse"
+		].includes(part.toLowerCase())) continue;
+		if ([
+			"forwards",
+			"backwards",
+			"both"
+		].includes(part.toLowerCase())) continue;
+		if (["running", "paused"].includes(part.toLowerCase())) continue;
+		if (/^(ease|linear|ease-in|ease-out|ease-in-out|step-start|step-end)$/i.test(part)) continue;
+		if (/^(cubic-bezier|steps)\(/i.test(part)) continue;
+		const match = ANIMATION_NAME_PATTERN.exec(part);
+		if (match) return match[1];
+	}
+	return null;
+}
+/**
+* Extract all animation names from an animation property value.
+* Handles multiple animations separated by commas.
+*
+* Example: "fadeIn 300ms, slideIn 500ms ease-out" → ["fadeIn", "slideIn"]
+*/
+function extractAnimationNamesFromAnimationValue(value) {
+	const names = [];
+	const animations = value.split(",");
+	for (const animation of animations) {
+		const name = extractAnimationNameFromValue(animation);
+		if (name && !names.includes(name)) names.push(name);
+	}
+	return names;
+}
+/**
+* Extract animation names from a style value (handles mappings and arrays).
+*/
+function extractAnimationNamesFromStyleValue(value, names) {
+	if (typeof value === "string") for (const name of extractAnimationNamesFromAnimationValue(value)) names.add(name);
+	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);
+}
+/**
+* Extract all animation names referenced in styles.
+* Scans 'animation' and 'animationName' properties including in state mappings.
+* Returns empty set if no animation properties found (fast path).
+*/
+function extractAnimationNamesFromStyles(styles) {
+	const names = /* @__PURE__ */ new Set();
+	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") {
+			const nestedNames = extractAnimationNamesFromStyles(value);
+			for (const name of nestedNames) names.add(name);
+		}
+	}
+	return names;
+}
+/**
+* Replace animation names in CSS declarations with injected names.
+* Optimized to avoid regex creation - uses simple string replacement.
+*
+* @param declarations CSS declarations string
+* @param nameMap Map from original name to injected name (only contains names that differ)
+* @returns Updated declarations string
+*/
+/**
+* The name a local `@keyframes` block is emitted under.
+*
+* Content-addressed, and a pure function of what was authored: the same steps
+* always produce the same name, and different steps under the same authored
+* name cannot collide. That is what lets the server and the client agree —
+* a name handed out by whichever injector happened to see the definition first
+* depends on run order, so the two would disagree on both the animation name
+* and the class that references it.
+*/
+function resolveKeyframesName(authored, steps) {
+	return `${authored}-${hashString(JSON.stringify(steps))}`;
+}
+/**
+* The emitted name for every local `@keyframes` in `styles`, by authored name.
+* Pure — the server, the RSC pass and the client all reach the same answer.
+*/
+function resolveKeyframesNames(used) {
+	const names = /* @__PURE__ */ new Map();
+	for (const [authored, steps] of Object.entries(used)) names.set(authored, resolveKeyframesName(authored, steps));
+	return names;
+}
+/**
+* Whether `declarations` names `animation` as an animation to run.
+*
+* Only `animation` and `animation-name` values count, and only whole tokens
+* within them: an animation called `crossfade` does not use keyframes called
+* `fade`. Same parsing as `replaceAnimationNames`, so the two agree on what
+* counts as a reference.
+*/
+function referencesAnimation(declarations, animation) {
+	if (!declarations.includes("animation")) return false;
+	for (const part of declarations.split(";")) {
+		const colonIdx = part.indexOf(":");
+		if (colonIdx === -1) continue;
+		const prop = part.slice(0, colonIdx).trim().toLowerCase();
+		if (prop !== "animation" && prop !== "animation-name") continue;
+		const value = part.slice(colonIdx + 1);
+		if (replaceWord(value, animation, "\0") !== value) return true;
+	}
+	return false;
+}
+function replaceAnimationNames(declarations, nameMap) {
+	if (!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, injected] of nameMap) {
+				const newValue = replaceWord(value, original, injected);
+				if (newValue !== value) {
+					value = newValue;
+					modified = true;
+				}
+			}
+			parts[i] = prefix + value;
+		}
+	}
+	return modified ? parts.join(";") : declarations;
+}
+/**
+* Replace a word in a string (word boundary aware, no regex).
+*/
+function replaceWord(str, word, replacement) {
+	let result = str;
+	let idx = 0;
+	while ((idx = result.indexOf(word, idx)) !== -1) {
+		const before = idx === 0 ? " " : result[idx - 1];
+		const after = idx + word.length >= result.length ? " " : result[idx + word.length];
+		const isWordBoundaryBefore = !/[a-zA-Z0-9_-]/.test(before);
+		const isWordBoundaryAfter = !/[a-zA-Z0-9_-]/.test(after);
+		if (isWordBoundaryBefore && isWordBoundaryAfter) {
+			result = result.slice(0, idx) + replacement + result.slice(idx + word.length);
+			idx += replacement.length;
+		} else idx += word.length;
+	}
+	return result;
+}
+/**
+* Filter keyframes to only those that are actually used.
+* Returns null if no keyframes are used (fast path).
+*/
+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
+/**
+* Format a single @property rule as a CSS string.
+*
+* Returns the full `@property --name { ... }` text, or empty string
+* if the token is invalid.
+*/
+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
+/**
+* Convert keyframes steps to a CSS string.
+* Replicates SheetManager.stepsToCSS() without the class instance.
+*/
+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(" ");
+}
+/**
+* Format a @keyframes rule as a CSS string.
+*/
+function formatKeyframesCSS(name, steps) {
+	return `@keyframes ${name} { ${stepsToCSS(steps)} }`;
+}
+//#endregion
+//#region src/ssr/format-rules.ts
+/**
+* Resolve selectors for a rule, applying className-based specificity doubling
+* and rootPrefix handling. Mirrors the logic in StyleInjector.inject().
+*/
+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;
+}
+/**
+* Group rules by selector + at-rules + startingStyle and merge their declarations.
+* Mirrors the grouping logic in SheetManager.insertRule().
+*/
+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));
+}
+/**
+* Format an array of StyleResult rules into a CSS text string.
+*
+* Applies className-based specificity doubling (.cls.cls),
+* groups rules by selector + at-rules, and wraps with at-rule blocks.
+*
+* Produces the same CSS text as SheetManager.insertRule() would insert
+* into the DOM, but as a plain string suitable for SSR output.
+*/
+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
+/**
+* Format an array of global StyleResult rules into a CSS text string.
+*
+* Rules already have their full selectors applied by renderStyles().
+* Handles rootPrefix prepending and at-rule wrapping.
+*/
+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 { rscClassRegexGlobal as A, formatFunctionDeclarations as B, hasLocalFontFace as C, makeClassName as D, DEFAULT_ZERO_NAME_PREFIX as E, getEffectiveDefinition as F, registerFunctionPolyfill as G, formatFunctionRule as H, hasLocalProperties as I, splitFunctions as J, registerLocalFunctionPolyfills as K, normalizePropertyDefinition as L, validateNamePrefix as M, hashString as N, makeCounterStyleName as O, extractLocalProperties as P, parsePropertyToken as R, formatFontFaceRule as S, DEFAULT_NAME_PREFIX as T, hasLocalFunctions as U, formatFunctionPrelude as V, parseFunctionName as W, formatCounterStyleRule as _, formatPropertyCSS as a, fontFaceContentHash as b, filterUsedKeyframes as c, referencesAnimation as d, replaceAnimationNames as f, formatCounterStyleDeclarations as g, extractLocalCounterStyle as h, formatKeyframesCSS as i, tastyClassRegex as j, makeKeyframeName as k, hasLocalKeyframes as l, DEFAULT_PROPERTIES as m, formatGlobalRules as n, extractAnimationNamesFromStyles as o, resolveKeyframesNames as p, resetFunctionPolyfills as q, formatRules as r, extractLocalKeyframes as s, createServerStyleArtifact as t, mergeKeyframes as u, hasLocalCounterStyle as v, PropertyTypeResolver as w, formatFontFaceDeclarations as x, extractLocalFontFace as y, extractLocalFunctions as z };
+
+//# sourceMappingURL=css-definitions-BZ9vm0ci.js.map