@tenphi/tasty 0.0.0-snapshot.d656d18 → 0.0.0-snapshot.d720187

package/dist/chunks/{runtime-engine-Y00VWjrS.js → runtime-engine-BfqCASPn.js}

@@ -1,254 +1,8 @@
-import { F as RE_NUMBER, I as RE_RAW_UNIT, T as Lru, _ as setGlobalPredefinedTokens, c as getGlobalParseFunctions, d as normalizeColorTokenValue, h as resetGlobalPredefinedTokens, i as CUSTOM_UNITS, l as getGlobalParser, m as resetGlobalParseFunctions, o as customFunction, p as parseStyle } from "./dsl-CXvoaLnj.js";
-import { i as warn, n as isSelector, o as isDevEnv, r as resetStyleWarnings, t as mergeStyles } from "./shared-utils-OIg0N_dp.js";
-import { A as resetHandlers, E as STYLE_HANDLER_MAP, H as hasStylesGenerated, M as createStyle, O as normalizeHandlerDefinition, T as setGlobalPredefinedStates, U as markStylesGeneratedState, V as resetStyleChunks, W as resetStylesGeneratedState, a as registerBaseStyleProps, b as renderStyles, k as registerHandler, o as resetBaseStyleProps, y as clearPipelineCache } from "./style-engine-CqSmIlud.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
+import { T as Lru, h as resetGlobalPredefinedTokens, m as resetGlobalParseFunctions, p as parseStyle } from "./dsl-CXvoaLnj.js";
+import { i as warn, n as isSelector, o as isDevEnv, r as resetStyleWarnings } from "./shared-utils-OIg0N_dp.js";
+import { A as validateNamePrefix, D as makeKeyframeName, F as normalizePropertyDefinition, G as resetFunctionPolyfills, H as parseFunctionName, N as getEffectiveDefinition, O as rscClassRegexGlobal, R as formatFunctionDeclarations, S as PropertyTypeResolver, T as makeClassName, j as hashString, k as tastyClassRegex, m as formatCounterStyleDeclarations, v as fontFaceContentHash, y as formatFontFaceDeclarations, z as formatFunctionPrelude } from "./css-definitions-CfXdhJ-p.js";
+import { C as STYLE_HANDLER_MAP, D as resetHandlers, G as resetGlobalPolyfillsState, H as hasStylesGenerated, K as resetStylesGeneratedState, R as resetStyleChunks, U as isFunctionsPolyfillEnabled, W as markStylesGeneratedState, a as registerBaseStyleProps, b as renderStyles, k as createStyle, o as resetBaseStyleProps, y as clearPipelineCache } from "./style-engine-CBuOt1e4.js";
+import { n as applyStyleConfig, r as normalizeConfig, t as resolveRecipesWith } from "./config-engine-7nX85gCT.js";
 //#region src/prop-handlers.ts
 /**
 * Props middleware for tasty components.
@@ -370,318 +124,6 @@ function resetPropHandlers() {
 	propHandlerRegistry.apply = null;
 }
 //#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/injector/batch.ts
 /**
 * Deferred CSSOM writes ("batched injection").
@@ -887,99 +329,6 @@ function resetStyleBatch() {
 	warnedNoProvider = false;
 }
 //#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/injector/sheet-manager.ts
 const supportsConstructableSheets = typeof CSSStyleSheet !== "undefined" && (() => {
 	try {
@@ -1940,114 +1289,6 @@ var SheetManager = class {
 	}
 };
 //#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/injector/injector.ts
 /**
 * How long a class is left alone after it was last known to be wanted.
@@ -2998,54 +2239,6 @@ var StyleInjector = class {
 	}
 };
 //#endregion
-//#region src/utils/typography.ts
-const RESERVED_PRESET_NAMES = new Set([
-	"strong",
-	"bold",
-	"italic",
-	"icon",
-	"tight"
-]);
-/**
-* Generate typography tokens with $ prefix for CSS custom properties.
-*
-* Each preset generates the following CSS custom properties:
-* - `${name}-font-size`
-* - `${name}-line-height`
-* - `${name}-letter-spacing`
-* - `${name}-font-weight`
-* - `${name}-bold-font-weight` (if defined)
-* - `${name}-icon-size` (if defined)
-* - `${name}-text-transform` (if defined)
-* - `${name}-font-family` (if defined)
-* - `${name}-font-style` (if defined)
-*
-* @param presets - Typography presets object
-* @returns ConfigTokens object with $ prefixed keys
-*
-* @example
-* const customTokens = generateTypographyTokens({
-*   myHeading: { fontSize: '24px', lineHeight: '32px', fontWeight: '700' },
-*   body: { fontSize: '16px', lineHeight: '24px', fontWeight: '400' },
-* });
-*/
-function generateTypographyTokens(presets) {
-	const tokens = {};
-	for (const [name, preset] of Object.entries(presets)) {
-		if (RESERVED_PRESET_NAMES.has(name)) throw new Error(`Invalid typography preset name "${name}". This name is reserved as a preset modifier.`);
-		tokens[`$${name}-font-size`] = preset.fontSize;
-		tokens[`$${name}-line-height`] = preset.lineHeight;
-		tokens[`$${name}-letter-spacing`] = preset.letterSpacing ?? "normal";
-		tokens[`$${name}-font-weight`] = preset.fontWeight;
-		if (preset.boldFontWeight !== void 0) tokens[`$${name}-bold-font-weight`] = preset.boldFontWeight;
-		if (preset.iconSize !== void 0) tokens[`$${name}-icon-size`] = preset.iconSize;
-		if (preset.textTransform !== void 0) tokens[`$${name}-text-transform`] = preset.textTransform;
-		if (preset.fontFamily !== void 0) tokens[`$${name}-font-family`] = preset.fontFamily;
-		if (preset.fontStyle !== void 0) tokens[`$${name}-font-style`] = preset.fontStyle;
-	}
-	return tokens;
-}
-//#endregion
 //#region src/config.ts
 /**
 * Tasty Configuration Module
@@ -3060,12 +2253,12 @@ function generateTypographyTokens(presets) {
 * reconfigure will emit a warning and be ignored.
 */
 const emittedWarnings = /* @__PURE__ */ new Set();
