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

package/dist/chunks/runtime-engine-Y00VWjrS.js

@@ -1,4719 +0,0 @@
-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
-//#region src/prop-handlers.ts
-/**
-* Props middleware for tasty components.
-*
-* A prop handler receives a component's props and returns them, changed or not.
-* That makes it the extension point for props that are *not* style properties:
-* it can read a custom prop, strip it so it never reaches the DOM, and fold its
-* meaning into `styles`, `mods`, `tokens`, `variant`, or `as`.
-*
-* ```ts
-* configure({
-*   propHandlers: {
-*     glaze: (props) => {
-*       const { glaze, ...rest } = props;
-*       if (!glaze) return rest;
-*       return { ...rest, styles: mergeStyles(glazeStyles(glaze), rest.styles) };
-*     },
-*   },
-* });
-* ```
-*
-* Handlers run on every render of every tasty component, so the registry is a
-* pre-composed chain that is `null` while nothing is registered — the cost when
-* unused is one property load and one branch.
-*/
-const GTKEY = "__tasty_prop_handlers__";
-const globalStore = globalThis;
-const propHandlerRegistry = globalStore[GTKEY] ?? (globalStore[GTKEY] = {
-	apply: null,
-	list: []
-});
-function normalize(key, definition, options) {
-	const source = options?.source ?? "configure()";
-	if (typeof definition === "function") return {
-		key,
-		triggers: [key],
-		fn: definition,
-		source
-	};
-	if (Array.isArray(definition)) {
-		const [first, fn] = definition;
-		if (typeof fn !== "function") throw new Error(`[Tasty] Invalid prop handler definition for "${key}". Tuple must have a function as the second element: [string, function] or [string[], function].`);
-		if (first === "*") return {
-			key,
-			triggers: null,
-			fn,
-			source
-		};
-		if (typeof first === "string") return {
-			key,
-			triggers: [first],
-			fn,
-			source
-		};
-		if (Array.isArray(first)) return {
-			key,
-			triggers: first.includes("*") ? null : first,
-			fn,
-			source
-		};
-		throw new Error(`[Tasty] Invalid prop handler definition for "${key}". First element must be a string or string array.`);
-	}
-	throw new Error(`[Tasty] Invalid prop handler definition for "${key}". Expected function, [string, function], or [string[], function].`);
-}
-/**
-* Run one handler, treating a nothing/non-object return as "unchanged".
-*
-* `isDevEnv()` is called lazily rather than captured at module load so the
-* warnings are assertable in tests; it is only reached on the misuse path.
-*/
-function runOne(handler, props) {
-	const next = handler.fn(props);
-	if (next != null && typeof next === "object" && !Array.isArray(next)) return next;
-	if (isDevEnv()) console.warn(next == null ? `[Tasty] propHandlers["${handler.key}"] (from ${handler.source}) returned ${String(next)}. Props are treated as unchanged — did you forget to \`return props\`?` : `[Tasty] propHandlers["${handler.key}"] (from ${handler.source}) returned ${Array.isArray(next) ? "an array" : typeof next}. A prop handler must return a props object. The result was ignored.`);
-	return props;
-}
-function compose(list) {
-	if (list.length === 0) return null;
-	if (list.length === 1) {
-		const only = list[0];
-		if (only.triggers === null) return (props) => runOne(only, props);
-		if (only.triggers.length === 1) {
-			const trigger = only.triggers[0];
-			return (props) => trigger in props ? runOne(only, props) : props;
-		}
-	}
-	return (props) => {
-		for (const handler of list) {
-			const triggers = handler.triggers;
-			if (triggers !== null) {
-				let triggered = false;
-				for (const trigger of triggers) if (trigger in props) {
-					triggered = true;
-					break;
-				}
-				if (!triggered) continue;
-			}
-			props = runOne(handler, props);
-		}
-		return props;
-	};
-}
-/**
-* Register a props middleware under `key`, replacing any handler already
-* registered under the same key while keeping its position in the chain.
-*/
-function registerPropHandler(key, definition, options) {
-	const normalized = normalize(key, definition, options);
-	const { list } = propHandlerRegistry;
-	const existing = list.findIndex((handler) => handler.key === key);
-	if (existing === -1) list.push(normalized);
-	else list[existing] = normalized;
-	propHandlerRegistry.apply = compose(list);
-}
-/** Drop every registered props middleware. Called by `resetConfig()`. */
-function resetPropHandlers() {
-	if (propHandlerRegistry.list.length === 0) return;
-	propHandlerRegistry.list.length = 0;
-	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").
-*
-* Every `insertRule()` on a live stylesheet invalidates style for the sheet's
-* scope, so Blink recalculates style the next time anything reads layout or
-* computed style. When components inject during React's render phase and other
-* components read layout in the same pass, the two interleave:
-*
-*   inject -> read (forced recalc) -> inject -> read (forced recalc) -> ...
-*
-* Batching moves every sheet write out from between those reads. Writes are
-* queued in FIFO order and drained in one go, so the tree is invalidated once
-* per flush instead of once per component.
-*
-* ## Ordering
-*
-* A single queue holds *all* writes — component rules, global rules, keyframes,
-* `@property`, `@font-face`, `@counter-style`, `@function` and raw CSS. Draining
-* it in insertion order keeps the sheet byte-identical to unbatched output,
-* which matters because equal-specificity rules resolve by document order.
-*
-* ## Batch windows — why queuing is safe
-*
-* Deferring a write past React's layout phase would let a `useLayoutEffect`
-* measure an element whose rules are not in the sheet yet, reading the unstyled
-* box. `<TastyBatchProvider>` closes that hole by opening a *window* during its
-* render and closing it — flushing — in its `useInsertionEffect`, which React
-* runs in the mutation phase, before any layout effect:
-*
-*   provider renders          -> window OPEN
-*     children render         -> injections queued
-*   provider insertionEffect  -> FLUSH, window CLOSED
-*   layout effects run        -> rules are in the sheet
-*
-* So in the default (`batchInjection: true`) mode a write is only ever queued
-* inside a commit whose flush is already guaranteed by that same commit. Every
-* injection outside a window — a deep update the provider did not re-render
-* for, a `useLayoutEffect` that injects, an event handler, an async callback —
-* is written straight through, exactly as with batching off.
-*
-* `batchInjection: 'always'` opts out of the gate and queues unconditionally.
-* That wins on more commits, at the cost of the measurement hazard above.
-*
-* ## Flush points (earliest wins)
-*
-* 1. `<TastyBatchProvider>`'s `useInsertionEffect` — closes the window.
-* 2. A microtask — a backstop for a render that was aborted or suspended and
-*    therefore never reached its insertion effect. An aborted render mounts
-*    nothing, so nothing can measure what it queued. Microtasks also always
-*    drain before paint, so styles are never visually missing.
-* 3. `flushStyles()` — explicit, and called internally by every injector read
-*    API (`getCSSText`, `cleanup`, `gc`, `destroy`, ...).
-*/
-/**
-* FIFO of pending writes. Drained with a moving `head` index rather than
-* `shift()` so a large batch stays O(n) instead of O(n²).
-*/
-let queue = [];
-let head = 0;
-let microtaskScheduled = false;
-let flushing = false;
-/**
-* Whether a `<TastyBatchProvider>` has rendered in the current commit and will
-* therefore flush in its insertion effect, making it safe to queue a write.
-*
-* A flag rather than a depth count, because renders and insertion effects do
-* not pair up one-to-one. StrictMode double-invokes render but runs the
-* insertion effect once, so a counter ends the commit stuck above zero — and a
-* window that stays open past its commit turns the next provider-less commit
-* into `'always'` mode behind the user's back, which is exactly the measurement
-* hazard `true` exists to avoid.
-*
-* Clearing on the first close is safe with nested or sibling providers: React
-* finishes every render in a commit before running any insertion effect, so once
-* one closes, no further render-phase injection can arrive in that commit.
-*/
-let windowOpen = false;
-/** Whether any window has ever been opened, i.e. a provider is in the tree. */
-let everOpened = false;
-/** Dev-only: warn at most once that batching is on with no provider mounted. */
-let warnedNoProvider = false;
-/**
-* Queue a sheet write.
-*
-* Returns a handle whose `cancel()` drops the write if the caller disposes
-* before the flush. The handle is intentionally tiny — one is allocated per
-* injected class, on the cache-miss path only.
-*/
-function enqueueStyleWrite(run) {
-	if (flushing) {
-		run();
-		return {
-			run,
-			cancelled: false,
-			done: true
-		};
-	}
-	const entry = {
-		run,
-		cancelled: false,
-		done: false
-	};
-	queue.push(entry);
-	scheduleMicrotaskFlush();
-	return entry;
-}
-/** Whether any write is still waiting to hit a stylesheet. */
-function hasPendingStyleWrites() {
-	return head < queue.length;
-}
-/**
-* Open a batch window. Called from `<TastyBatchProvider>`'s render, so every
-* descendant injection in this commit is covered by the provider's insertion
-* effect.
-*
-* Called during render on purpose: the window must be open before children
-* render. It is idempotent — so StrictMode's double render costs nothing — and
-* carries no other side effect. A render that is thrown away is recovered by the
-* microtask backstop.
-*
-* A no-op without a `document`. On the server there is no sheet to batch
-* against, and `useInsertionEffect` never runs, so nothing would ever close a
-* window this opened. Skipping it keeps the provider inert during SSR and RSC
-* instead of merely harmless.
-*/
-function openBatchWindow() {
-	if (typeof document === "undefined") return;
-	windowOpen = true;
-	everOpened = true;
-}
-/**
-* Close a batch window and flush. Called from the provider's
-* `useInsertionEffect`, i.e. after every render in the commit and before any
-* layout effect.
-*/
-function closeBatchWindow() {
-	windowOpen = false;
-	flushStyles();
-}
-/** Whether a batch window is currently open. */
-function isBatchWindowOpen() {
-	return windowOpen;
-}
-function scheduleMicrotaskFlush() {
-	if (microtaskScheduled || flushing) return;
-	microtaskScheduled = true;
-	queueMicrotask(() => {
-		microtaskScheduled = false;
-		windowOpen = false;
-		flushStyles();
-	});
-}
-/**
-* Drain every pending sheet write, in insertion order.
-*
-* Safe to call when the queue is empty (the common case, so the guard comes
-* first) and safe to call re-entrantly: a nested `flushStyles()` is a no-op,
-* and work a draining write triggers is written in place by
-* `enqueueStyleWrite` rather than queued behind the rest of the batch.
-*/
-function flushStyles() {
-	if (head >= queue.length) return;
-	if (flushing) return;
-	flushing = true;
-	try {
-		while (head < queue.length) {
-			const entry = queue[head++];
-			if (entry.cancelled) {
-				entry.done = true;
-				continue;
-			}
-			entry.run();
-			entry.done = true;
-		}
-	} finally {
-		queue = [];
-		head = 0;
-		flushing = false;
-	}
-}
-/**
-* Dev-only: `batchInjection: true` batches nothing unless a window opens, and no
-* window has ever opened, so no provider is in the tree. Called by the injector
-* the first time it declines to batch.
-*/
-function warnBatchProviderMissing() {
-	if (everOpened || warnedNoProvider || !isDevEnv()) return;
-	warnedNoProvider = true;
-	warn("[Tasty] batchInjection needs <TastyBatchProvider> mounted to batch.");
-}
-/**
-* Drop every pending write without applying it. Test helper — production code
-* should call `flushStyles()` instead.
-*/
-function resetStyleBatch() {
-	queue = [];
-	head = 0;
-	microtaskScheduled = false;
-	flushing = false;
-	windowOpen = false;
-	everOpened = false;
-	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 {
-		new CSSStyleSheet();
-		return true;
-	} catch {
-		return false;
-	}
-})();
-var SheetManager = class {
-	rootRegistries = /* @__PURE__ */ new WeakMap();
-	/** Strong set of active roots so background GC can iterate them all */
-	activeRoots = /* @__PURE__ */ new Set();
-	config;
-	/** Dedicated style elements for raw CSS per root */
-	rawStyleElements = /* @__PURE__ */ new WeakMap();
-	/** Constructable sheets for raw CSS in adopted mode */
-	rawConstructableSheets = /* @__PURE__ */ new WeakMap();
-	/** Tracking for raw CSS blocks per root */
-	rawCSSBlocks = /* @__PURE__ */ new WeakMap();
-	/** Counter for generating unique raw CSS IDs */
-	rawCSSCounter = 0;
-	constructor(config) {
-		this.config = config;
-	}
-	/**
-	* Resolve the underlying CSSStyleSheet from a SheetInfo,
-	* abstracting away adopted vs style-element modes.
-	*/
-	getCSSSheet(sheetInfo) {
-		if (sheetInfo.constructableSheet) return sheetInfo.constructableSheet;
-		return sheetInfo.sheet?.sheet ?? null;
-	}
-	/**
-	* Record an inserted rule text at its rule index (text mode only).
-	*
-	* `textRules` mirrors the sheet's rule order. `textContent` cannot be edited
-	* rule-by-rule the way CSSOM can, so keeping the texts is what makes
-	* deletion possible at all in this mode.
-	*/
-	trackTextRule(sheet, ruleIndex, ruleText) {
-		if (!sheet.textMode) return;
-		const rules = sheet.textRules ??= [];
-		while (rules.length < ruleIndex) rules.push("");
-		rules[ruleIndex] = ruleText;
-	}
-	/**
-	* Remove rule indices from a text-mode sheet and rewrite the element's text.
-	* Returns the indices that were actually removed.
-	*/
-	deleteTextRules(sheet, indices) {
-		const rules = sheet.textRules;
-		if (!rules) return [];
-		const removed = [...new Set(indices)].filter((idx) => idx >= 0 && idx < rules.length).sort((a, b) => b - a);
-		for (const idx of removed) rules.splice(idx, 1);
-		if (removed.length > 0 && sheet.sheet) sheet.sheet.textContent = rules.length ? "\n" + rules.join("\n") : "";
-		return removed;
-	}
-	/**
-	* Determine the injection mode for a root.
-	* ShadowRoot uses adopted stylesheets when supported; Document uses <style> elements.
-	*/
-	detectInjectionMode(root) {
-		if (root instanceof ShadowRoot && supportsConstructableSheets && !this.config.forceTextInjection) return "adopted";
-		return "style-element";
-	}
-	/**
-	* Get or create registry for a root (Document or ShadowRoot)
-	*/
-	getRegistry(root) {
-		let registry = this.rootRegistries.get(root);
-		if (!registry) {
-			const metrics = this.config.devMode ? {
-				hits: 0,
-				misses: 0,
-				bulkCleanups: 0,
-				totalInsertions: 0,
-				totalUnused: 0,
-				stylesCleanedUp: 0,
-				cleanupHistory: [],
-				startTime: Date.now()
-			} : void 0;
-			registry = {
-				sheets: [],
-				pinCounts: /* @__PURE__ */ new Map(),
-				rules: /* @__PURE__ */ new Map(),
-				cacheKeyToClassName: /* @__PURE__ */ new Map(),
-				ruleTextSet: /* @__PURE__ */ new Set(),
-				metrics,
-				keyframesCache: /* @__PURE__ */ new Map(),
-				keyframesNameToContent: /* @__PURE__ */ new Map(),
-				keyframesCounter: 0,
-				injectedProperties: /* @__PURE__ */ new Map(),
-				injectedFontFaces: /* @__PURE__ */ new Set(),
-				injectedCounterStyles: /* @__PURE__ */ new Map(),
-				injectedFunctions: /* @__PURE__ */ new Map(),
-				globalRules: /* @__PURE__ */ new Map(),
-				propertyTypeResolver: new PropertyTypeResolver(),
-				unusedSince: /* @__PURE__ */ new Map(),
-				localKeyframes: /* @__PURE__ */ new Map(),
-				touchCount: 0,
-				serverClassSyncIndex: 0,
-				rscStylesScanned: false,
-				injectionMode: this.detectInjectionMode(root)
-			};
-			this.rootRegistries.set(root, registry);
-			this.activeRoots.add(root);
-		}
-		return registry;
-	}
-	/** Return all roots with active registries (for background GC sweep). */
-	getActiveRoots() {
-		return this.activeRoots;
-	}
-	/** Check whether any roots have active registries. */
-	hasActiveRoots() {
-		return this.activeRoots.size > 0;
-	}
-	/** Remove registries for ShadowRoots whose host has been detached from the DOM. */
-	pruneDisconnectedRoots() {
-		const toPrune = [];
-		for (const root of this.activeRoots) if (root !== document && !root.host?.isConnected) toPrune.push(root);
-		for (const root of toPrune) this.cleanup(root);
-	}
-	/**
-	* Create a new stylesheet for the registry.
-	* In adopted mode (ShadowRoot), creates a constructable CSSStyleSheet and
-	* pushes it to adoptedStyleSheets. Otherwise creates a <style> element.
-	*/
-	createSheet(registry, root) {
-		if (registry.injectionMode === "adopted") {
-			const constructableSheet = new CSSStyleSheet();
-			root.adoptedStyleSheets = [...root.adoptedStyleSheets, constructableSheet];
-			const sheetInfo = {
-				sheet: null,
-				constructableSheet,
-				ruleCount: 0,
-				holes: []
-			};
-			registry.sheets.push(sheetInfo);
-			return sheetInfo;
-		}
-		const sheet = this.createStyleElement(root);
-		const textMode = this.config.forceTextInjection === true || sheet.sheet == null;
-		const sheetInfo = {
-			sheet,
-			ruleCount: 0,
-			holes: [],
-			textMode,
-			...textMode ? { textRules: [] } : {}
-		};
-		registry.sheets.push(sheetInfo);
-		return sheetInfo;
-	}
-	/**
-	* Create a style element and append to document
-	*/
-	createStyleElement(root) {
-		const style = root.createElement?.("style") || document.createElement("style");
-		if (this.config.nonce) style.nonce = this.config.nonce;
-		style.setAttribute("data-tasty", "");
-		if ("head" in root && root.head) root.head.appendChild(style);
-		else if ("appendChild" in root) root.appendChild(style);
-		else document.head.appendChild(style);
-		if (!style.isConnected && !this.config.forceTextInjection) console.error("[Tasty] SheetManager: style element failed to connect to the DOM.", {
-			parentNode: style.parentNode?.nodeName,
-			isConnected: style.isConnected
-		});
-		return style;
-	}
-	/**
-	* Insert CSS rules as a single block
-	*/
-	insertRule(registry, flattenedRules, className, root) {
-		let targetSheet = this.findAvailableSheet(registry, root);
-		if (!targetSheet) targetSheet = this.createSheet(registry, root);
-		const sheetIndex = registry.sheets.indexOf(targetSheet);
-		try {
-			const groupedRules = [];
-			const groupMap = /* @__PURE__ */ new Map();
-			const atKey = (at) => at && at.length ? at.join("|") : "";
-			flattenedRules.forEach((r) => {
-				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, {
-						idx: groupedRules.length,
-						selector: r.selector,
-						atRules: r.atRules,
-						startingStyle: r.startingStyle,
-						declarations: r.declarations
-					});
-					groupedRules.push({ ...r });
-				}
-			});
-			groupMap.forEach((val) => {
-				groupedRules[val.idx] = {
-					selector: val.selector,
-					atRules: val.atRules,
-					startingStyle: val.startingStyle,
-					declarations: val.declarations
-				};
-			});
-			const insertedRuleTexts = [];
-			const insertedIndices = [];
-			let currentRuleIndex = this.findAvailableRuleIndex(targetSheet);
-			let firstInsertedIndex = null;
-			let lastInsertedIndex = null;
-			for (const rule of groupedRules) {
-				const declarations = rule.declarations;
-				const innerContent = rule.startingStyle ? `@starting-style { ${declarations} }` : 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);
-				const styleElement = targetSheet.sheet;
-				const styleSheet = this.getCSSSheet(targetSheet);
-				if (!targetSheet.textMode && styleSheet) {
-					const maxIndex = styleSheet.cssRules.length;
-					const atomicRuleIndex = this.findAvailableRuleIndex(targetSheet);
-					const safeIndex = Math.min(Math.max(0, atomicRuleIndex), maxIndex);
-					const splitSelectorsSafely = (selectorList) => {
-						const parts = [];
-						let buf = "";
-						let depthSq = 0;
-						let depthPar = 0;
-						let inStr = "";
-						for (let i = 0; i < selectorList.length; i++) {
-							const ch = selectorList[i];
-							if (inStr) {
-								if (ch === inStr && selectorList[i - 1] !== "\\") inStr = "";
-								buf += ch;
-								continue;
-							}
-							if (ch === "\"" || ch === "'") {
-								inStr = ch;
-								buf += ch;
-								continue;
-							}
-							if (ch === "[") depthSq++;
-							else if (ch === "]") depthSq = Math.max(0, depthSq - 1);
-							else if (ch === "(") depthPar++;
-							else if (ch === ")") depthPar = Math.max(0, depthPar - 1);
-							if (ch === "," && depthSq === 0 && depthPar === 0) {
-								const part = buf.trim();
-								if (part) parts.push(part);
-								buf = "";
-							} else buf += ch;
-						}
-						const tail = buf.trim();
-						if (tail) parts.push(tail);
-						return parts;
-					};
-					try {
-						styleSheet.insertRule(fullRule, safeIndex);
-						targetSheet.ruleCount++;
-						insertedIndices.push(safeIndex);
-						if (firstInsertedIndex == null) firstInsertedIndex = safeIndex;
-						lastInsertedIndex = safeIndex;
-						currentRuleIndex = safeIndex + 1;
-					} catch (e) {
-						const selectors = splitSelectorsSafely(rule.selector);
-						if (selectors.length > 1) {
-							let anyInserted = false;
-							for (const sel of selectors) {
-								const singleBase = `${sel} { ${declarations} }`;
-								let singleRule = singleBase;
-								if (rule.atRules && rule.atRules.length > 0) singleRule = rule.atRules.reduce((css, atRule) => `${atRule} { ${css} }`, singleBase);
-								try {
-									const maxIdx = styleSheet.cssRules.length;
-									const atomicIdx = this.findAvailableRuleIndex(targetSheet);
-									const idx = Math.min(Math.max(0, atomicIdx), maxIdx);
-									styleSheet.insertRule(singleRule, idx);
-									targetSheet.ruleCount++;
-									insertedIndices.push(idx);
-									if (firstInsertedIndex == null) firstInsertedIndex = idx;
-									lastInsertedIndex = idx;
-									currentRuleIndex = idx + 1;
-									anyInserted = true;
-								} catch (singleErr) {
-									console.warn("[Tasty] Browser rejected CSS rule:", singleRule, singleErr);
-								}
-							}
-							if (!anyInserted) {}
-						} else if (!(fullRule.startsWith("@property ") && !this.engineSupportsAtProperty(registry, styleSheet))) console.warn("[Tasty] Browser rejected CSS rule:", fullRule, e);
-					}
-				} else if (styleElement) {
-					const atomicRuleIndex = this.findAvailableRuleIndex(targetSheet);
-					this.trackTextRule(targetSheet, atomicRuleIndex, fullRule);
-					styleElement.textContent = (styleElement.textContent || "") + "\n" + fullRule;
-					targetSheet.ruleCount++;
-					insertedIndices.push(atomicRuleIndex);
-					if (firstInsertedIndex == null) firstInsertedIndex = atomicRuleIndex;
-					lastInsertedIndex = atomicRuleIndex;
-					currentRuleIndex = atomicRuleIndex + 1;
-				}
-				if (styleElement && !styleElement.parentNode && !this.config.forceTextInjection) console.error("[Tasty] SheetManager: style element is not attached to the DOM; rules will not apply.", {
-					className,
-					ruleIndex: currentRuleIndex
-				});
-				if (this.config.devMode) {
-					insertedRuleTexts.push(fullRule);
-					try {
-						registry.ruleTextSet.add(fullRule);
-					} catch {}
-				}
-			}
-			if (insertedIndices.length === 0) return null;
-			return {
-				className,
-				ruleIndex: firstInsertedIndex ?? 0,
-				sheetIndex,
-				cssText: this.config.devMode ? insertedRuleTexts : void 0,
-				endRuleIndex: lastInsertedIndex ?? firstInsertedIndex ?? 0,
-				indices: insertedIndices
-			};
-		} catch (error) {
-			console.warn("[Tasty] Failed to insert CSS rules:", error, {
-				flattenedRules,
-				className
-			});
-			return null;
-		}
-	}
-	/**
-	* Insert global CSS rules
-	*/
-	insertGlobalRule(registry, flattenedRules, globalKey, root) {
-		const ruleInfo = this.insertRule(registry, flattenedRules, globalKey, root);
-		if (ruleInfo) registry.globalRules.set(globalKey, ruleInfo);
-		return ruleInfo;
-	}
-	/**
-	* Delete a global CSS rule by key
-	*/
-	deleteGlobalRule(registry, globalKey) {
-		const ruleInfo = registry.globalRules.get(globalKey);
-		if (!ruleInfo) return;
-		this.deleteRule(registry, ruleInfo);
-		registry.globalRules.delete(globalKey);
-	}
-	/**
-	* Adjust rule indices after deletion to account for shifting
-	*/
-	adjustIndicesAfterDeletion(registry, sheetIndex, startIdx, endIdx, deleteCount, deletedRuleInfo, deletedIndices) {
-		try {
-			const sortedDeleted = deletedIndices && deletedIndices.length > 0 ? [...deletedIndices].sort((a, b) => a - b) : null;
-			const countDeletedBefore = (sorted, idx) => {
-				let shift = 0;
-				for (const delIdx of sorted) if (delIdx < idx) shift++;
-				else break;
-				return shift;
-			};
-			const adjustRuleInfo = (info) => {
-				if (info === deletedRuleInfo) return;
-				if (info.sheetIndex !== sheetIndex) return;
-				if (!info.indices || info.indices.length === 0) return;
-				if (sortedDeleted) info.indices = info.indices.map((idx) => {
-					return idx - countDeletedBefore(sortedDeleted, idx);
-				});
-				else info.indices = info.indices.map((idx) => idx > endIdx ? Math.max(0, idx - deleteCount) : idx);
-				if (info.indices.length > 0) {
-					info.ruleIndex = Math.min(...info.indices);
-					info.endRuleIndex = Math.max(...info.indices);
-				}
-			};
-			for (const info of registry.rules.values()) adjustRuleInfo(info);
-			for (const info of registry.globalRules.values()) adjustRuleInfo(info);
-			for (const entry of registry.keyframesCache.values()) {
-				const ki = entry.info;
-				if (ki.sheetIndex !== sheetIndex) continue;
-				if (sortedDeleted) {
-					const shift = countDeletedBefore(sortedDeleted, ki.ruleIndex);
-					if (shift > 0) ki.ruleIndex = Math.max(0, ki.ruleIndex - shift);
-				} else if (ki.ruleIndex > endIdx) ki.ruleIndex = Math.max(0, ki.ruleIndex - deleteCount);
-			}
-		} catch {}
-	}
-	/**
-	* Delete a CSS rule from the sheet
-	*/
-	deleteRule(registry, ruleInfo) {
-		const sheet = registry.sheets[ruleInfo.sheetIndex];
-		if (!sheet) return;
-		try {
-			const texts = this.config.devMode && Array.isArray(ruleInfo.cssText) ? ruleInfo.cssText.slice() : [];
-			const styleSheet = this.getCSSSheet(sheet);
-			if (sheet.textMode) {
-				let targetIndices;
-				if (ruleInfo.indices && ruleInfo.indices.length > 0) targetIndices = ruleInfo.indices;
-				else {
-					const startIdx = Math.max(0, ruleInfo.ruleIndex);
-					const endIdx = Math.min((sheet.textRules?.length ?? 0) - 1, Number.isFinite(ruleInfo.endRuleIndex) ? ruleInfo.endRuleIndex : startIdx);
-					targetIndices = [];
-					for (let idx = startIdx; idx <= endIdx; idx++) targetIndices.push(idx);
-				}
-				const deletedIndices = this.deleteTextRules(sheet, targetIndices);
-				if (deletedIndices.length > 0) {
-					sheet.ruleCount = Math.max(0, sheet.ruleCount - deletedIndices.length);
-					this.adjustIndicesAfterDeletion(registry, ruleInfo.sheetIndex, Math.min(...deletedIndices), Math.max(...deletedIndices), deletedIndices.length, ruleInfo, deletedIndices);
-				}
-			} else if (styleSheet) {
-				const rules = styleSheet.cssRules;
-				if (ruleInfo.indices && ruleInfo.indices.length > 0) {
-					const sortedIndices = [...ruleInfo.indices].sort((a, b) => b - a);
-					const deletedIndices = [];
-					for (const idx of sortedIndices) if (idx >= 0 && idx < styleSheet.cssRules.length) try {
-						styleSheet.deleteRule(idx);
-						deletedIndices.push(idx);
-					} catch (e) {
-						console.warn(`[Tasty] Failed to delete rule at index ${idx}:`, e);
-					}
-					sheet.ruleCount = Math.max(0, sheet.ruleCount - deletedIndices.length);
-					if (deletedIndices.length > 0) this.adjustIndicesAfterDeletion(registry, ruleInfo.sheetIndex, Math.min(...deletedIndices), Math.max(...deletedIndices), deletedIndices.length, ruleInfo, deletedIndices);
-				} else {
-					const startIdx = Math.max(0, ruleInfo.ruleIndex);
-					const endIdx = Math.min(rules.length - 1, Number.isFinite(ruleInfo.endRuleIndex) ? ruleInfo.endRuleIndex : startIdx);
-					if (Number.isFinite(startIdx) && endIdx >= startIdx) {
-						const deleteCount = endIdx - startIdx + 1;
-						for (let idx = endIdx; idx >= startIdx; idx--) {
-							if (idx < 0 || idx >= styleSheet.cssRules.length) continue;
-							styleSheet.deleteRule(idx);
-						}
-						sheet.ruleCount = Math.max(0, sheet.ruleCount - deleteCount);
-						this.adjustIndicesAfterDeletion(registry, ruleInfo.sheetIndex, startIdx, endIdx, deleteCount, ruleInfo);
-					}
-				}
-			}
-			if (this.config.devMode && texts.length) try {
-				for (const text of texts) registry.ruleTextSet.delete(text);
-			} catch {}
-		} catch (error) {
-			console.warn("[Tasty] Failed to delete CSS rule:", error);
-		}
-	}
-	/**
-	* Find a sheet with available space or return null
-	*/
-	findAvailableSheet(registry, _root) {
-		const maxRules = this.config.maxRulesPerSheet;
-		if (!maxRules) return registry.sheets[registry.sheets.length - 1] || null;
-		for (const sheet of registry.sheets) if (sheet.ruleCount < maxRules) return sheet;
-		return null;
-	}
-	/**
-	* Find an available rule index in the sheet
-	*/
-	findAvailableRuleIndex(sheet) {
-		return sheet.ruleCount;
-	}
-	/**
-	* Probe whether the underlying CSS engine supports `@property` at-rules.
-	* Result is cached per registry on `registry.atPropertySupported`.
-	*
-	* The probe inserts and immediately deletes a minimal known-valid rule
-	* (`@property --__tasty_probe__ { syntax: "*"; inherits: true; }`).
-	* Engines that lack `@property` support (jsdom, happy-dom) reject any
-	* `@property` rule including this one, so a probe failure is a reliable
-	* signal that further `@property` rejections are environmental noise and
-	* not user-authored bugs.
-	*
-	* The probe is intentionally a separate operation from the user's failing
-	* insertion: we don't want to leak `--__tasty_probe__` into the sheet, so
-	* on success we delete the probe rule immediately, leaving `ruleCount`
-	* and `cssRules.length` unchanged.
-	*/
-	engineSupportsAtProperty(registry, styleSheet) {
-		if (registry.atPropertySupported !== void 0) return registry.atPropertySupported;
-		const probeRule = "@property --__tasty_probe__ { syntax: \"*\"; inherits: true; }";
-		try {
-			const probeIdx = styleSheet.cssRules.length;
-			styleSheet.insertRule(probeRule, probeIdx);
-			try {
-				styleSheet.deleteRule(probeIdx);
-			} catch {}
-			registry.atPropertySupported = true;
-		} catch {
-			registry.atPropertySupported = false;
-		}
-		return registry.atPropertySupported;
-	}
-	/**
-	* Delete the given classes: their rules leave the sheets and every registry
-	* entry pointing at them is dropped.
-	*
-	* Deciding *what* is unused belongs to `StyleInjector.gc()`, which owns the
-	* DOM scan and the capacity policy. This only re-checks that each class is
-	* still safe to delete, and reports how many were.
-	*
-	* @returns Number of classes actually deleted.
-	*/
-	deleteClasses(registry, classNames) {
-		const cleanupStartTime = Date.now();
-		const selected = Array.from(classNames).map((className) => {
-			const ruleInfo = registry.rules.get(className);
-			return ruleInfo ? {
-				className,
-				ruleInfo
-			} : null;
-		}).filter((entry) => entry != null);
-		if (selected.length === 0) return 0;
-		const deleted = /* @__PURE__ */ new Set();
-		let cleanedUpCount = 0;
-		let totalCssSize = 0;
-		let totalRulesDeleted = 0;
-		const rulesBySheet = /* @__PURE__ */ new Map();
-		for (const { className, ruleInfo } of selected) {
-			const sheetIndex = ruleInfo.sheetIndex;
-			if (this.config.devMode && Array.isArray(ruleInfo.cssText)) {
-				const cssSize = ruleInfo.cssText.reduce((total, css) => total + css.length, 0);
-				totalCssSize += cssSize;
-				totalRulesDeleted += ruleInfo.cssText.length;
-			}
-			if (!rulesBySheet.has(sheetIndex)) rulesBySheet.set(sheetIndex, []);
-			rulesBySheet.get(sheetIndex).push({
-				className,
-				ruleInfo
-			});
-		}
-		for (const [_sheetIndex, rulesInSheet] of rulesBySheet) {
-			rulesInSheet.sort((a, b) => b.ruleInfo.ruleIndex - a.ruleInfo.ruleIndex);
-			for (const { className, ruleInfo } of rulesInSheet) {
-				if ((registry.pinCounts.get(className) ?? 0) > 0) continue;
-				if (registry.rules.get(className) !== ruleInfo) continue;
-				const sheetInfo = registry.sheets[ruleInfo.sheetIndex];
-				if (!sheetInfo || !sheetInfo.sheet && !sheetInfo.constructableSheet) continue;
-				const styleSheet = this.getCSSSheet(sheetInfo);
-				if (!sheetInfo.textMode && !styleSheet) continue;
-				const maxRuleIndex = (sheetInfo.textMode ? sheetInfo.textRules?.length ?? 0 : styleSheet?.cssRules.length ?? 0) - 1;
-				const startIdx = ruleInfo.ruleIndex;
-				const endIdx = ruleInfo.endRuleIndex ?? ruleInfo.ruleIndex;
-				if (startIdx < 0 || endIdx > maxRuleIndex || startIdx > endIdx) continue;
-				this.deleteRule(registry, ruleInfo);
-				registry.rules.delete(className);
-				registry.pinCounts.delete(className);
-				registry.unusedSince.delete(className);
-				for (const [key, entry] of registry.localKeyframes) {
-					if (!entry.owners.delete(className)) continue;
-					if (entry.owners.size === 0) {
-						entry.dispose();
-						registry.localKeyframes.delete(key);
-					}
-				}
-				deleted.add(className);
-				cleanedUpCount++;
-			}
-		}
-		if (deleted.size > 0) {
-			for (const [key, mappedClassName] of registry.cacheKeyToClassName) if (deleted.has(mappedClassName)) registry.cacheKeyToClassName.delete(key);
-		}
-		if (registry.metrics) {
-			registry.metrics.bulkCleanups++;
-			registry.metrics.stylesCleanedUp += cleanedUpCount;
-			registry.metrics.cleanupHistory.push({
-				timestamp: cleanupStartTime,
-				classesDeleted: cleanedUpCount,
-				cssSize: totalCssSize,
-				rulesDeleted: totalRulesDeleted
-			});
-		}
-		return cleanedUpCount;
-	}
-	/**
-	* Get total number of rules across all sheets
-	*/
-	getTotalRuleCount(registry) {
-		return registry.sheets.reduce((total, sheet) => total + sheet.ruleCount - sheet.holes.length, 0);
-	}
-	/**
-	* The CSS of one managed sheet, or `null` when it holds none this can read —
-	* an empty style element, or a sheet the engine refuses to hand over.
-	*/
-	readSheetCSS(sheetInfo) {
-		try {
-			if (sheetInfo.constructableSheet) return Array.from(sheetInfo.constructableSheet.cssRules).map((rule) => rule.cssText).join("\n");
-			if (sheetInfo.sheet) {
-				const styleElement = sheetInfo.sheet;
-				if (styleElement.textContent) return styleElement.textContent;
-				if (styleElement.sheet) return Array.from(styleElement.sheet.cssRules).map((rule) => rule.cssText).join("\n");
-			}
-		} catch (error) {
-			console.warn("[Tasty] Failed to read CSS from sheet:", error);
-		}
-		return null;
-	}
-	/**
-	* Get CSS text from all sheets (for SSR)
-	*/
-	getCSSText(registry) {
-		const cssChunks = [];
-		for (const sheetInfo of registry.sheets) {
-			const css = this.readSheetCSS(sheetInfo);
-			if (css !== null) cssChunks.push(css);
-		}
-		return cssChunks.join("\n");
-	}
-	/**
-	* Get cache performance metrics
-	*/
-	getMetrics(registry) {
-		if (!registry.metrics) return null;
-		return {
-			...registry.metrics,
-			unusedHits: 0
-		};
-	}
-	/**
-	* Reset cache performance metrics
-	*/
-	resetMetrics(registry) {
-		if (registry.metrics) registry.metrics = {
-			hits: 0,
-			misses: 0,
-			bulkCleanups: 0,
-			totalInsertions: 0,
-			totalUnused: 0,
-			stylesCleanedUp: 0,
-			cleanupHistory: [],
-			startTime: Date.now()
-		};
-	}
-	/**
-	* Convert keyframes steps to CSS string.
-	* Public so the SSR collector can format keyframes without DOM access.
-	* Returns both the CSS text and a combined declarations string for property type scanning.
-	*/
-	stepsToCSS(steps) {
-		const rules = [];
-		const allDeclarations = [];
-		for (const [key, value] of Object.entries(steps)) {
-			if (typeof value === "string") {
-				rules.push(`${key} { ${value.trim()} }`);
-				allDeclarations.push(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()} }`);
-			allDeclarations.push(declarations);
-		}
-		return {
-			css: rules.join(" "),
-			declarations: allDeclarations.join("; ")
-		};
-	}
-	/**
-	* Insert keyframes rule.
-	* Returns the KeyframesInfo and the raw declarations string for property type scanning.
-	*/
-	insertKeyframes(registry, steps, name, root) {
-		let targetSheet = this.findAvailableSheet(registry, root);
-		if (!targetSheet) targetSheet = this.createSheet(registry, root);
-		const ruleIndex = this.findAvailableRuleIndex(targetSheet);
-		const sheetIndex = registry.sheets.indexOf(targetSheet);
-		try {
-			const { css: cssSteps, declarations } = this.stepsToCSS(steps);
-			const fullRule = `@keyframes ${name} { ${cssSteps} }`;
-			const styleSheet = this.getCSSSheet(targetSheet);
-			if (!targetSheet.textMode && styleSheet) {
-				const safeIndex = Math.min(Math.max(0, ruleIndex), styleSheet.cssRules.length);
-				styleSheet.insertRule(fullRule, safeIndex);
-			} else if (targetSheet.sheet) {
-				this.trackTextRule(targetSheet, ruleIndex, fullRule);
-				targetSheet.sheet.textContent = (targetSheet.sheet.textContent || "") + "\n" + fullRule;
-			}
-			targetSheet.ruleCount++;
-			return {
-				info: {
-					name,
-					ruleIndex,
-					sheetIndex,
-					cssText: this.config.devMode ? fullRule : void 0
-				},
-				declarations
-			};
-		} catch (error) {
-			console.warn("[Tasty] Failed to insert keyframes:", error);
-			return null;
-		}
-	}
-	/**
-	* Delete keyframes rule
-	*/
-	deleteKeyframes(registry, info) {
-		const sheet = registry.sheets[info.sheetIndex];
-		if (!sheet) return;
-		try {
-			const styleSheet = this.getCSSSheet(sheet);
-			const adjustIndices = () => this.adjustIndicesAfterDeletion(registry, info.sheetIndex, info.ruleIndex, info.ruleIndex, 1, {
-				className: "",
-				ruleIndex: info.ruleIndex,
-				sheetIndex: info.sheetIndex
-			}, [info.ruleIndex]);
-			if (sheet.textMode) {
-				if (this.deleteTextRules(sheet, [info.ruleIndex]).length > 0) {
-					sheet.ruleCount = Math.max(0, sheet.ruleCount - 1);
-					adjustIndices();
-				}
-			} else if (styleSheet) {
-				if (info.ruleIndex >= 0 && info.ruleIndex < styleSheet.cssRules.length) {
-					styleSheet.deleteRule(info.ruleIndex);
-					sheet.ruleCount = Math.max(0, sheet.ruleCount - 1);
-					adjustIndices();
-				}
-			}
-		} catch (error) {
-			console.warn("[Tasty] Failed to delete keyframes:", error);
-		}
-	}
-	/**
-	* Clean up resources for a root
-	*/
-	cleanup(root) {
-		const registry = this.rootRegistries.get(root);
-		if (!registry) return;
-		if (registry.injectionMode === "adopted") {
-			const shadowRoot = root;
-			const ownedSheets = /* @__PURE__ */ new Set();
-			for (const sheetInfo of registry.sheets) if (sheetInfo.constructableSheet) ownedSheets.add(sheetInfo.constructableSheet);
-			const rawSheet = this.rawConstructableSheets.get(shadowRoot);
-			if (rawSheet) {
-				ownedSheets.add(rawSheet);
-				this.rawConstructableSheets.delete(shadowRoot);
-			}
-			if (ownedSheets.size > 0) shadowRoot.adoptedStyleSheets = shadowRoot.adoptedStyleSheets.filter((s) => !ownedSheets.has(s));
-		} else {
-			for (const sheet of registry.sheets) try {
-				const styleElement = sheet.sheet;
-				if (styleElement?.parentNode) styleElement.parentNode.removeChild(styleElement);
-			} catch (error) {
-				console.warn("[Tasty] Failed to cleanup sheet:", error);
-			}
-			const rawStyleElement = this.rawStyleElements.get(root);
-			if (rawStyleElement?.parentNode) rawStyleElement.parentNode.removeChild(rawStyleElement);
-			this.rawStyleElements.delete(root);
-		}
-		this.rootRegistries.delete(root);
-		this.activeRoots.delete(root);
-		this.rawCSSBlocks.delete(root);
-	}
-	/**
-	* Check if a root uses adopted injection mode.
-	*/
-	isAdoptedMode(root) {
-		const registry = this.rootRegistries.get(root);
-		if (registry) return registry.injectionMode === "adopted";
-		return this.detectInjectionMode(root) === "adopted";
-	}
-	/**
-	* Get or create a constructable CSSStyleSheet for raw CSS in adopted mode.
-	* The raw sheet is prepended to adoptedStyleSheets so it precedes tasty rules.
-	*/
-	getOrCreateRawAdoptedSheet(root) {
-		let sheet = this.rawConstructableSheets.get(root);
-		if (!sheet) {
-			sheet = new CSSStyleSheet();
-			root.adoptedStyleSheets = [sheet, ...root.adoptedStyleSheets];
-			this.rawConstructableSheets.set(root, sheet);
-			if (!this.rawCSSBlocks.has(root)) this.rawCSSBlocks.set(root, /* @__PURE__ */ new Map());
-		}
-		return sheet;
-	}
-	/**
-	* Get or create a dedicated style element for raw CSS
-	* Raw CSS is kept separate from tasty-managed sheets to avoid index conflicts
-	*/
-	getOrCreateRawStyleElement(root) {
-		let styleElement = this.rawStyleElements.get(root);
-		if (!styleElement) {
-			styleElement = root.createElement?.("style") || document.createElement("style");
-			if (this.config.nonce) styleElement.nonce = this.config.nonce;
-			styleElement.setAttribute("data-tasty-raw", "");
-			if ("head" in root && root.head) root.head.appendChild(styleElement);
-			else if ("appendChild" in root) root.appendChild(styleElement);
-			else document.head.appendChild(styleElement);
-			this.rawStyleElements.set(root, styleElement);
-			this.rawCSSBlocks.set(root, /* @__PURE__ */ new Map());
-		}
-		return styleElement;
-	}
-	/**
-	* Inject raw CSS text directly without parsing
-	* Returns a dispose function to remove the injected CSS
-	*/
-	injectRawCSS(css, root) {
-		if (!css.trim()) return { dispose: () => {} };
-		const id = `raw_${this.rawCSSCounter++}`;
-		if (this.isAdoptedMode(root)) {
-			this.getOrCreateRawAdoptedSheet(root);
-			const blocksMap = this.rawCSSBlocks.get(root);
-			const info = {
-				id,
-				css,
-				startOffset: 0,
-				endOffset: css.length
-			};
-			blocksMap.set(id, info);
-			this.rebuildRawAdoptedSheet(root);
-			return { dispose: () => {
-				this.disposeRawCSS(id, root);
-			} };
-		}
-		const styleElement = this.getOrCreateRawStyleElement(root);
-		const blocksMap = this.rawCSSBlocks.get(root);
-		const currentContent = styleElement.textContent || "";
-		const startOffset = currentContent.length;
-		const cssWithNewline = (currentContent ? "\n" : "") + css;
-		const endOffset = startOffset + cssWithNewline.length;
-		styleElement.textContent = currentContent + cssWithNewline;
-		const info = {
-			id,
-			css,
-			startOffset,
-			endOffset
-		};
-		blocksMap.set(id, info);
-		return { dispose: () => {
-			this.disposeRawCSS(id, root);
-		} };
-	}
-	/**
-	* Rebuild the raw CSS constructable sheet from all tracked blocks.
-	*/
-	rebuildRawAdoptedSheet(root) {
-		const sheet = this.rawConstructableSheets.get(root);
-		const blocksMap = this.rawCSSBlocks.get(root);
-		if (!sheet || !blocksMap) return;
-		if (blocksMap.size === 0) {
-			sheet.replaceSync("");
-			return;
-		}
-		const blocks = Array.from(blocksMap.values());
-		blocks.sort((a, b) => a.startOffset - b.startOffset);
-		const allCSS = blocks.map((b) => b.css).join("\n");
-		sheet.replaceSync(allCSS);
-	}
-	/**
-	* Remove a raw CSS block by ID
-	*/
-	disposeRawCSS(id, root) {
-		const blocksMap = this.rawCSSBlocks.get(root);
-		if (!blocksMap) return;
-		if (!blocksMap.get(id)) return;
-		blocksMap.delete(id);
-		if (this.isAdoptedMode(root)) {
-			this.rebuildRawAdoptedSheet(root);
-			return;
-		}
-		const styleElement = this.rawStyleElements.get(root);
-		if (!styleElement) return;
-		const remainingBlocks = Array.from(blocksMap.values());
-		if (remainingBlocks.length === 0) styleElement.textContent = "";
-		else {
-			remainingBlocks.sort((a, b) => a.startOffset - b.startOffset);
-			styleElement.textContent = remainingBlocks.map((block) => block.css).join("\n");
-			let offset = 0;
-			for (const block of remainingBlocks) {
-				block.startOffset = offset;
-				block.endOffset = offset + block.css.length;
-				offset = block.endOffset + 1;
-			}
-		}
-	}
-	/**
-	* Get the raw CSS content
-	*/
-	/**
-	* The CSS this injector owns in `root`, one entry per sheet, in the order the
-	* engine applies them.
-	*
-	* `getCSSText()` walks the managed sheets only, and raw CSS has its own —
-	* which sits before, after, or *between* them depending on how it got there:
-	* prepended to `adoptedStyleSheets`, or wherever in `<head>` the first raw
-	* injection happened to land, with every managed sheet opened afterwards
-	* following it. Reporting a fixed order would describe the opposite winner
-	* from the live page whenever two rules of equal specificity meet, so the raw
-	* sheet is spliced in at the position the DOM actually gives it.
-	*/
-	getOwnedCSSInOrder(registry, root) {
-		const raw = this.getRawCSSText(root);
-		const rawElement = this.isAdoptedMode(root) ? null : this.rawStyleElements.get(root);
-		let rawIndex = raw && !rawElement ? 0 : -1;
-		const chunks = [];
-		for (const sheetInfo of registry.sheets) {
-			const css = this.readSheetCSS(sheetInfo);
-			if (css === null) continue;
-			if (rawIndex < 0 && rawElement && sheetInfo.sheet && rawElement.compareDocumentPosition(sheetInfo.sheet) & Node.DOCUMENT_POSITION_FOLLOWING) rawIndex = chunks.length;
-			chunks.push(css);
-		}
-		if (!raw) return chunks;
-		chunks.splice(rawIndex < 0 ? chunks.length : rawIndex, 0, raw);
-		return chunks;
-	}
-	/**
-	* Top-level rules in the raw sheet.
-	*
-	* Read from the sheet the engine parsed, not from the text: a raw block is
-	* one string but any number of rules, and one rule — `@keyframes`, `@media` —
-	* can contain any number of blocks, so counting braces answers neither
-	* question.
-	*/
-	getRawRuleCount(root) {
-		const sheet = this.isAdoptedMode(root) ? this.rawConstructableSheets.get(root) : this.rawStyleElements.get(root)?.sheet;
-		try {
-			return sheet?.cssRules.length ?? 0;
-		} catch {
-			return 0;
-		}
-	}
-	getRawCSSText(root) {
-		if (this.isAdoptedMode(root)) {
-			const blocksMap = this.rawCSSBlocks.get(root);
-			if (!blocksMap || blocksMap.size === 0) return "";
-			const blocks = Array.from(blocksMap.values());
-			blocks.sort((a, b) => a.startOffset - b.startOffset);
-			return blocks.map((b) => b.css).join("\n");
-		}
-		return this.rawStyleElements.get(root)?.textContent || "";
-	}
-};
-//#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.
-* Long enough that a render cannot plausibly still be waiting to commit one.
-*/
-const DEFAULT_GC_GRACE = 1e4;
-/** Dispose handle handed back for injections that took no pin. */
-const noop = () => {};
-/**
-* Placeholder `KeyframesInfo` for a cache entry reserved by a batched write and
-* not yet backed by a real rule. Only ever read through `entry.pending`, which
-* is checked before the info is used.
-*/
-const EMPTY_KEYFRAMES_INFO = {
-	name: "",
-	ruleIndex: -3,
-	sheetIndex: -3
-};
-/**
-* Extract class names from `<style data-tasty-rsc>` tags.
-* The doubled-specificity pattern `.tXXX.tXXX` makes extraction reliable.
-*/
-function extractRSCClassNames(rscClassRegex) {
-	if (typeof document === "undefined") return [];
-	const styles = document.querySelectorAll("style[data-tasty-rsc]");
-	if (styles.length === 0) return [];
-	const classSet = /* @__PURE__ */ new Set();
-	for (const style of styles) {
-		const text = style.textContent;
-		if (!text) continue;
-		let match;
-		rscClassRegex.lastIndex = 0;
-		while ((match = rscClassRegex.exec(text)) !== null) classSet.add(match[1]);
-	}
-	return Array.from(classSet);
-}
-/**
-* Lazily sync server-rendered class names into the client registry.
-*
-* Sources:
-* 1. `window.__TASTY__` — pushed by SSR/RSC streaming scripts
-* 2. `<style data-tasty-rsc>` tags — inline CSS emitted by RSC components
-*
-* Called inside `inject()` / `allocateClassName()` to pick up
-* class names rendered on the server (including during SPA navigation).
-*/
-function syncServerClasses(registry, rscClassRegex) {
-	if (typeof window === "undefined") return;
-	const classes = window.__TASTY__;
-	if (classes && classes.length > registry.serverClassSyncIndex) {
-		for (let i = registry.serverClassSyncIndex; i < classes.length; i++) registerHydratedClass(registry, classes[i]);
-		registry.serverClassSyncIndex = classes.length;
-	}
-	if (!registry.rscStylesScanned) {
-		registry.rscStylesScanned = true;
-		for (const cls of extractRSCClassNames(rscClassRegex)) registerHydratedClass(registry, cls);
-	}
-}
-function registerHydratedClass(registry, className) {
-	if (registry.rules.has(className)) return;
-	registry.rules.set(className, {
-		className,
-		ruleIndex: -2,
-		sheetIndex: -2
-	});
-	registry.pinCounts.set(className, 0);
-}
-var StyleInjector = class {
-	sheetManager;
-	config;
-	globalRuleCounter = 0;
-	/** Cancels the scheduled sweep, whichever timer scheduled it. */
-	cancelPendingGC = null;
-	namePrefix;
-	classRegex;
-	rscClassRegex;
-	/** @internal — exposed for debug utilities only */
-	get _sheetManager() {
-		return this.sheetManager;
-	}
-	/**
-	* Whether sheet writes should be queued instead of applied immediately.
-	*
-	* Only ever true on the client: SSR collects CSS as text and the RSC path
-	* returns it as strings, so neither has a live sheet to batch writes against.
-	*
-	* In the default `true` mode a write is only queued inside an open batch
-	* window — a commit in which `<TastyBatchProvider>` rendered and will
-	* therefore flush in its insertion effect, before any layout effect can
-	* measure. Everything else falls through to a synchronous write, so enabling
-	* the flag cannot make a `useLayoutEffect` read an unstyled element.
-	* `'always'` drops the gate and accepts that trade for wider coverage.
-	*/
-	get batching() {
-		const mode = this.config.batchInjection;
-		if (!mode || typeof document === "undefined") return false;
-		if (mode === "always") return true;
-		if (isBatchWindowOpen()) return true;
-		warnBatchProviderMissing();
-		return false;
-	}
-	/**
-	* Apply a sheet write now, or queue it when batching is on.
-	* Returns the queue handle when deferred, so the caller can cancel it if it
-	* disposes before the flush.
-	*/
-	writeSheet(task) {
-		if (this.batching) return enqueueStyleWrite(task);
-		task();
-		return null;
-	}
-	/**
-	* Insert a global (non-class) rule, honouring batching.
-	*
-	* `onApplied` records the caller's dedupe bookkeeping. When the write is
-	* queued it runs eagerly, so a repeat call before the flush bails out instead
-	* of queueing the same rule twice — the same reasoning as
-	* `insertPropertyRule`'s eager marking. When written synchronously it runs
-	* only on success, preserving the existing retry-on-failure behaviour.
-	*/
-	writeGlobalRule(registry, rules, key, root, onApplied) {
-		if (this.batching) {
-			onApplied?.();
-			enqueueStyleWrite(() => {
-				this.sheetManager.insertGlobalRule(registry, rules, key, root);
-			});
-			return;
-		}
-		if (this.sheetManager.insertGlobalRule(registry, rules, key, root)) onApplied?.();
-	}
-	constructor(config = {}) {
-		if (config.namePrefix !== void 0) validateNamePrefix(config.namePrefix);
-		this.config = config;
-		this.sheetManager = new SheetManager(config);
-		this.namePrefix = config.namePrefix ?? "t";
-		this.classRegex = tastyClassRegex(this.namePrefix);
-		this.rscClassRegex = rscClassRegexGlobal(this.namePrefix);
-	}
-	/**
-	* Generate a deterministic class name from a cache key using content hash.
-	* The same cache key always produces the same class name across environments
-	* with the same `namePrefix`.
-	*/
-	generateClassName(cacheKey) {
-		return makeClassName(this.namePrefix, hashString(cacheKey));
-	}
-	/**
-	* Check if `className` was hydrated from server-rendered styles and,
-	* if so, wire the cacheKey mapping. Returns true on hit.
-	*/
-	tryHydratedHit(registry, cacheKey, className) {
-		syncServerClasses(registry, this.rscClassRegex);
-		const rule = registry.rules.get(className);
-		if (rule && rule.ruleIndex === -2 && rule.sheetIndex === -2) {
-			registry.cacheKeyToClassName.set(cacheKey, className);
-			return true;
-		}
-		return false;
-	}
-	/**
-	* Allocate a className for a cacheKey without injecting styles yet.
-	* This allows separating className allocation (render phase) from style injection (insertion phase).
-	*/
-	allocateClassName(cacheKey, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		if (registry.cacheKeyToClassName.has(cacheKey)) return {
-			className: registry.cacheKeyToClassName.get(cacheKey),
-			isNewAllocation: false
-		};
-		const className = this.generateClassName(cacheKey);
-		if (this.tryHydratedHit(registry, cacheKey, className)) return {
-			className,
-			isNewAllocation: false
-		};
-		if (registry.rules.get(className)) {
-			if (isDevEnv()) console.warn(`[Tasty] Hash collision: cache keys produce the same class "${className}". Styles may be incorrect.`);
-			registry.cacheKeyToClassName.set(cacheKey, className);
-			return {
-				className,
-				isNewAllocation: false
-			};
-		}
-		const placeholderRuleInfo = {
-			className,
-			ruleIndex: -1,
-			sheetIndex: -1
-		};
-		registry.rules.set(className, placeholderRuleInfo);
-		registry.cacheKeyToClassName.set(cacheKey, className);
-		return {
-			className,
-			isNewAllocation: true
-		};
-	}
-	/**
-	* Inject styles from StyleResult objects
-	*/
-	inject(rules, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const pin = options?.pin ?? true;
-		if (rules.length === 0) return {
-			className: "",
-			dispose: () => {}
-		};
-		const cacheKey = options?.cacheKey;
-		let className;
-		if (cacheKey && registry.cacheKeyToClassName.has(cacheKey)) {
-			className = registry.cacheKeyToClassName.get(cacheKey);
-			const existingRuleInfo = registry.rules.get(className);
-			if (existingRuleInfo.ruleIndex === -3) {
-				registry.unusedSince.delete(className);
-				if (pin) registry.pinCounts.set(className, (registry.pinCounts.get(className) || 0) + 1);
-				if (registry.metrics) registry.metrics.hits++;
-				return {
-					className,
-					dispose: pin ? () => this.unpin(className, registry) : noop
-				};
-			}
-			if (!(existingRuleInfo.ruleIndex === -1 && existingRuleInfo.sheetIndex === -1)) {
-				registry.unusedSince.delete(className);
-				if (pin) {
-					const pins = registry.pinCounts.get(className) || 0;
-					registry.pinCounts.set(className, pins + 1);
-				}
-				if (registry.metrics) registry.metrics.hits++;
-				return {
-					className,
-					dispose: pin ? () => this.unpin(className, registry) : noop
-				};
-			}
-		} else if (cacheKey) {
-			className = this.generateClassName(cacheKey);
-			if (this.tryHydratedHit(registry, cacheKey, className)) {
-				if (pin) registry.pinCounts.set(className, (registry.pinCounts.get(className) || 0) + 1);
-				if (registry.metrics) registry.metrics.hits++;
-				return {
-					className,
-					dispose: pin ? () => this.unpin(className, registry) : noop
-				};
-			}
-		} else {
-			const parts = rules.map((r) => `${r.selector}\0${r.declarations}`);
-			className = makeClassName(this.namePrefix, hashString(parts.join("\n")));
-		}
-		const rulesToInsert = rules.map((rule) => {
-			let newSelector = rule.selector;
-			if (rule.needsClassName) {
-				const selectorParts = newSelector ? newSelector.split("|||") : [""];
-				const classPrefix = `.${className}.${className}`;
-				newSelector = selectorParts.map((part) => {
-					const classSelector = part ? `${classPrefix}${part}` : classPrefix;
-					if (rule.rootPrefix) return `${rule.rootPrefix} ${classSelector}`;
-					return classSelector;
-				}).join(", ");
-			}
-			return {
-				...rule,
-				selector: newSelector,
-				needsClassName: void 0,
-				rootPrefix: void 0
-			};
-		});
-		const applySheetWrite = () => {
-			if (this.config.autoPropertyTypes !== false) {
-				const resolver = registry.propertyTypeResolver;
-				const defined = registry.injectedProperties;
-				for (const rule of rulesToInsert) {
-					if (!rule.declarations) continue;
-					resolver.scanDeclarations(rule.declarations, (name) => defined.has(name), (name, syntax, initialValue) => {
-						this.property(name, {
-							syntax,
-							inherits: true,
-							initialValue,
-							root
-						});
-					});
-				}
-			}
-			const ruleInfo = this.sheetManager.insertRule(registry, rulesToInsert, className, root);
-			if (!ruleInfo) {
-				if (registry.metrics) registry.metrics.misses++;
-				return null;
-			}
-			registry.rules.set(className, ruleInfo);
-			if (cacheKey) registry.cacheKeyToClassName.set(cacheKey, className);
-			if (registry.metrics) {
-				registry.metrics.totalInsertions++;
-				registry.metrics.misses++;
-			}
-			return ruleInfo;
-		};
-		if (this.batching) {
-			registry.rules.set(className, {
-				className,
-				ruleIndex: -3,
-				sheetIndex: -3
-			});
-			if (cacheKey) registry.cacheKeyToClassName.set(cacheKey, className);
-			if (pin) registry.pinCounts.set(className, 1);
-			registry.unusedSince.set(className, Date.now());
-			const queued = enqueueStyleWrite(() => {
-				if (applySheetWrite()) return;
-				registry.rules.set(className, {
-					className,
-					ruleIndex: -1,
-					sheetIndex: -1
-				});
-			});
-			return {
-				className,
-				dispose: pin ? () => {
-					if (!queued.done && registry.pinCounts.get(className) === 1 && registry.rules.get(className)?.ruleIndex === -3) {
-						queued.cancelled = true;
-						registry.rules.delete(className);
-						if (cacheKey) registry.cacheKeyToClassName.delete(cacheKey);
-						registry.pinCounts.set(className, 0);
-						return;
-					}
-					this.unpin(className, registry);
-				} : noop
-			};
-		}
-		if (!applySheetWrite()) return {
-			className,
-			dispose: () => {}
-		};
-		if (pin) registry.pinCounts.set(className, 1);
-		registry.unusedSince.set(className, Date.now());
-		return {
-			className,
-			dispose: pin ? () => this.unpin(className, registry) : noop
-		};
-	}
-	/**
-	* Inject global styles (rules without a generated tasty class selector)
-	* This ensures we don't reserve a tasty class name (t{number}) for global rules,
-	* which could otherwise collide with element-level styles and break lookups.
-	*/
-	injectGlobal(rules, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		if (!rules || rules.length === 0) return { dispose: () => {} };
-		const key = `global:${this.globalRuleCounter++}`;
-		const applyWrite = () => {
-			if (this.config.autoPropertyTypes !== false) {
-				const resolver = registry.propertyTypeResolver;
-				const defined = registry.injectedProperties;
-				for (const rule of rules) {
-					if (!rule.declarations) continue;
-					resolver.scanDeclarations(rule.declarations, (name) => defined.has(name), (name, syntax, initialValue) => {
-						this.property(name, {
-							syntax,
-							inherits: true,
-							initialValue,
-							root
-						});
-					});
-				}
-			}
-			const inserted = this.sheetManager.insertGlobalRule(registry, rules, key, root);
-			if (registry.metrics) registry.metrics.totalInsertions++;
-			return inserted;
-		};
-		if (this.batching) {
-			let info = null;
-			const queued = enqueueStyleWrite(() => {
-				info = applyWrite();
-			});
-			return { dispose: () => {
-				if (!queued.done) {
-					queued.cancelled = true;
-					return;
-				}
-				if (info) this.sheetManager.deleteGlobalRule(registry, key);
-			} };
-		}
-		const info = applyWrite();
-		return { dispose: () => {
-			if (info) this.sheetManager.deleteGlobalRule(registry, key);
-		} };
-	}
-	/**
-	* Inject raw CSS text directly without parsing
-	* This is a low-overhead alternative to createGlobalStyle for raw CSS
-	* The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking
-	*/
-	injectRawCSS(css, options) {
-		const root = options?.root || document;
-		if (!this.batching) return this.sheetManager.injectRawCSS(css, root);
-		let result = null;
-		const queued = enqueueStyleWrite(() => {
-			result = this.sheetManager.injectRawCSS(css, root);
-		});
-		return { dispose: () => {
-			if (!queued.done) {
-				queued.cancelled = true;
-				return;
-			}
-			result?.dispose();
-		} };
-	}
-	/**
-	* Get raw CSS text for SSR
-	*/
-	getRawCSSText(options) {
-		flushStyles();
-		const root = options?.root || document;
-		return this.sheetManager.getRawCSSText(root);
-	}
-	/**
-	* Take a reference on local `@keyframes`, under the deterministic names the
-	* caller resolved.
-	*
-	* One reference per distinct set of steps, shared by every class that ends up
-	* animating it, so a repeat render takes nothing further. Ownership is
-	* assigned by `ownKeyframes()` once the rules exist to be inspected.
-	*/
-	holdKeyframes(steps, names, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const keys = /* @__PURE__ */ new Map();
-		for (const [authored, definition] of Object.entries(steps)) {
-			const resolved = names.get(authored) ?? authored;
-			let entry = registry.localKeyframes.get(resolved);
-			if (!entry) {
-				const injected = this.keyframes(definition, {
-					name: resolved,
-					root,
-					distinctByName: true
-				});
-				entry = {
-					name: injected.toString(),
-					dispose: injected.dispose,
-					owners: /* @__PURE__ */ new Set()
-				};
-				registry.localKeyframes.set(resolved, entry);
-			}
-			keys.set(authored, resolved);
-		}
-		return keys;
-	}
-	/**
-	* Record that `className` animates these keyframes, so the reference is
-	* released when the last such class is collected.
-	*
-	* Only classes whose rules actually reference the animation should be here:
-	* a class that merely rendered alongside one would otherwise keep the
-	* keyframes alive for as long as it lives.
-	*/
-	ownKeyframes(key, className, options) {
-		this.sheetManager.getRegistry(options?.root || document).localKeyframes.get(key)?.owners.add(className);
-	}
-	/**
-	* Pin an already-injected cacheKey and return the handle that releases it.
-	* For callers that skipped the pipeline on a cache hit but still need the
-	* class held. Returns null if the cacheKey is not found.
-	*/
-	trackRef(cacheKey, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		if (!registry.cacheKeyToClassName.has(cacheKey)) return null;
-		const className = registry.cacheKeyToClassName.get(cacheKey);
-		const pins = registry.pinCounts.get(className) || 0;
-		registry.pinCounts.set(className, pins + 1);
-		if (registry.metrics) registry.metrics.hits++;
-		return {
-			className,
-			dispose: () => this.unpin(className, registry)
-		};
-	}
-	/**
-	* Release one pin on a className. At zero pins the class is not deleted — it
-	* stays cached and collectible, and `gc()` decides when it actually goes.
-	*/
-	unpin(className, registry) {
-		const pins = registry.pinCounts.get(className);
-		if (pins == null || pins <= 0) return;
-		const remaining = pins - 1;
-		registry.pinCounts.set(className, remaining);
-		if (remaining === 0 && registry.metrics) registry.metrics.totalUnused++;
-	}
-	/**
-	* Remove every style that is neither in the DOM nor referenced by an
-	* outstanding `inject()` handle, ignoring the GC capacity threshold.
-	*/
-	cleanup(root) {
-		this.gc({
-			root,
-			force: true
-		});
-	}
-	/**
-	* Get CSS text from all sheets (for SSR)
-	*/
-	getCSSText(options) {
-		flushStyles();
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		return this.sheetManager.getCSSText(registry);
-	}
-	/**
-	* Get CSS only for the provided tasty classNames (e.g., ["t0","t3"])
-	*/
-	getCSSTextForClasses(classNames, options) {
-		flushStyles();
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const cssChunks = [];
-		for (const cls of classNames) {
-			const info = registry.rules.get(cls);
-			if (info) {
-				const sheet = registry.sheets[info.sheetIndex];
-				const styleSheet = sheet ? this.sheetManager.getCSSSheet(sheet) : null;
-				if (styleSheet) {
-					const start = Math.max(0, info.ruleIndex);
-					const end = Math.min(styleSheet.cssRules.length - 1, info.endRuleIndex ?? info.ruleIndex);
-					if (start >= 0 && end >= start && start < styleSheet.cssRules.length) for (let i = start; i <= end; i++) {
-						const rule = styleSheet.cssRules[i];
-						if (rule) cssChunks.push(rule.cssText);
-					}
-				} else if (info.cssText && info.cssText.length) cssChunks.push(...info.cssText);
-			}
-		}
-		return cssChunks.join("\n");
-	}
-	/**
-	* Get cache performance metrics
-	*/
-	getMetrics(options) {
-		flushStyles();
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const metrics = this.sheetManager.getMetrics(registry);
-		if (metrics && typeof document !== "undefined") metrics.unusedHits = this.collectUnused(registry, root).length;
-		return metrics;
-	}
-	/**
-	* Reset cache performance metrics
-	*/
-	resetMetrics(options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		this.sheetManager.resetMetrics(registry);
-	}
-	/**
-	* Define a CSS @property custom property.
-	*
-	* Accepts tasty token syntax for the property name:
-	* - `$name` → defines `--name`
-	* - `#name` → defines `--name-color` (auto-sets syntax: '<color>', defaults initialValue: 'transparent')
-	* - `--name` → defines `--name` (legacy format)
-	*
-	* Example:
-	* @property --rotation { syntax: "<angle>"; inherits: false; initial-value: 45deg; }
-	*
-	* Note: No caching or dispose — this defines a global property.
-	*
-	* If the same property is registered with different options, a warning is emitted
-	* but the original definition is preserved (CSS @property cannot be redefined).
-	*/
-	property(name, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const effectiveResult = getEffectiveDefinition(name, {
-			syntax: options?.syntax,
-			inherits: options?.inherits,
-			initialValue: options?.initialValue
-		});
-		if (!effectiveResult.isValid) {
-			if (isDevEnv()) console.warn(`[Tasty] property(): ${effectiveResult.error}. Got: "${name}"`);
-			return;
-		}
-		const cssName = effectiveResult.cssName;
-		const definition = effectiveResult.definition;
-		this.insertPropertyRule(registry, root, cssName, definition, name);
-	}
-	/**
-	* Build and insert a single `@property` rule into the given registry.
-	* No-op if the property was already injected.
-	*/
-	insertPropertyRule(registry, root, cssName, definition, cacheKey) {
-		if (registry.injectedProperties.has(cssName)) return;
-		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};`);
-		}
-		const declarations = parts.join(" ").trim();
-		const rule = {
-			selector: `@property ${cssName}`,
-			declarations
-		};
-		registry.injectedProperties.set(cssName, normalizePropertyDefinition(definition));
-		this.writeGlobalRule(registry, [rule], `property:${cacheKey}`, root);
-	}
-	/**
-	* Check whether a given @property name was already injected by this injector.
-	*
-	* Accepts tasty token syntax:
-	* - `$name` → checks `--name`
-	* - `#name` → checks `--name-color`
-	* - `--name` → checks `--name` (legacy format)
-	*/
-	isPropertyDefined(name, options) {
-		flushStyles();
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const effectiveResult = getEffectiveDefinition(name, {});
-		if (!effectiveResult.isValid) return false;
-		return registry.injectedProperties.has(effectiveResult.cssName);
-	}
-	/**
-	* Inject a CSS @font-face rule.
-	*
-	* Permanent and global — no dispose or ref-counting.
-	* Deduplicates by content hash (family + descriptors).
-	*/
-	fontFace(family, descriptors, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const hash = fontFaceContentHash(family, descriptors);
-		if (registry.injectedFontFaces.has(hash)) return;
-		const rule = {
-			selector: "@font-face",
-			declarations: formatFontFaceDeclarations(family, descriptors)
-		};
-		this.writeGlobalRule(registry, [rule], `fontface:${hash}`, root, () => {
-			registry.injectedFontFaces.add(hash);
-		});
-	}
-	/**
-	* Inject a CSS @counter-style rule.
-	*
-	* Permanent and global — no dispose or ref-counting. Deduplicates by name.
-	* By default a definition overrides a previously injected one of the same
-	* name. Pass `weak: true` for global `configure()` definitions, which must
-	* never clobber an existing rule (so component-local definitions win
-	* regardless of injection order).
-	*/
-	counterStyle(name, descriptors, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const isWeak = options?.weak === true;
-		const existingIsStrong = registry.injectedCounterStyles.get(name);
-		if (existingIsStrong !== void 0) {
-			if (isWeak || existingIsStrong === true) return;
-			this.writeSheet(() => {
-				this.sheetManager.deleteGlobalRule(registry, `counterstyle:${name}`);
-			});
-		}
-		const rule = {
-			selector: `@counter-style ${name}`,
-			declarations: formatCounterStyleDeclarations(descriptors)
-		};
-		this.writeGlobalRule(registry, [rule], `counterstyle:${name}`, root, () => {
-			registry.injectedCounterStyles.set(name, !isWeak);
-		});
-	}
-	/**
-	* Inject a CSS @function rule (custom function).
-	*
-	* Permanent and global — no dispose or ref-counting. Deduplicates by function
-	* name. By default a definition overrides a previously injected one of the
-	* same name. Pass `weak: true` for global `configure()` definitions, which
-	* must never clobber an existing rule (so component-local definitions win
-	* regardless of injection order).
-	*/
-	func(name, definition, options) {
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		const isWeak = options?.weak === true;
-		const cssName = parseFunctionName(name);
-		const existingIsStrong = registry.injectedFunctions.get(cssName);
-		if (existingIsStrong !== void 0) {
-			if (isWeak || existingIsStrong === true) return;
-			this.writeSheet(() => {
-				this.sheetManager.deleteGlobalRule(registry, `function:${cssName}`);
-			});
-		}
-		const rule = {
-			selector: formatFunctionPrelude(name, definition.args, definition.returns),
-			declarations: formatFunctionDeclarations(definition)
-		};
-		this.writeGlobalRule(registry, [rule], `function:${cssName}`, root, () => {
-			registry.injectedFunctions.set(cssName, !isWeak);
-		});
-	}
-	/**
-	* Inject keyframes and return object with toString() and dispose()
-	*
-	* Keyframes are cached by content (steps). If the same content is injected
-	* multiple times with different provided names, the first injected name is reused.
-	*
-	* If the same name is provided with different content (collision), a unique
-	* name is generated to avoid overwriting the existing keyframes.
-	*/
-	keyframes(steps, nameOrOptions) {
-		const isStringName = typeof nameOrOptions === "string";
-		const providedName = isStringName ? nameOrOptions : nameOrOptions?.name;
-		const distinctByName = isStringName ? false : nameOrOptions?.distinctByName ?? false;
-		const root = isStringName ? document : nameOrOptions?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		if (Object.keys(steps).length === 0) return {
-			toString: () => "",
-			dispose: () => {}
-		};
-		const contentHash = distinctByName && providedName ? `${providedName}\u0000${JSON.stringify(steps)}` : JSON.stringify(steps);
-		const existing = registry.keyframesCache.get(contentHash);
-		if (existing) {
-			existing.refCount++;
-			return {
-				toString: () => existing.name,
-				dispose: () => this.disposeKeyframes(contentHash, registry)
-			};
-		}
-		let actualName;
-		if (providedName) {
-			const existingContentForName = registry.keyframesNameToContent.get(providedName);
-			if (existingContentForName && existingContentForName !== contentHash) actualName = `${providedName}-${makeKeyframeName(this.namePrefix, String(registry.keyframesCounter++))}`;
-			else {
-				actualName = providedName;
-				registry.keyframesNameToContent.set(providedName, contentHash);
-			}
-		} else actualName = makeKeyframeName(this.namePrefix, String(registry.keyframesCounter++));
-		const applyWrite = () => {
-			const result = this.sheetManager.insertKeyframes(registry, steps, actualName, root);
-			if (!result) return false;
-			const { info, declarations } = result;
-			if (this.config.autoPropertyTypes !== false && declarations) registry.propertyTypeResolver.scanDeclarations(declarations, (name) => registry.injectedProperties.has(name), (name, syntax, initialValue) => {
-				this.property(name, {
-					syntax,
-					inherits: true,
-					initialValue,
-					root
-				});
-			});
-			const entry = registry.keyframesCache.get(contentHash);
-			if (entry) {
-				entry.info = info;
-				entry.pending = void 0;
-			} else registry.keyframesCache.set(contentHash, {
-				name: actualName,
-				refCount: 1,
-				info
-			});
-			if (registry.metrics) {
-				registry.metrics.totalInsertions++;
-				registry.metrics.misses++;
-			}
-			return true;
-		};
-		if (this.batching) {
-			const entry = {
-				name: actualName,
-				refCount: 1,
-				info: EMPTY_KEYFRAMES_INFO
-			};
-			registry.keyframesCache.set(contentHash, entry);
-			entry.pending = enqueueStyleWrite(() => {
-				if (applyWrite()) return;
-				if (registry.keyframesCache.get(contentHash) === entry) registry.keyframesCache.delete(contentHash);
-			});
-			return {
-				toString: () => actualName,
-				dispose: () => this.disposeKeyframes(contentHash, registry)
-			};
-		}
-		if (!applyWrite()) return {
-			toString: () => "",
-			dispose: () => {}
-		};
-		return {
-			toString: () => actualName,
-			dispose: () => this.disposeKeyframes(contentHash, registry)
-		};
-	}
-	/**
-	* Dispose keyframes
-	*/
-	disposeKeyframes(contentHash, registry) {
-		const entry = registry.keyframesCache.get(contentHash);
-		if (!entry) return;
-		entry.refCount--;
-		if (entry.refCount <= 0) {
-			if (entry.pending && !entry.pending.done) entry.pending.cancelled = true;
-			else this.sheetManager.deleteKeyframes(registry, entry.info);
-			registry.keyframesCache.delete(contentHash);
-			for (const [name, hash] of registry.keyframesNameToContent.entries()) if (hash === contentHash) {
-				registry.keyframesNameToContent.delete(name);
-				break;
-			}
-			if (registry.metrics) {
-				registry.metrics.totalUnused++;
-				registry.metrics.stylesCleanedUp++;
-			}
-		}
-	}
-	/**
-	* Count a render, and schedule a collection pass every `touchInterval` of
-	* them. Nothing else: what a class is worth keeping is decided by the sweep's
-	* own DOM scan, so rendering does not track usage at all.
-	*
-	* @deprecated The class name is ignored — pass anything, or stop calling it.
-	* Collection no longer records per-class usage, and scheduling does not need
-	* to know which class was rendered. A class handed back by `inject()` is
-	* marked wanted there, which is what reuse actually goes through.
-	*/
-	touch(_className, options) {
-		if (typeof document === "undefined") return;
-		if (!this.config.gc) return;
-		const registry = this.sheetManager.getRegistry(options?.root || document);
-		if (++registry.touchCount >= (this.config.gc.touchInterval ?? 1e3)) {
-			registry.touchCount = 0;
-			this.scheduleGC();
-		}
-	}
-	/**
-	* Schedule a GC in idle time. Runs GC on all active roots, and avoids
-	* double-scheduling.
-	*
-	* Idle only. Without `requestIdleCallback` nothing is collected
-	* automatically: running the sweep inline here would put it inside the render
-	* that touched the class, and collection is never urgent enough for that.
-	*/
-	scheduleGC() {
-		if (this.cancelPendingGC) return;
-		const runGC = () => {
-			this.cancelPendingGC = null;
-			this.sheetManager.pruneDisconnectedRoots();
-			for (const root of this.sheetManager.getActiveRoots()) this.gc({ root });
-		};
-		if (typeof requestIdleCallback !== "undefined") {
-			const handle = requestIdleCallback(() => runGC());
-			this.cancelPendingGC = () => cancelIdleCallback(handle);
-		}
-	}
-	/**
-	* The one definition of "unused": this injector owns the class's rules, no
-	* element in `root` carries it, and nobody pinned it.
-	*
-	* `gc()` evicts from this set, `getMetrics()` counts it, and `tastyDebug`
-	* reports it — all through here, so the three can never disagree about what
-	* "unused" means. Entries carry their last `touch()` so callers can drop the
-	* oldest first; a class that was never touched sorts as oldest.
-	*/
-	/**
-	* Everything the injector holds falls into one of five bands, and only the
-	* last of them is ever deleted:
-	*
-	* 1. rendered — some element carries the class right now
-	* 2. not ours — queued for a batched write, pre-allocated, or server-rendered
-	* 3. hot — nothing carries it, but that was noticed less than `grace` ago
-	* 4. cached — cold, but within `capacity` when ordered by when it went cold
-	* 5. the rest
-	*
-	* This returns bands 4 and 5 together, most recently cold first; `gc()` draws
-	* the capacity line through them. Band 3 is what makes collection safe
-	* without a commit signal: a render can resolve a class and commit it a
-	* little later, and during that gap nothing on the page carries it.
-	*/
-	collectUnused(registry, root) {
-		const now = Date.now();
-		const grace = this.config.gc?.grace ?? DEFAULT_GC_GRACE;
-		const liveClasses = /* @__PURE__ */ new Set();
-		for (const el of root.querySelectorAll("[class]")) for (const token of el.classList) if (this.classRegex.test(token)) liveClasses.add(token);
-		const unused = [];
-		for (const [className, ruleInfo] of registry.rules) {
-			if (ruleInfo.sheetIndex < 0) continue;
-			if (liveClasses.has(className)) {
-				registry.unusedSince.delete(className);
-				continue;
-			}
-			if ((registry.pinCounts.get(className) ?? 0) > 0) continue;
-			let since = registry.unusedSince.get(className);
-			if (since === void 0) {
-				since = now;
-				registry.unusedSince.set(className, now);
-			}
-			if (now - since < grace) continue;
-			unused.push(className);
-		}
-		unused.sort((a, b) => (registry.unusedSince.get(b) ?? 0) - (registry.unusedSince.get(a) ?? 0));
-		return unused;
-	}
-	/**
-	* Class names this injector holds CSS for that nothing renders and nobody
-	* pinned — exactly what `gc({ force: true })` would delete. Unordered.
-	*/
-	getUnusedClasses(options) {
-		flushStyles();
-		if (typeof document === "undefined") return [];
-		const root = options?.root || document;
-		const registry = this.sheetManager.getRegistry(root);
-		return this.collectUnused(registry, root);
-	}
-	/**
-	* Synchronous garbage collection.
-	*
-	* 1. Quick upper-bound check: skip if the registry is smaller than capacity.
-	* 2. Scans the DOM for live tasty classNames — the DOM, not a ref count, is
-	*    what says a class rendered by a component is still in use.
-	* 3. With `force: true`: deletes every unused class.
-	*    Without `force`: keeps the `capacity` most recently touched and deletes
-	*    the rest, oldest first.
-	*
-	* @returns Number of styles evicted.
-	*/
-	gc(options) {
-		flushStyles();
-		if (typeof document === "undefined") return 0;
-		this.cancelPendingGC?.();
-		this.cancelPendingGC = null;
-		const root = options?.root || document;
-		const force = options?.force;
-		const registry = this.sheetManager.getRegistry(root);
-		const capacity = this.config.gc?.capacity ?? 1e3;
-		if (!force && registry.rules.size <= capacity) return 0;
-		const unused = this.collectUnused(registry, root);
-		let doomed;
-		if (force) doomed = unused;
-		else if (unused.length > capacity) doomed = unused.slice(capacity);
-		else return 0;
-		if (doomed.length === 0) return 0;
-		return this.sheetManager.deleteClasses(registry, doomed);
-	}
-	/**
-	* Destroy all resources for a root
-	*/
-	destroy(root) {
-		flushStyles();
-		const targetRoot = root || document;
-		this.sheetManager.cleanup(targetRoot);
-		if (this.cancelPendingGC && !this.sheetManager.hasActiveRoots()) {
-			this.cancelPendingGC();
-			this.cancelPendingGC = null;
-		}
-	}
-};
-//#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
-*
-* Centralizes all tasty configuration, including:
-* - Style injector settings (nonce, cleanup thresholds, etc.)
-* - Global predefined states for advanced state mapping
-* - stylesGenerated flag that locks configuration after first style generation
-*
-* Configuration must be done BEFORE any styles are generated.
-* After the first `inject()` call, configuration is locked and attempts to
-* reconfigure will emit a warning and be ignored.
-*/
-const emittedWarnings = /* @__PURE__ */ new Set();
-const devMode$1 = isDevEnv();
-/**
-* Emit a warning only once
-*/
-function warnOnce(key, message) {
-	if (devMode$1 && !emittedWarnings.has(key)) {
-		emittedWarnings.add(key);
-		console.warn(message);
-	}
-}
-let currentConfig = null;
-let globalKeyframes = null;
-let globalFontFace = null;
-let globalCounterStyle = null;
-let globalFunction = null;
-let globalPolyfills = null;
-let globalProperties = null;
-let globalRecipes = null;
-let globalConfigTokens = null;
-let globalStyles = null;
-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) {
-	globalThis[key] = value;
-}
-function getFromGlobalThis(key) {
-	return globalThis[key];
-}
-function clearGlobalThisConfig() {
-	const g = globalThis;
-	delete g[GTKEY_TOKENS];
-	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];
-}
-/**
-* Default properties shipped with tasty.
-* These are always included unless explicitly overridden via `configure({ properties })`.
-* Keys use tasty token syntax (#name for colors, $name for other properties).
-*
-* For properties with CSS @property-compatible types (length, time, number, color),
-* an `initialValue` is provided so the property works even without a project-level token.
-*/
-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"
-	}
-};
-const GLOBAL_INJECTOR_KEY = "__TASTY_GLOBAL_INJECTOR__";
-/**
-* Detect if we're running in a test environment
-*/
-function isTestEnvironment() {
-	if (typeof global !== "undefined") {
-		const g = global;
-		if (g.vi || g.jest || g.expect || g.describe || g.it) return true;
-	}
-	if (typeof window !== "undefined") {
-		const ua = window.navigator?.userAgent;
-		if (ua?.includes("jsdom") || ua?.includes("HappyDOM")) return true;
-	}
-	if (typeof globalThis !== "undefined") {
-		const gt = globalThis;
-		if (gt.vitest || gt.mocha) return true;
-	}
-	return false;
-}
-/**
-* Create default configuration with optional test environment detection
-*/
-function createDefaultConfig(isTest) {
-	return {
-		maxRulesPerSheet: 8192,
-		forceTextInjection: isTest ?? false,
-		devMode: isDevEnv(),
-		namePrefix: "t"
-	};
-}
-/**
-* Mark that styles have been generated (called by injector on first inject)
-* This locks the configuration - no further changes allowed.
-* Also injects internal and global properties.
-*/
-function markStylesGenerated() {
-	if (!markStylesGeneratedState()) return;
-	if (typeof document !== "undefined" && document.querySelector("[data-tasty-ssr]")) {
-		warnOnce("ssr-globals-skip", "[Tasty] SSR styles detected — skipping client-side global CSS injection to avoid duplicates.");
-		return;
-	}
-	const injector = getGlobalInjector();
-	for (const [token, definition] of Object.entries(getEffectiveProperties())) injector.property(token, definition);
-	if (globalFontFace && Object.keys(globalFontFace).length > 0) for (const [family, input] of Object.entries(globalFontFace)) {
-		const descriptors = Array.isArray(input) ? input : [input];
-		for (const desc of descriptors) injector.fontFace(family, desc);
-	}
-	if (globalCounterStyle && Object.keys(globalCounterStyle).length > 0) for (const [name, descriptors] of Object.entries(globalCounterStyle)) injector.counterStyle(name, descriptors, { weak: true });
-	if (globalFunction && Object.keys(globalFunction).length > 0) for (const [name, definition] of Object.entries(globalFunction)) injector.func(name, definition, { weak: true });
-	if (globalConfigTokens && Object.keys(globalConfigTokens).length > 0) {
-		const tokenRules = renderStyles(globalConfigTokens, ":root");
-		if (tokenRules.length > 0) injector.injectGlobal(tokenRules);
-	}
-	if (globalStyles) {
-		for (const [selector, styles] of Object.entries(globalStyles)) if (Object.keys(styles).length > 0) {
-			const rules = renderStyles(styles, selector);
-			if (rules.length > 0) injector.injectGlobal(rules);
-		}
-	}
-}
-let _hasGlobalKeyframes = false;
-/**
-* Check if any global keyframes are configured.
-* Uses a pre-computed flag to avoid Object.keys() allocation on every call.
-*/
-function hasGlobalKeyframes() {
-	return _hasGlobalKeyframes;
-}
-/**
-* Get global keyframes configuration.
-* Returns null if no keyframes configured (fast path for zero-overhead).
-*/
-function getGlobalKeyframes() {
-	return globalKeyframes;
-}
-/**
-* Set global keyframes (called from configure).
-* Internal use only.
-*/
-function setGlobalKeyframes(keyframes) {
-	if (hasStylesGenerated()) {
-		warnOnce("keyframes-after-styles", "[Tasty] Cannot update keyframes after styles have been generated.\nThe new keyframes will be ignored.");
-		return;
-	}
-	globalKeyframes = {
-		...globalKeyframes ?? {},
-		...keyframes
-	};
-	_hasGlobalKeyframes = Object.keys(globalKeyframes).length > 0;
-}
-/**
-* Set global properties (called from configure).
-* Internal use only.
-*/
-function setGlobalProperties(properties) {
-	if (hasStylesGenerated()) {
-		warnOnce("properties-after-styles", "[Tasty] Cannot update properties after styles have been generated.\nThe new properties will be ignored.");
-		return;
-	}
-	globalProperties = {
-		...globalProperties ?? getFromGlobalThis(GTKEY_PROPERTIES) ?? {},
-		...properties
-	};
-	setOnGlobalThis(GTKEY_PROPERTIES, globalProperties);
-}
-/**
-* Get the effective properties: DEFAULT_PROPERTIES merged with user-configured
-* properties. User properties override defaults with matching keys.
-* Reads from globalThis first for cross-module SSR support.
-*/
-function getEffectiveProperties() {
-	const props = globalProperties ?? getFromGlobalThis(GTKEY_PROPERTIES);
-	if (!props) return DEFAULT_PROPERTIES;
-	return {
-		...DEFAULT_PROPERTIES,
-		...props
-	};
-}
-/**
-* Get global font-face configuration.
-* Returns null if no font faces configured.
-* Reads from globalThis first for cross-module SSR support.
-*/
-function getGlobalFontFaces() {
-	return globalFontFace ?? getFromGlobalThis(GTKEY_FONT_FACE) ?? null;
-}
-/**
-* Set global font faces (called from configure).
-* Internal use only.
-*/
-function setGlobalFontFace(fontFace) {
-	if (hasStylesGenerated()) {
-		warnOnce("fontface-after-styles", "[Tasty] Cannot update fontFaces after styles have been generated.\nThe new font faces will be ignored.");
-		return;
-	}
-	globalFontFace = {
-		...getGlobalFontFaces() ?? {},
-		...fontFace
-	};
-	setOnGlobalThis(GTKEY_FONT_FACE, globalFontFace);
-}
-/**
-* Get global counter-style configuration.
-* Returns null if no counter styles configured.
-* Reads from globalThis first for cross-module SSR support.
-*/
-function getGlobalCounterStyles() {
-	return globalCounterStyle ?? getFromGlobalThis(GTKEY_COUNTER_STYLE) ?? null;
-}
-/**
-* Set global counter styles (called from configure).
-* Internal use only.
-*/
-function setGlobalCounterStyle(counterStyle) {
-	if (hasStylesGenerated()) {
-		warnOnce("counterstyle-after-styles", "[Tasty] Cannot update counterStyles after styles have been generated.\nThe new counter styles will be ignored.");
-		return;
-	}
-	globalCounterStyle = {
-		...getGlobalCounterStyles() ?? {},
-		...counterStyle
-	};
-	setOnGlobalThis(GTKEY_COUNTER_STYLE, globalCounterStyle);
-}
-/**
-* Get global @function configuration.
-* Returns null if no functions configured.
-* Reads from globalThis first for cross-module SSR support.
-*/
-function getGlobalFunctions() {
-	return globalFunction ?? getFromGlobalThis(GTKEY_FUNCTION) ?? null;
-}
-/**
-* Set global functions (called from configure).
-* Internal use only.
-*/
-function setGlobalFunction(functions) {
-	if (hasStylesGenerated()) {
-		warnOnce("function-after-styles", "[Tasty] Cannot update functions after styles have been generated.\nThe new functions will be ignored.");
-		return;
-	}
-	globalFunction = {
-		...getGlobalFunctions() ?? {},
-		...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.
-*/
-function hasGlobalRecipes() {
-	return globalRecipes !== null && Object.keys(globalRecipes).length > 0;
-}
-/**
-* Get global recipes configuration.
-* Returns null if no recipes configured (fast path for zero-overhead).
-*/
-function getGlobalRecipes() {
-	return globalRecipes;
-}
-/**
-* Set global recipes (called from configure).
-* Internal use only.
-*/
-function setGlobalRecipes(recipes) {
-	if (hasStylesGenerated()) {
-		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 (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.`);
-			if (key === "recipe") warnOnce(`recipe-recursive-${name}`, `[Tasty] Recipe "${name}" contains a "recipe" key. Recipes cannot reference other recipes. Use space-separated names for composition: recipe: 'base elevated'.`);
-		}
-	}
-	globalRecipes = {
-		...globalRecipes ?? {},
-		...recipes
-	};
-}
-/**
-* Get global token styles for :root injection.
-* Returns null if no tokens configured.
-* Reads from globalThis first for cross-module SSR support.
-*/
-function getGlobalConfigTokens() {
-	return globalConfigTokens ?? getFromGlobalThis(GTKEY_TOKENS) ?? null;
-}
-/**
-* Set global token styles (called from configure).
-* Internal use only.
-*/
-function setGlobalConfigTokens(styles) {
-	if (hasStylesGenerated()) {
-		warnOnce("tokens-after-styles", "[Tasty] Cannot update tokens after styles have been generated.\nThe new tokens will be ignored.");
-		return;
-	}
-	globalConfigTokens = globalConfigTokens ? {
-		...globalConfigTokens,
-		...styles
-	} : styles;
-	setOnGlobalThis(GTKEY_TOKENS, globalConfigTokens);
-}
-/**
-* Get configured global styles for injection.
-* Returns null if no global styles configured.
-* Reads from globalThis first for cross-module SSR support.
-*/
-function getGlobalStyles() {
-	return globalStyles ?? getFromGlobalThis(GTKEY_GLOBAL_STYLES) ?? null;
-}
-/**
-* Set configured global styles (called from configure).
-* Internal use only.
-*/
-function setGlobalStyles(styles) {
-	if (hasStylesGenerated()) {
-		warnOnce("globalStyles-after-styles", "[Tasty] Cannot update globalStyles after styles have been generated.\nThe new global styles will be ignored.");
-		return;
-	}
-	if (globalStyles) for (const [selector, selectorStyles] of Object.entries(styles)) globalStyles[selector] = globalStyles[selector] ? {
-		...globalStyles[selector],
-		...selectorStyles
-	} : selectorStyles;
-	else globalStyles = { ...styles };
-	setOnGlobalThis(GTKEY_GLOBAL_STYLES, globalStyles);
-}
-/**
-* Check if configuration is locked (styles have been generated)
-*/
-function isConfigLocked() {
-	return hasStylesGenerated();
-}
-/**
-* Configure the Tasty style system.
-*
-* Must be called BEFORE any styles are generated (before first render that uses tasty).
-* After styles are generated, configuration is locked and calls to configure() will
-* emit a warning and be ignored.
-*
-* @example
-* ```ts
-* import { configure } from '@tenphi/tasty';
-*
-* // Configure before app renders
-* configure({
-*   nonce: 'abc123',
-*   states: {
-*     '@mobile': '@media(w < 768px)',
-*     '@dark': '@root(theme=dark)',
-*   },
-* });
-* ```
-*/
-function configure(config = {}) {
-	if (hasStylesGenerated()) {
-		warnOnce("configure-after-styles", "[Tasty] Cannot call configure() after styles have been generated.\nConfiguration must be done before the first render. The configuration will be ignored.");
-		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);
-	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);
-	const { states: _states, parserCacheSize: _parserCacheSize, units: _units, functions: _functions, polyfills: _polyfills, plugins: _plugins, keyframes: _keyframes, properties: _properties, fontFaces: _fontFaces, counterStyles: _counterStyles, handlers: _handlers, propHandlers: _propHandlers, baseStyleProps: _baseStyleProps, tokens: _tokens, replaceTokens: _replaceTokens, recipes: _recipes, colorSpace: _colorSpace, presets: _presets, globalStyles: _globalStyles, ...injectorConfig } = config;
-	const fullConfig = {
-		...createDefaultConfig(),
-		...currentConfig,
-		...injectorConfig
-	};
-	currentConfig = fullConfig;
-	const storage = typeof window !== "undefined" ? window : globalThis;
-	storage[GLOBAL_INJECTOR_KEY] = new StyleInjector(fullConfig);
-}
-/**
-* Get the current configuration.
-* If not configured, returns default configuration.
-*/
-function getConfig() {
-	if (!currentConfig) currentConfig = createDefaultConfig(isTestEnvironment());
-	return currentConfig;
-}
-/**
-* Get the configured prefix used for every generated identifier
-* (class names, keyframe names, counter-style names).
-*
-* Falls back to the default prefix (`'t'`) when `configure()` has not
-* been called yet — this matches the auto-configuration behavior used
-* by the rest of the system.
-*/
-function getNamePrefix() {
-	return currentConfig?.namePrefix ?? "t";
-}
-/**
-* Get the global injector instance.
-* Auto-configures with defaults if not already configured.
-*/
-function getGlobalInjector() {
-	const storage = typeof window !== "undefined" ? window : globalThis;
-	if (!storage[GLOBAL_INJECTOR_KEY]) configure();
-	return storage[GLOBAL_INJECTOR_KEY];
-}
-/**
-* Reset configuration (for testing only).
-* Clears the global injector and allows reconfiguration.
-*/
-function resetConfig() {
-	resetStylesGeneratedState();
-	currentConfig = null;
-	globalKeyframes = null;
-	_hasGlobalKeyframes = false;
-	globalProperties = null;
-	globalFontFace = null;
-	globalCounterStyle = null;
-	globalFunction = null;
-	globalPolyfills = null;
-	globalRecipes = null;
-	globalConfigTokens = null;
-	globalStyles = null;
-	clearGlobalThisConfig();
-	resetGlobalPredefinedTokens();
-	resetGlobalParseFunctions();
-	resetFunctionPolyfills();
-	resetHandlers();
-	resetStyleChunks();
-	resetPropHandlers();
-	resetBaseStyleProps();
-	clearPipelineCache();
-	emittedWarnings.clear();
-	resetStyleWarnings();
-	const storage = typeof window !== "undefined" ? window : globalThis;
-	delete storage[GLOBAL_INJECTOR_KEY];
-}
-//#endregion
-//#region src/injector/chunk-sheet-registry.ts
-/**
-* Global registry mapping CSS content hashes to shared constructable
-* CSSStyleSheet objects with reference counting.
-*
-* Multiple shadow roots adopting the same chunk share a single underlying
-* stylesheet object — parse once, adopt everywhere.
-*/
-var ChunkSheetRegistry = class {
-	sheets = /* @__PURE__ */ new Map();
-	sheetToHash = /* @__PURE__ */ new WeakMap();
-	/**
-	* Get or create a CSSStyleSheet for the given CSS text.
-	* Increments refCount. Uses content hash as the dedup key.
-	*/
-	acquire(cssText) {
-		const hash = hashString(cssText);
-		const existing = this.sheets.get(hash);
-		if (existing) {
-			existing.refCount++;
-			return existing.sheet;
-		}
-		const sheet = new CSSStyleSheet();
-		sheet.replaceSync(cssText);
-		const entry = {
-			sheet,
-			cssText,
-			refCount: 1
-		};
-		this.sheets.set(hash, entry);
-		this.sheetToHash.set(sheet, hash);
-		return sheet;
-	}
-	/**
-	* Decrement refCount for a sheet. When refCount reaches 0,
-	* the sheet is removed from the registry.
-	*/
-	release(sheet) {
-		const hash = this.sheetToHash.get(sheet);
-		if (!hash) return;
-		const entry = this.sheets.get(hash);
-		if (!entry) return;
-		entry.refCount--;
-		if (entry.refCount <= 0) {
-			this.sheets.delete(hash);
-			this.sheetToHash.delete(sheet);
-		}
-	}
-	/**
-	* Bulk acquire — returns an array of CSSStyleSheet in the same order.
-	*/
-	acquireAll(cssTexts) {
-		return cssTexts.map((text) => this.acquire(text));
-	}
-	/**
-	* Bulk release — decrements refCount for each sheet.
-	*/
-	releaseAll(sheets) {
-		for (const sheet of sheets) this.release(sheet);
-	}
-	/** Number of unique sheets currently held. */
-	get size() {
-		return this.sheets.size;
-	}
-};
-/** Module-level singleton shared across the entire application. */
-const chunkSheetRegistry = new ChunkSheetRegistry();
-//#endregion
-//#region src/injector/index.ts
-/**
-* Inject styles and return className with dispose function
-*/
-function inject(rules, options) {
-	const injector = getGlobalInjector();
-	markStylesGenerated();
-	return injector.inject(rules, options);
-}
-/**
-* Inject global rules that should not reserve tasty class names
-*/
-function injectGlobal(rules, options) {
-	return getGlobalInjector().injectGlobal(rules, options);
-}
-/**
-* Inject raw CSS text directly without parsing
-* This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.
-* The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.
-*
-* @example
-* ```tsx
-* // Inject raw CSS
-* const { dispose } = injectRawCSS(`
-*   body { margin: 0; padding: 0; }
-*   .my-class { color: red; }
-* `);
-*
-* // Later, remove the injected CSS
-* dispose();
-* ```
-*/
-function injectRawCSS(css, options) {
-	return getGlobalInjector().injectRawCSS(css, options);
-}
-/**
-* Get raw CSS text for SSR
-*/
-function getRawCSSText(options) {
-	return getGlobalInjector().getRawCSSText(options);
-}
-/**
-* Inject keyframes and return object with toString() and dispose()
-*/
-function keyframes(steps, nameOrOptions) {
-	return getGlobalInjector().keyframes(steps, nameOrOptions);
-}
-/**
-* Define a CSS @property custom property.
-* This enables advanced features like animating custom properties.
-*
-* Note: @property rules are global and persistent once defined.
-* Re-registering the same property name is a no-op.
-*
-* @param name - The custom property name (must start with --)
-* @param options - Property configuration
-*
-* @example
-* ```ts
-* // Define a color property that can be animated
-* property('--my-color', {
-*   syntax: '<color>',
-*   initialValue: 'red',
-* });
-*
-* // Define an angle property
-* property('--rotation', {
-*   syntax: '<angle>',
-*   inherits: false,
-*   initialValue: '0deg',
-* });
-* ```
-*/
-function property(name, options) {
-	return getGlobalInjector().property(name, options);
-}
-/**
-* Check if a CSS @property has already been defined
-*
-* @param name - The custom property name to check
-* @param options - Options including root
-*/
-function isPropertyDefined(name, options) {
-	return getGlobalInjector().isPropertyDefined(name, options);
-}
-/**
-* Inject a CSS @font-face rule.
-*
-* Permanent and global — no dispose or ref-counting.
-* Deduplicates by content hash (family + descriptors).
-*/
-function fontFace(family, descriptors, options) {
-	return getGlobalInjector().fontFace(family, descriptors, options);
-}
-/**
-* Inject a CSS @counter-style rule.
-*
-* Permanent and global — no dispose or ref-counting. Deduplicates by name and
-* overrides an existing rule by default. Pass `weak: true` for global
-* `configure()` definitions, which never clobber an existing rule.
-*/
-function counterStyle(name, descriptors, options) {
-	return getGlobalInjector().counterStyle(name, descriptors, options);
-}
-/**
-* Inject a CSS @function rule (custom function).
-*
-* Permanent and global — no dispose or ref-counting. Deduplicates by function
-* name and overrides an existing rule by default. Pass `weak: true` for global
-* `configure()` definitions, which never clobber an existing rule.
-*
-* @param name - The function name (`$$name`, `$name`, or `--name`)
-* @param definition - Function definition (args, returns, result, local vars)
-*
-* @example
-* ```ts
-* func('$$negative', { args: ['$value'], result: '(-1 * $value)' });
-* ```
-*/
-function func(name, definition, options) {
-	return getGlobalInjector().func(name, definition, options);
-}
-/**
-* Get CSS text from all sheets (for SSR)
-*/
-function getCSSText(options) {
-	return getGlobalInjector().getCSSText(options);
-}
-/**
-* Collect only CSS used by a rendered subtree (like jest-styled-components).
-* Pass the container returned by render(...).
-*/
-function getCSSTextForNode(node, options) {
-	const classRegex = tastyClassRegex(getNamePrefix());
-	const classSet = /* @__PURE__ */ new Set();
-	const readClasses = (el) => {
-		const cls = el.getAttribute("class");
-		if (!cls) return;
-		for (const token of cls.split(/\s+/)) if (classRegex.test(token)) classSet.add(token);
-	};
-	if (node.getAttribute) readClasses(node);
-	const elements = node.querySelectorAll ? node.querySelectorAll("[class]") : [];
-	if (elements) elements.forEach(readClasses);
-	return getGlobalInjector().getCSSTextForClasses(classSet, options);
-}
-/**
-* Take a reference on local `@keyframes` under the deterministic names the
-* caller resolved, and report which entry holds each. Pair with
-* `ownKeyframes()` once the rules exist to inspect.
-*/
-function holdKeyframes(steps, names, options) {
-	return getGlobalInjector().holdKeyframes(steps, names, options);
-}
-/**
-* Record that a class animates these keyframes, so the reference is released
-* when the last such class is collected.
-*/
-function ownKeyframes(key, className, options) {
-	getGlobalInjector().ownKeyframes(key, className, options);
-}
-/**
-* Remove every injected rule that is neither in the DOM nor held by an
-* outstanding `inject()` handle. Equivalent to `gc({ force: true })`.
-*/
-function cleanup(root) {
-	return getGlobalInjector().cleanup(root);
-}
-/**
-* Count a render, so that a collection pass is scheduled every
-* `gc.touchInterval` of them. Used internally by computeStyles and tasty().
-*
-* @deprecated The class name is ignored — collection asks the DOM what is
-* rendered rather than recording usage per class. The argument is kept so
-* existing calls still compile.
-*/
-function touch(className, options) {
-	if (!getConfig().gc) return;
-	getGlobalInjector().touch(className, options);
-}
-/**
-* Synchronous garbage collection of unused styles — those no element carries
-* and no `inject()` handle references. Evicts the oldest ones once they exceed
-* capacity. With `{ force: true }`, removes all of them regardless of capacity.
-*
-* @returns Number of styles evicted.
-*/
-function gc(options) {
-	return getGlobalInjector().gc(options);
-}
-/**
-* Get the global injector instance for debugging
-*/
-const injector = { get instance() {
-	return getGlobalInjector();
-} };
-/**
-* Destroy all resources and clean up
-*/
-function destroy(root) {
-	return getGlobalInjector().destroy(root);
-}
-/**
-* Create a new isolated injector instance
-*/
-function createInjector(config = {}) {
-	return new StyleInjector({
-		...getConfig(),
-		forceTextInjection: config.forceTextInjection ?? isTestEnvironment(),
-		...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;
-/**
-* Register the collector getter in the current module graph only.
-* Used by Next.js TastyRegistry.
-*/
-function registerSSRCollectorGetter(fn) {
-	_getSSRCollector = fn;
-}
-/**
-* Register the collector getter on globalThis so it is visible across
-* separate module graphs (e.g. Astro middleware ↔ page components).
-*/
-function registerSSRCollectorGetterGlobal(fn) {
-	globalThis[GETTER_KEY] = fn;
-}
-/**
-* Retrieve the SSR collector: module-level first, globalThis fallback.
-*/
-function getRegisteredSSRCollector() {
-	if (_getSSRCollector) return _getSSRCollector();
-	const getter = globalThis[GETTER_KEY];
-	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
-*/
-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;
-}
-//#endregion
-//#region src/utils/cache-wrapper.ts
-/**
-* Create a function that caches the result with LRU eviction.
-*/
-function cacheWrapper(handler, limit = 1e3) {
-	const cache = new Lru(limit);
-	return (firstArg, secondArg) => {
-		const key = typeof firstArg === "string" && secondArg == null ? firstArg : JSON.stringify([firstArg, secondArg]);
-		let result = cache.get(key);
-		if (result === void 0) {
-			result = secondArg == null ? handler(firstArg) : handler(firstArg, secondArg);
-			cache.set(key, result);
-		}
-		return result;
-	};
-}
-//#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
-* functions (`useGlobalStyles`, `useRawCSS`, `useKeyframes`, `useCounterStyle`).
-*
-* Two levels, both weak:
-*
-* - **injector** — `configure()` replaces the global injector, and every dispose
-*   handle and generated name we cache belongs to the one that produced it.
-*   Keying by injector makes stale state fall away with it, instead of letting
-*   change-detection keys suppress re-injection into the new sheets.
-* - **root** — the same selector or slot name can be used in several shadow
-*   roots, and each holds its own injection.
-*/
-function createClientState(create) {
-	const byInjector = /* @__PURE__ */ new WeakMap();
-	return (root) => {
-		const injector = getGlobalInjector();
-		let byRoot = byInjector.get(injector);
-		if (!byRoot) {
-			byRoot = /* @__PURE__ */ new WeakMap();
-			byInjector.set(injector, byRoot);
-		}
-		let state = byRoot.get(root);
-		if (!state) {
-			state = create();
-			byRoot.set(root, state);
-		}
-		return state;
-	};
-}
-//#endregion
-//#region src/utils/deps-equal.ts
-/**
-* Shallow comparison of two dependency arrays using Object.is semantics.
-* Returns true when both arrays have the same length and every element
-* at the same index is identical.
-*/
-function depsEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
-	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 };
-
-//# sourceMappingURL=runtime-engine-Y00VWjrS.js.map