-const devMode$1 = isDevEnv();
+const devMode = isDevEnv();
 /**
 * Emit a warning only once
 */
 function warnOnce(key, message) {
-	if (devMode$1 && !emittedWarnings.has(key)) {
+	if (devMode && !emittedWarnings.has(key)) {
 		emittedWarnings.add(key);
 		console.warn(message);
 	}
@@ -3075,7 +2268,6 @@ let globalKeyframes = null;
 let globalFontFace = null;
 let globalCounterStyle = null;
 let globalFunction = null;
-let globalPolyfills = null;
 let globalProperties = null;
 let globalRecipes = null;
 let globalConfigTokens = null;
@@ -3084,7 +2276,6 @@ const GTKEY_TOKENS = "__tasty_cfg_tokens__";
 const GTKEY_FONT_FACE = "__tasty_cfg_font_face__";
 const GTKEY_COUNTER_STYLE = "__tasty_cfg_counter_style__";
 const GTKEY_FUNCTION = "__tasty_cfg_function__";
-const GTKEY_POLYFILLS = "__tasty_cfg_polyfills__";
 const GTKEY_PROPERTIES = "__tasty_cfg_properties__";
 const GTKEY_GLOBAL_STYLES = "__tasty_cfg_global_styles__";
 function setOnGlobalThis(key, value) {
@@ -3099,7 +2290,6 @@ function clearGlobalThisConfig() {
 	delete g[GTKEY_FONT_FACE];
 	delete g[GTKEY_COUNTER_STYLE];
 	delete g[GTKEY_FUNCTION];
-	delete g[GTKEY_POLYFILLS];
 	delete g[GTKEY_PROPERTIES];
 	delete g[GTKEY_GLOBAL_STYLES];
 }
@@ -3370,28 +2560,6 @@ function setGlobalFunction(functions) {
 	setOnGlobalThis(GTKEY_FUNCTION, globalFunction);
 }
 /**
-* Whether the CSS `@function` polyfill (inline expansion) is enabled.
-* Reads from globalThis first for cross-module SSR/zero-runtime support.
-*/
-function isFunctionsPolyfillEnabled() {
-	return (globalPolyfills ?? getFromGlobalThis(GTKEY_POLYFILLS) ?? null)?.functions === true;
-}
-/**
-* Set global polyfill toggles (called from configure).
-* Internal use only.
-*/
-function setGlobalPolyfills(polyfills) {
-	if (hasStylesGenerated()) {
-		warnOnce("polyfills-after-styles", "[Tasty] Cannot update polyfills after styles have been generated.\nThe new polyfill toggles will be ignored.");
-		return;
-	}
-	globalPolyfills = {
-		...globalPolyfills ?? {},
-		...polyfills
-	};
-	setOnGlobalThis(GTKEY_POLYFILLS, globalPolyfills);
-}
-/**
 * Check if any global recipes are configured.
 * Fast path: returns false if no recipes were ever set.
 */
@@ -3414,7 +2582,7 @@ function setGlobalRecipes(recipes) {
 		warnOnce("recipes-after-styles", "[Tasty] Cannot update recipes after styles have been generated.\nThe new recipes will be ignored.");
 		return;
 	}
-	if (devMode$1) for (const [name, recipeStyles] of Object.entries(recipes)) {
+	if (devMode) for (const [name, recipeStyles] of Object.entries(recipes)) {
 		if (name === "none") warnOnce("recipe-reserved-none", "[Tasty] Recipe name \"none\" is reserved. It is used as a keyword meaning \"no base recipes\" (e.g. recipe: 'none / post-recipe'). Choose a different name for your recipe.");
 		for (const key of Object.keys(recipeStyles)) {
 			if (isSelector(key)) warnOnce(`recipe-selector-${name}-${key}`, `[Tasty] Recipe "${name}" contains sub-element key "${key}". Recipes must be flat styles without sub-element keys. Remove the sub-element key from the recipe definition.`);
@@ -3506,207 +2674,16 @@ function configure(config = {}) {
 		return;
 	}
 	if (config.namePrefix !== void 0) validateNamePrefix(config.namePrefix);
-	let mergedStates = {};
-	let mergedUnits = {};
-	let mergedFunctions = {};
-	let mergedHandlers = {};
-	/** Where each handler key came from, so registration warnings can name it. */
-	const handlerSources = /* @__PURE__ */ new Map();
-	let mergedPropHandlers = {};
-	/** Where each prop handler key came from, for its warnings. */
-	const propHandlerSources = /* @__PURE__ */ new Map();
-	const mergedBaseStyleProps = [];
-	let mergedProperties = {};
-	let mergedKeyframes = {};
-	let mergedFontFaces = {};
-	let mergedCounterStyles = {};
-	let mergedReplaceTokens = {};
-	let mergedConfigTokens = {};
-	let mergedRecipes = {};
-	let mergedPresets = {};
-	const mergedGlobalStyles = {};
-	if (config.plugins) for (const plugin of config.plugins) {
-		if (plugin.states) mergedStates = {
-			...mergedStates,
-			...plugin.states
-		};
-		if (plugin.units) mergedUnits = {
-			...mergedUnits,
-			...plugin.units
-		};
-		if (plugin.functions) mergedFunctions = {
-			...mergedFunctions,
-			...plugin.functions
-		};
-		if (plugin.handlers) {
-			mergedHandlers = {
-				...mergedHandlers,
-				...plugin.handlers
-			};
-			for (const key of Object.keys(plugin.handlers)) handlerSources.set(key, `plugin "${plugin.name}"`);
-		}
-		if (plugin.propHandlers) {
-			mergedPropHandlers = {
-				...mergedPropHandlers,
-				...plugin.propHandlers
-			};
-			for (const key of Object.keys(plugin.propHandlers)) propHandlerSources.set(key, `plugin "${plugin.name}"`);
-		}
-		if (plugin.baseStyleProps) mergedBaseStyleProps.push(...plugin.baseStyleProps);
-		if (plugin.properties) mergedProperties = {
-			...mergedProperties,
-			...plugin.properties
-		};
-		if (plugin.keyframes) mergedKeyframes = {
-			...mergedKeyframes,
-			...plugin.keyframes
-		};
-		if (plugin.fontFaces) mergedFontFaces = {
-			...mergedFontFaces,
-			...plugin.fontFaces
-		};
-		if (plugin.counterStyles) mergedCounterStyles = {
-			...mergedCounterStyles,
-			...plugin.counterStyles
-		};
-		if (plugin.replaceTokens) mergedReplaceTokens = {
-			...mergedReplaceTokens,
-			...plugin.replaceTokens
-		};
-		if (plugin.tokens) mergedConfigTokens = {
-			...mergedConfigTokens,
-			...plugin.tokens
-		};
-		if (plugin.recipes) mergedRecipes = {
-			...mergedRecipes,
-			...plugin.recipes
-		};
-		if (plugin.presets) mergedPresets = {
-			...mergedPresets,
-			...plugin.presets
-		};
-		if (plugin.globalStyles) for (const [sel, styles] of Object.entries(plugin.globalStyles)) mergedGlobalStyles[sel] = mergedGlobalStyles[sel] ? {
-			...mergedGlobalStyles[sel],
-			...styles
-		} : styles;
-	}
-	if (config.states) mergedStates = {
-		...mergedStates,
-		...config.states
-	};
-	if (config.units) mergedUnits = {
-		...mergedUnits,
-		...config.units
-	};
-	if (config.functions) mergedFunctions = {
-		...mergedFunctions,
-		...config.functions
-	};
-	if (config.handlers) {
-		mergedHandlers = {
-			...mergedHandlers,
-			...config.handlers
-		};
-		for (const key of Object.keys(config.handlers)) handlerSources.set(key, "configure()");
-	}
-	if (config.propHandlers) {
-		mergedPropHandlers = {
-			...mergedPropHandlers,
-			...config.propHandlers
-		};
-		for (const key of Object.keys(config.propHandlers)) propHandlerSources.set(key, "configure()");
-	}
-	if (config.baseStyleProps) mergedBaseStyleProps.push(...config.baseStyleProps);
-	if (config.properties) mergedProperties = {
-		...mergedProperties,
-		...config.properties
-	};
-	if (config.keyframes) mergedKeyframes = {
-		...mergedKeyframes,
-		...config.keyframes
-	};
-	if (config.fontFaces) mergedFontFaces = {
-		...mergedFontFaces,
-		...config.fontFaces
-	};
-	if (config.counterStyles) mergedCounterStyles = {
-		...mergedCounterStyles,
-		...config.counterStyles
-	};
-	if (config.replaceTokens) mergedReplaceTokens = {
-		...mergedReplaceTokens,
-		...config.replaceTokens
-	};
-	if (config.presets) mergedPresets = {
-		...mergedPresets,
-		...config.presets
-	};
-	if (Object.keys(mergedPresets).length > 0) mergedConfigTokens = {
-		...generateTypographyTokens(mergedPresets),
-		...mergedConfigTokens
-	};
-	if (config.tokens) mergedConfigTokens = {
-		...mergedConfigTokens,
-		...config.tokens
-	};
-	if (config.recipes) mergedRecipes = {
-		...mergedRecipes,
-		...config.recipes
-	};
-	if (config.globalStyles) for (const [sel, styles] of Object.entries(config.globalStyles)) mergedGlobalStyles[sel] = mergedGlobalStyles[sel] ? {
-		...mergedGlobalStyles[sel],
-		...styles
-	} : styles;
-	if (devMode$1) {
-		const tokenKeys = new Set(Object.keys(mergedConfigTokens));
-		for (const key of Object.keys(mergedReplaceTokens)) if (tokenKeys.has(key)) warnOnce(`token-conflict-${key}`, `[Tasty] Token "${key}" is defined in both \`tokens\` and \`replaceTokens\`. \`replaceTokens\` performs parse-time substitution, so the \`tokens\` CSS custom property will be injected but never used by Tasty styles. Remove it from one of the two.`);
-	}
-	if (config.colorSpace) warnOnce("colorSpace-deprecated", "[Tasty] configure({ colorSpace }) no longer has any effect and will be removed in the next major. Colors are emitted as authored, and opacity is applied with relative color syntax, which reads a color's channels in the browser. To address channels yourself, write `oklch(from var(--name-color) l c h)` against the token.");
-	if (Object.keys(mergedStates).length > 0) setGlobalPredefinedStates(mergedStates);
-	const parser = getGlobalParser();
-	if (config.parserCacheSize !== void 0) parser.updateOptions({ cacheSize: config.parserCacheSize });
-	if (Object.keys(mergedUnits).length > 0) {
-		const currentUnits = parser.getUnits() ?? CUSTOM_UNITS;
-		parser.setUnits({
-			...currentUnits,
-			...mergedUnits
-		});
-	}
-	if (config.polyfills) setGlobalPolyfills(config.polyfills);
-	const { parseFuncs, functionDefs } = splitFunctions(mergedFunctions, (key, kind) => {
-		warnOnce(`functions-mismatch-${key}`, kind === "expected-definition" ? `[Tasty] functions["${key}"]: a "$$"-prefixed key denotes a CSS @function and expects a definition object, but received a function. Entry ignored.` : `[Tasty] functions["${key}"]: a bare key denotes a parse function and expects a function value, but received an object. Did you mean "$$${key}"? Entry ignored.`);
-	});
-	if (Object.keys(parseFuncs).length > 0) {
-		const currentFuncs = getGlobalParseFunctions();
-		const finalFuncs = {
-			...currentFuncs,
-			...parseFuncs
-		};
-		parser.setFunctions(finalFuncs);
-		Object.assign(currentFuncs, parseFuncs);
-	}
-	if (Object.keys(functionDefs).length > 0) if (isFunctionsPolyfillEnabled()) for (const [name, definition] of Object.entries(functionDefs)) registerFunctionPolyfill(name, definition);
-	else setGlobalFunction(functionDefs);
+	const normalized = normalizeConfig(config);
+	const { propHandlers: mergedPropHandlers, propHandlerSources, baseStyleProps: mergedBaseStyleProps, properties: mergedProperties, keyframes: mergedKeyframes, fontFaces: mergedFontFaces, counterStyles: mergedCounterStyles, tokens: mergedConfigTokens, recipes: mergedRecipes, globalStyles: mergedGlobalStyles } = normalized;
+	const functionDefs = applyStyleConfig(config, normalized, warnOnce);
+	if (!isFunctionsPolyfillEnabled() && Object.keys(functionDefs).length > 0) setGlobalFunction(functionDefs);
 	if (Object.keys(mergedKeyframes).length > 0) setGlobalKeyframes(mergedKeyframes);
 	if (Object.keys(mergedProperties).length > 0) setGlobalProperties(mergedProperties);
 	if (Object.keys(mergedFontFaces).length > 0) setGlobalFontFace(mergedFontFaces);
 	if (Object.keys(mergedCounterStyles).length > 0) setGlobalCounterStyle(mergedCounterStyles);
-	if (Object.keys(mergedHandlers).length > 0) for (const [name, definition] of Object.entries(mergedHandlers)) registerHandler(normalizeHandlerDefinition(name, definition), {
-		key: name,
-		source: handlerSources.get(name)
-	});
 	if (Object.keys(mergedPropHandlers).length > 0) for (const [name, definition] of Object.entries(mergedPropHandlers)) registerPropHandler(name, definition, { source: propHandlerSources.get(name) });
 	if (mergedBaseStyleProps.length > 0) registerBaseStyleProps(mergedBaseStyleProps);
-	if (Object.keys(mergedReplaceTokens).length > 0) {
-		const processedTokens = {};
-		for (const [key, value] of Object.entries(mergedReplaceTokens)) if (key.startsWith("#")) {
-			const normalized = normalizeColorTokenValue(value);
-			if (normalized === null) continue;
-			processedTokens[key] = String(normalized);
-		} else if (value === false) continue;
-		else processedTokens[key] = String(value);
-		setGlobalPredefinedTokens(processedTokens);
-	}
 	if (Object.keys(mergedConfigTokens).length > 0) setGlobalConfigTokens(mergedConfigTokens);
 	if (Object.keys(mergedRecipes).length > 0) setGlobalRecipes(mergedRecipes);
 	if (Object.keys(mergedGlobalStyles).length > 0) setGlobalStyles(mergedGlobalStyles);
@@ -3761,7 +2738,7 @@ function resetConfig() {
 	globalFontFace = null;
 	globalCounterStyle = null;
 	globalFunction = null;
-	globalPolyfills = null;
+	resetGlobalPolyfillsState();
 	globalRecipes = null;
 	globalConfigTokens = null;
 	globalStyles = null;
@@ -4060,251 +3037,6 @@ function createInjector(config = {}) {
 	});
 }
 //#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/ssr-collector-ref.ts
 const GETTER_KEY = "__tasty_ssr_collector_getter__";
 let _getSSRCollector = null;
@@ -4331,307 +3063,10 @@ function getRegisteredSSRCollector() {
 	return getter ? getter() : 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/utils/resolve-recipes.ts
-/**
-* Recipe resolution utility.
-*
-* Resolves `recipe` style properties by looking up predefined recipe styles
-* from global configuration and merging them with the component's own styles.
-*
-* Resolution order per level (top-level and each sub-element independently):
-* base_recipe_1 base_recipe_2 → component styles → post_recipe_1 post_recipe_2
-*
-* The `/` separator splits base recipes (before component styles)
-* from post recipes (after component styles). All merges use mergeStyles
-* semantics: primitives and state maps with '' key fully replace;
-* state maps without '' key extend the existing value.
-*
-* Returns the same object reference if no recipes are present (zero overhead).
-*/
-const devMode = isDevEnv();
-/**
-* Parse a recipe string into base and post recipe name groups.
-*
-* Syntax: `'base1 base2 / post1 post2'`
-* - Names are space-separated within each group
-* - `/` separates base (before component) from post (after component) groups
-* - `/` is optional; if absent, all names are base
-* - `none` as the sole base value means "no base recipes"
-*
-* Returns `{ base: null, post: null }` if the string is empty or invalid.
-*/
-function parseRecipeNames(value) {
-	const empty = {
-		base: null,
-		post: null
-	};
-	if (typeof value !== "string") return empty;
-	const trimmed = value.trim();
-	if (trimmed === "") return empty;
-	const slashIndex = trimmed.indexOf("/");
-	if (slashIndex === -1) {
-		if (trimmed === "none") return empty;
-		return {
-			base: splitNames(trimmed),
-			post: null
-		};
-	}
-	const basePart = trimmed.slice(0, slashIndex);
-	const postPart = trimmed.slice(slashIndex + 1);
-	return {
-		base: basePart.trim() === "none" ? null : splitNames(basePart),
-		post: splitNames(postPart)
-	};
-}
-function splitNames(s) {
-	const names = s.split(/\s+/).filter(Boolean);
-	return names.length > 0 ? names : null;
-}
-/**
-* Collect merged styles for a list of recipe names.
-* Each recipe is flat-spread on top of the previous.
-*/
-function collectRecipeStyles(names, recipes) {
-	let merged = {};
-	for (const name of names) {
-		const recipeStyles = recipes[name];
-		if (!recipeStyles) {
-			if (devMode) console.warn(`[Tasty] Recipe "${name}" not found. Make sure it is defined in configure({ recipes: { ... } }).`);
-			continue;
-		}
-		merged = {
-			...merged,
-			...recipeStyles
-		};
-	}
-	return merged;
-}
-/**
-* Resolve recipe references in a flat styles object (no sub-elements).
-* Returns null if no `recipe` key is present.
-*
-* Resolution: base recipes → component styles → post recipes (all via mergeStyles)
-*/
-function resolveRecipesForLevel(styles, recipes) {
-	if (!("recipe" in styles)) return null;
-	const { base, post } = parseRecipeNames(styles.recipe);
-	const { recipe: _recipe, ...allRest } = styles;
-	const flatStyles = {};
-	const selectorStyles = {};
-	for (const key of Object.keys(allRest)) if (isSelector(key)) selectorStyles[key] = allRest[key];
-	else flatStyles[key] = allRest[key];
-	if (!base && !post) return allRest;
-	let result;
-	if (base) result = mergeStyles(collectRecipeStyles(base, recipes), flatStyles);
-	else result = { ...flatStyles };
-	if (post) {
-		const postStyles = collectRecipeStyles(post, recipes);
-		result = mergeStyles(result, postStyles);
-	}
-	for (const key of Object.keys(selectorStyles)) result[key] = selectorStyles[key];
-	return result;
-}
-/**
-* Resolve all `recipe` style properties in a styles object.
-*
-* Handles both top-level and sub-element recipe references.
-* Returns the same object reference if no recipes are present anywhere
-* (zero overhead for the common case).
-*
-* @param styles - The styles object potentially containing `recipe` keys
-* @returns Resolved styles with recipe values merged in, or the original object if unchanged
-*/
+/** Resolve recipe references against the globally configured recipe map. */
 function resolveRecipes(styles) {
-	const recipes = getGlobalRecipes();
-	if (!recipes) return styles;
-	let changed = false;
-	const topResolved = resolveRecipesForLevel(styles, recipes);
-	let result;
-	if (topResolved) {
-		changed = true;
-		result = topResolved;
-	} else result = styles;
-	const keys = Object.keys(result);
-	for (const key of keys) {
-		if (!isSelector(key)) continue;
-		const subStyles = result[key];
-		if (!subStyles || typeof subStyles !== "object" || Array.isArray(subStyles)) continue;
-		const subRecord = subStyles;
-		if (!("recipe" in subRecord)) continue;
-		const subResolved = resolveRecipesForLevel(subRecord, recipes);
-		if (subResolved) {
-			if (!changed) {
-				changed = true;
-				result = { ...styles };
-			}
-			result[key] = subResolved;
-		}
-	}
-	return changed ? result : styles;
+	return resolveRecipesWith(styles, getGlobalRecipes());
 }
 //#endregion
 //#region src/utils/cache-wrapper.ts
@@ -4651,25 +3086,6 @@ function cacheWrapper(handler, limit = 1e3) {
 	};
 }
 //#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/utils/client-state.ts
 /**
 * Build a per-(injector, root) client state cache for the standalone style
@@ -4714,6 +3130,6 @@ function depsEqual(a, b) {
 	return true;
 }
 //#endregion
-export { getNamePrefix as $, holdKeyframes as A, extractLocalProperties as At, ChunkSheetRegistry as B, destroy as C, DEFAULT_ZERO_NAME_PREFIX as Ct, getCSSText as D, tastyClassRegex as Dt, gc as E, makeKeyframeName as Et, isPropertyDefined as F, formatFunctionRule as Ft, getGlobalConfigTokens as G, configure as H, keyframes as I, hasLocalFunctions as It, getGlobalFunctions as J, getGlobalCounterStyles as K, ownKeyframes as L, parseFunctionName as Lt, injectGlobal as M, parsePropertyToken as Mt, injectRawCSS as N, propHandlerRegistry as Nt, getCSSTextForNode as O, validateNamePrefix as Ot, injector as P, extractLocalFunctions as Pt, getGlobalStyles as Q, property as R, registerFunctionPolyfill as Rt, createInjector as S, DEFAULT_NAME_PREFIX as St, func as T, makeCounterStyleName as Tt, getConfig as U, chunkSheetRegistry as V, getEffectiveProperties as W, getGlobalKeyframes as X, getGlobalInjector as Y, getGlobalRecipes as Z, referencesAnimation as _, closeBatchWindow as _t, resolveRecipes as a, resetConfig as at, cleanup as b, openBatchWindow as bt, formatPropertyCSS as c, extractLocalCounterStyle as ct, registerSSRCollectorGetterGlobal as d, extractLocalFontFace as dt, hasGlobalKeyframes as et, extractAnimationNamesFromStyles as f, fontFaceContentHash as ft, mergeKeyframes as g, PropertyTypeResolver as gt, hasLocalKeyframes as h, SheetManager as ht, cacheWrapper as i, isTestEnvironment as it, inject as j, hasLocalProperties as jt, getRawCSSText as k, hashString as kt, getRegisteredSSRCollector as l, formatCounterStyleRule as lt, filterUsedKeyframes as m, hasLocalFontFace as mt, createClientState as n, isConfigLocked as nt, formatRules as o, generateTypographyTokens as ot, extractLocalKeyframes as p, formatFontFaceRule as pt, getGlobalFontFaces as q, formatGlobalRules as r, isFunctionsPolyfillEnabled as rt, formatKeyframesCSS as s, StyleInjector as st, depsEqual as t, hasGlobalRecipes as tt, registerSSRCollectorGetter as u, hasLocalCounterStyle as ut, replaceAnimationNames as v, flushStyles as vt, fontFace as w, makeClassName as wt, counterStyle as x, resetStyleBatch as xt, resolveKeyframesNames as y, hasPendingStyleWrites as yt, touch as z, registerLocalFunctionPolyfills as zt };
+export { resetStyleBatch as $, configure as A, getGlobalStyles as B, isPropertyDefined as C, touch as D, property as E, getGlobalFontFaces as F, isTestEnvironment as G, hasGlobalKeyframes as H, getGlobalFunctions as I, SheetManager as J, resetConfig as K, getGlobalInjector as L, getEffectiveProperties as M, getGlobalConfigTokens as N, ChunkSheetRegistry as O, getGlobalCounterStyles as P, openBatchWindow as Q, getGlobalKeyframes as R, injector as S, ownKeyframes as T, hasGlobalRecipes as U, getNamePrefix as V, isConfigLocked as W, flushStyles as X, closeBatchWindow as Y, hasPendingStyleWrites as Z, getRawCSSText as _, getRegisteredSSRCollector as a, injectGlobal as b, cleanup as c, destroy as d, propHandlerRegistry as et, fontFace as f, getCSSTextForNode as g, getCSSText as h, resolveRecipes as i, getConfig as j, chunkSheetRegistry as k, counterStyle as l, gc as m, createClientState as n, registerSSRCollectorGetter as o, func as p, StyleInjector as q, cacheWrapper as r, registerSSRCollectorGetterGlobal as s, depsEqual as t, createInjector as u, holdKeyframes as v, keyframes as w, injectRawCSS as x, inject as y, getGlobalRecipes as z };
 
-//# sourceMappingURL=runtime-engine-Y00VWjrS.js.map
+//# sourceMappingURL=runtime-engine-BfqCASPn.js.map