@tenphi/tasty 3.7.0 → 3.9.0

package/dist/chunks/runtime-engine-DvnE2g-E.js

@@ -0,0 +1,2437 @@
+import { f as parseStyle, j as normalizeDslName, m as resetGlobalPredefinedTokens, p as resetGlobalParseFunctions, u as normalizeColorTokenValue, w as Lru } from "./dsl-C5yuAn41.js";
+import { i as warn, n as isSelector, o as isDevEnv, r as resetStyleWarnings } from "./shared-utils-DWA4LjIa.js";
+import { A as validateNamePrefix, B as formatFunctionPrelude, D as makeKeyframeName, F as normalizePropertyDefinition, G as registerLocalFunctionPolyfills, I as parsePropertyToken, K as resetFunctionPolyfills, M as extractLocalProperties, N as getEffectiveDefinition, O as rscClassRegexGlobal, R as extractLocalFunctions, S as PropertyTypeResolver, T as makeClassName, U as parseFunctionName, V as formatFunctionRule, _ as extractLocalFontFace, a as formatPropertyCSS, b as formatFontFaceRule, c as filterUsedKeyframes, d as replaceAnimationNames, f as resolveKeyframesNames, h as formatCounterStyleRule, i as formatKeyframesCSS, j as hashString, k as tastyClassRegex, l as hasLocalKeyframes, m as formatCounterStyleDeclarations, o as extractAnimationNamesFromStyles, p as extractLocalCounterStyle, r as formatRules, s as extractLocalKeyframes, u as mergeKeyframes, v as fontFaceContentHash, y as formatFontFaceDeclarations, z as formatFunctionDeclarations } from "./css-definitions-D_it4XZH.js";
+import { C as STYLE_HANDLER_MAP, D as resetHandlers, G as resetGlobalPolyfillsState, H as hasStylesGenerated, K as resetStylesGeneratedState, R as resetStyleChunks, S as camelToKebab, U as isFunctionsPolyfillEnabled, W as markStylesGeneratedState, a as registerBaseStyleProps, b as renderStyles, k as createStyle, n as generateChunkCacheKey, o as resetBaseStyleProps, r as categorizeStyleKeys, t as renderStylesForChunk, y as clearPipelineCache } from "./style-engine-C1ECBZxR.js";
+import { n as applyStyleConfig, r as normalizeConfig, t as resolveRecipesWith } from "./config-engine-C3pF9EK9.js";
+import { _ as resetConfigResources, a as getGlobalConfigTokens, c as getGlobalFunctions, d as mergeGlobalConfigTokens, f as mergeGlobalCounterStyles, g as mergeGlobalStyles, h as mergeGlobalProperties, i as getEffectiveProperties, l as getGlobalStyles, m as mergeGlobalFunctions, o as getGlobalCounterStyles, p as mergeGlobalFontFaces, s as getGlobalFontFaces, t as getRegisteredSSRCollector, v as setRuntimeConfigState } from "./runtime-state-BTDqSYBk.js";
+import { cache } from "react";
+//#region src/prop-handlers.ts
+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].`);
+}
+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;
+	};
+}
+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);
+}
+function resetPropHandlers() {
+	if (propHandlerRegistry.list.length === 0) return;
+	propHandlerRegistry.list.length = 0;
+	propHandlerRegistry.apply = null;
+}
+//#endregion
+//#region src/injector/batch.ts
+let queue = [];
+let head = 0;
+let microtaskScheduled = false;
+let flushing = false;
+let windowOpen = false;
+let everOpened = false;
+let warnedNoProvider = false;
+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;
+}
+function hasPendingStyleWrites() {
+	return head < queue.length;
+}
+function openBatchWindow() {
+	if (typeof document === "undefined") return;
+	windowOpen = true;
+	everOpened = true;
+}
+function closeBatchWindow() {
+	windowOpen = false;
+	flushStyles();
+}
+function isBatchWindowOpen() {
+	return windowOpen;
+}
+function scheduleMicrotaskFlush() {
+	if (microtaskScheduled || flushing) return;
+	microtaskScheduled = true;
+	queueMicrotask(() => {
+		microtaskScheduled = false;
+		windowOpen = false;
+		flushStyles();
+	});
+}
+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;
+	}
+}
+function warnBatchProviderMissing() {
+	if (everOpened || warnedNoProvider || !isDevEnv()) return;
+	warnedNoProvider = true;
+	warn("[Tasty] batchInjection needs <TastyBatchProvider> mounted to batch.");
+}
+function resetStyleBatch() {
+	queue = [];
+	head = 0;
+	microtaskScheduled = false;
+	flushing = false;
+	windowOpen = false;
+	everOpened = false;
+	warnedNoProvider = false;
+}
+//#endregion
+//#region src/injector/sheet-manager.ts
+const supportsConstructableSheets = typeof CSSStyleSheet !== "undefined" && (() => {
+	try {
+		new CSSStyleSheet();
+		return true;
+	} catch {
+		return false;
+	}
+})();
+function wrapAtRules(css, atRules) {
+	return atRules?.reduce((wrapped, atRule) => `${atRule} { ${wrapped} }`, css) ?? css;
+}
+function splitSelectorsSafely(selectorList) {
+	const parts = [];
+	let buffer = "";
+	let squareDepth = 0;
+	let parenDepth = 0;
+	let quote = "";
+	for (let i = 0; i < selectorList.length; i++) {
+		const char = selectorList[i];
+		if (quote) {
+			if (char === quote && selectorList[i - 1] !== "\\") quote = "";
+			buffer += char;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			buffer += char;
+			continue;
+		}
+		if (char === "[") squareDepth++;
+		else if (char === "]") squareDepth = Math.max(0, squareDepth - 1);
+		else if (char === "(") parenDepth++;
+		else if (char === ")") parenDepth = Math.max(0, parenDepth - 1);
+		if (char === "," && squareDepth === 0 && parenDepth === 0) {
+			const part = buffer.trim();
+			if (part) parts.push(part);
+			buffer = "";
+		} else buffer += char;
+	}
+	const tail = buffer.trim();
+	if (tail) parts.push(tail);
+	return parts;
+}
+function rulesToCSS(sheet) {
+	return Array.from(sheet.cssRules, (rule) => rule.cssText).join("\n");
+}
+function rawBlocksToCSS(blocks) {
+	return [...blocks.values()].sort((a, b) => a.startOffset - b.startOffset).map((block) => block.css).join("\n");
+}
+var SheetManager = class {
+	rootRegistries = /* @__PURE__ */ new WeakMap();
+	activeRoots = /* @__PURE__ */ new Set();
+	config;
+	rawStyleElements = /* @__PURE__ */ new WeakMap();
+	rawConstructableSheets = /* @__PURE__ */ new WeakMap();
+	rawCSSBlocks = /* @__PURE__ */ new WeakMap();
+	rawCSSCounter = 0;
+	constructor(config) {
+		this.config = config;
+	}
+	getCSSSheet(sheetInfo) {
+		if (sheetInfo.constructableSheet) return sheetInfo.constructableSheet;
+		return sheetInfo.sheet?.sheet ?? null;
+	}
+	trackTextRule(sheet, ruleIndex, ruleText) {
+		if (!sheet.textMode) return;
+		const rules = sheet.textRules ??= [];
+		while (rules.length < ruleIndex) rules.push("");
+		rules[ruleIndex] = ruleText;
+	}
+	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;
+	}
+	detectInjectionMode(root) {
+		if (root instanceof ShadowRoot && supportsConstructableSheets && !this.config.forceTextInjection) return "adopted";
+		return "style-element";
+	}
+	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;
+	}
+	getActiveRoots() {
+		return this.activeRoots;
+	}
+	hasActiveRoots() {
+		return this.activeRoots.size > 0;
+	}
+	pruneDisconnectedRoots() {
+		for (const root of this.activeRoots) if (root !== document && !root.host?.isConnected) this.cleanup(root);
+	}
+	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;
+	}
+	createStyleElement(root, attribute = "data-tasty") {
+		const style = root.createElement?.("style") || document.createElement("style");
+		if (this.config.nonce) style.nonce = this.config.nonce;
+		style.setAttribute(attribute, "");
+		("head" in root && root.head ? root.head : root).appendChild(style);
+		if (attribute === "data-tasty" && !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;
+	}
+	appendTextRule(sheet, ruleIndex, ruleText) {
+		this.trackTextRule(sheet, ruleIndex, ruleText);
+		const style = sheet.sheet;
+		style.textContent = (style.textContent || "") + "\n" + ruleText;
+	}
+	insertRule(registry, flattenedRules, className, root) {
+		let targetSheet = this.findAvailableSheet(registry);
+		if (!targetSheet) targetSheet = this.createSheet(registry, root);
+		const sheetIndex = registry.sheets.indexOf(targetSheet);
+		try {
+			const groupedRules = /* @__PURE__ */ new Map();
+			for (const rule of flattenedRules) {
+				const key = `${rule.atRules?.join("|") ?? ""}||${rule.selector}||${rule.startingStyle ? "1" : "0"}`;
+				const existing = groupedRules.get(key);
+				if (existing) existing.declarations = existing.declarations ? `${existing.declarations} ${rule.declarations}` : rule.declarations;
+				else groupedRules.set(key, {
+					selector: rule.selector,
+					atRules: rule.atRules,
+					startingStyle: rule.startingStyle,
+					declarations: rule.declarations
+				});
+			}
+			const insertedRuleTexts = [];
+			const insertedIndices = [];
+			let currentRuleIndex = this.findAvailableRuleIndex(targetSheet);
+			let firstInsertedIndex = null;
+			let lastInsertedIndex = null;
+			const recordInsertion = (index) => {
+				targetSheet.ruleCount++;
+				insertedIndices.push(index);
+				if (firstInsertedIndex == null) firstInsertedIndex = index;
+				lastInsertedIndex = index;
+				currentRuleIndex = index + 1;
+			};
+			for (const rule of groupedRules.values()) {
+				const declarations = rule.declarations;
+				const innerContent = rule.startingStyle ? `@starting-style { ${declarations} }` : declarations;
+				const fullRule = wrapAtRules(`${rule.selector} { ${innerContent} }`, rule.atRules);
+				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);
+					try {
+						styleSheet.insertRule(fullRule, safeIndex);
+						recordInsertion(safeIndex);
+					} catch (e) {
+						const selectors = splitSelectorsSafely(rule.selector);
+						if (selectors.length > 1) for (const sel of selectors) {
+							const singleRule = wrapAtRules(`${sel} { ${declarations} }`, rule.atRules);
+							try {
+								const maxIdx = styleSheet.cssRules.length;
+								const atomicIdx = this.findAvailableRuleIndex(targetSheet);
+								const idx = Math.min(Math.max(0, atomicIdx), maxIdx);
+								styleSheet.insertRule(singleRule, idx);
+								recordInsertion(idx);
+							} catch (singleErr) {
+								console.warn("[Tasty] Browser rejected CSS rule:", singleRule, singleErr);
+							}
+						}
+						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.appendTextRule(targetSheet, atomicRuleIndex, fullRule);
+					recordInsertion(atomicRuleIndex);
+				}
+				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;
+		}
+	}
+	insertGlobalRule(registry, flattenedRules, globalKey, root) {
+		const ruleInfo = this.insertRule(registry, flattenedRules, globalKey, root);
+		if (ruleInfo) registry.globalRules.set(globalKey, ruleInfo);
+		return ruleInfo;
+	}
+	deleteGlobalRule(registry, globalKey) {
+		const ruleInfo = registry.globalRules.get(globalKey);
+		if (!ruleInfo) return;
+		this.deleteRule(registry, ruleInfo);
+		registry.globalRules.delete(globalKey);
+	}
+	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 {}
+	}
+	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);
+			const indices = ruleInfo.indices;
+			if (sheet.textMode) {
+				let targetIndices;
+				if (indices?.length) targetIndices = 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 (indices?.length) {
+					const sortedIndices = [...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);
+		}
+	}
+	findAvailableSheet(registry) {
+		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;
+	}
+	findAvailableRuleIndex(sheet) {
+		return sheet.ruleCount;
+	}
+	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;
+	}
+	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 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;
+			}
+			const rules = rulesBySheet.get(sheetIndex);
+			if (rules) rules.push({
+				className,
+				ruleInfo
+			});
+			else rulesBySheet.set(sheetIndex, [{
+				className,
+				ruleInfo
+			}]);
+		}
+		for (const rulesInSheet of rulesBySheet.values()) {
+			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);
+			}
+		}
+		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 += deleted.size;
+			registry.metrics.cleanupHistory.push({
+				timestamp: cleanupStartTime,
+				classesDeleted: deleted.size,
+				cssSize: totalCssSize,
+				rulesDeleted: totalRulesDeleted
+			});
+		}
+		return deleted.size;
+	}
+	getTotalRuleCount(registry) {
+		return registry.sheets.reduce((total, sheet) => total + sheet.ruleCount - sheet.holes.length, 0);
+	}
+	readSheetCSS(sheetInfo) {
+		try {
+			if (sheetInfo.sheet?.textContent) return sheetInfo.sheet.textContent;
+			const sheet = this.getCSSSheet(sheetInfo);
+			if (sheet) return rulesToCSS(sheet);
+		} catch (error) {
+			console.warn("[Tasty] Failed to read CSS from sheet:", error);
+		}
+		return null;
+	}
+	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");
+	}
+	getMetrics(registry) {
+		if (!registry.metrics) return null;
+		return {
+			...registry.metrics,
+			unusedHits: 0
+		};
+	}
+	resetMetrics(registry) {
+		if (registry.metrics) registry.metrics = {
+			hits: 0,
+			misses: 0,
+			bulkCleanups: 0,
+			totalInsertions: 0,
+			totalUnused: 0,
+			stylesCleanedUp: 0,
+			cleanupHistory: [],
+			startTime: Date.now()
+		};
+	}
+	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("; ")
+		};
+	}
+	insertKeyframes(registry, steps, name, root) {
+		let targetSheet = this.findAvailableSheet(registry);
+		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.appendTextRule(targetSheet, ruleIndex, 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;
+		}
+	}
+	deleteKeyframes(registry, info) {
+		const sheet = registry.sheets[info.sheetIndex];
+		if (!sheet) return;
+		try {
+			const styleSheet = this.getCSSSheet(sheet);
+			if (sheet.textMode) {
+				if (!this.deleteTextRules(sheet, [info.ruleIndex]).length) return;
+			} else {
+				if (!styleSheet || info.ruleIndex < 0 || info.ruleIndex >= styleSheet.cssRules.length) return;
+				styleSheet.deleteRule(info.ruleIndex);
+			}
+			sheet.ruleCount = Math.max(0, sheet.ruleCount - 1);
+			this.adjustIndicesAfterDeletion(registry, info.sheetIndex, info.ruleIndex, info.ruleIndex, 1, null, [info.ruleIndex]);
+		} catch (error) {
+			console.warn("[Tasty] Failed to delete keyframes:", error);
+		}
+	}
+	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);
+	}
+	isAdoptedMode(root) {
+		const registry = this.rootRegistries.get(root);
+		if (registry) return registry.injectionMode === "adopted";
+		return this.detectInjectionMode(root) === "adopted";
+	}
+	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;
+	}
+	getOrCreateRawStyleElement(root) {
+		let styleElement = this.rawStyleElements.get(root);
+		if (!styleElement) {
+			styleElement = this.createStyleElement(root, "data-tasty-raw");
+			this.rawStyleElements.set(root, styleElement);
+			this.rawCSSBlocks.set(root, /* @__PURE__ */ new Map());
+		}
+		return styleElement;
+	}
+	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);
+		} else {
+			const styleElement = this.getOrCreateRawStyleElement(root);
+			const blocksMap = this.rawCSSBlocks.get(root);
+			const currentContent = styleElement.textContent || "";
+			const cssWithNewline = (currentContent ? "\n" : "") + css;
+			styleElement.textContent = currentContent + cssWithNewline;
+			blocksMap.set(id, {
+				id,
+				css,
+				startOffset: currentContent.length,
+				endOffset: currentContent.length + cssWithNewline.length
+			});
+		}
+		return { dispose: () => {
+			this.disposeRawCSS(id, root);
+		} };
+	}
+	rebuildRawAdoptedSheet(root) {
+		const sheet = this.rawConstructableSheets.get(root);
+		const blocksMap = this.rawCSSBlocks.get(root);
+		if (!sheet || !blocksMap) return;
+		sheet.replaceSync(rawBlocksToCSS(blocksMap));
+	}
+	disposeRawCSS(id, root) {
+		const blocksMap = this.rawCSSBlocks.get(root);
+		if (!blocksMap?.delete(id)) return;
+		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;
+			}
+		}
+	}
+	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;
+	}
+	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 "";
+			return rawBlocksToCSS(blocksMap);
+		}
+		return this.rawStyleElements.get(root)?.textContent || "";
+	}
+};
+//#endregion
+//#region src/injector/injector.ts
+const DEFAULT_GC_GRACE = 1e4;
+const noop = () => {};
+const EMPTY_KEYFRAMES_INFO = {
+	name: "",
+	ruleIndex: -3,
+	sheetIndex: -3
+};
+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);
+}
+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;
+	cancelPendingGC = null;
+	namePrefix;
+	classRegex;
+	rscClassRegex;
+	get _sheetManager() {
+		return this.sheetManager;
+	}
+	inferProperties(registry, rules, root) {
+		if (this.config.autoPropertyTypes === false) return;
+		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
+				});
+			});
+		}
+	}
+	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;
+	}
+	writeSheet(task) {
+		if (this.batching) return enqueueStyleWrite(task);
+		task();
+		return null;
+	}
+	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);
+	}
+	generateClassName(cacheKey) {
+		return makeClassName(this.namePrefix, hashString(cacheKey));
+	}
+	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;
+	}
+	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(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 = () => {
+			this.inferProperties(registry, rulesToInsert, 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
+		};
+	}
+	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 = () => {
+			this.inferProperties(registry, rules, 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);
+		} };
+	}
+	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();
+		} };
+	}
+	getRawCSSText(options) {
+		flushStyles();
+		const root = options?.root || document;
+		return this.sheetManager.getRawCSSText(root);
+	}
+	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;
+	}
+	ownKeyframes(key, className, options) {
+		this.sheetManager.getRegistry(options?.root || document).localKeyframes.get(key)?.owners.add(className);
+	}
+	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)
+		};
+	}
+	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++;
+	}
+	cleanup(root) {
+		this.gc({
+			root,
+			force: true
+		});
+	}
+	getCSSText(options) {
+		flushStyles();
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		return this.sheetManager.getCSSText(registry);
+	}
+	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");
+	}
+	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;
+	}
+	resetMetrics(options) {
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		this.sheetManager.resetMetrics(registry);
+	}
+	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);
+	}
+	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);
+	}
+	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);
+	}
+	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);
+		});
+	}
+	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);
+		});
+	}
+	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);
+		});
+	}
+	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)
+		};
+	}
+	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++;
+			}
+		}
+	}
+	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();
+		}
+	}
+	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);
+		}
+	}
+	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;
+	}
+	getUnusedClasses(options) {
+		flushStyles();
+		if (typeof document === "undefined") return [];
+		const root = options?.root || document;
+		const registry = this.sheetManager.getRegistry(root);
+		return this.collectUnused(registry, root);
+	}
+	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(root) {
+		flushStyles();
+		const targetRoot = root || document;
+		this.sheetManager.cleanup(targetRoot);
+		if (this.cancelPendingGC && !this.sheetManager.hasActiveRoots()) {
+			this.cancelPendingGC();
+			this.cancelPendingGC = null;
+		}
+	}
+};
+//#endregion
+//#region src/config.ts
+const emittedWarnings = /* @__PURE__ */ new Set();
+const devMode = isDevEnv();
+function warnOnce(key, message) {
+	if (devMode && !emittedWarnings.has(key)) {
+		emittedWarnings.add(key);
+		console.warn(message);
+	}
+}
+let currentConfig = null;
+let globalKeyframes = null;
+let globalRecipes = null;
+const GLOBAL_INJECTOR_KEY = "__TASTY_GLOBAL_INJECTOR__";
+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;
+}
+function createDefaultConfig(isTest) {
+	return {
+		maxRulesPerSheet: 8192,
+		forceTextInjection: isTest ?? false,
+		devMode: isDevEnv(),
+		namePrefix: "t"
+	};
+}
+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();
+	const globalFontFaces = getGlobalFontFaces();
+	const globalCounterStyles = getGlobalCounterStyles();
+	const globalFunctions = getGlobalFunctions();
+	const globalTokens = getGlobalConfigTokens();
+	const configuredGlobalStyles = getGlobalStyles();
+	for (const [token, definition] of Object.entries(getEffectiveProperties())) injector.property(token, definition);
+	if (globalFontFaces && Object.keys(globalFontFaces).length > 0) for (const [family, input] of Object.entries(globalFontFaces)) {
+		const descriptors = Array.isArray(input) ? input : [input];
+		for (const desc of descriptors) injector.fontFace(family, desc);
+	}
+	if (globalCounterStyles && Object.keys(globalCounterStyles).length > 0) for (const [name, descriptors] of Object.entries(globalCounterStyles)) injector.counterStyle(name, descriptors, { weak: true });
+	if (globalFunctions && Object.keys(globalFunctions).length > 0) for (const [name, definition] of Object.entries(globalFunctions)) injector.func(name, definition, { weak: true });
+	if (globalTokens && Object.keys(globalTokens).length > 0) {
+		const tokenRules = renderStyles(globalTokens, ":root");
+		if (tokenRules.length > 0) injector.injectGlobal(tokenRules);
+	}
+	if (configuredGlobalStyles) {
+		for (const [selector, styles] of Object.entries(configuredGlobalStyles)) if (Object.keys(styles).length > 0) {
+			const rules = renderStyles(styles, selector);
+			if (rules.length > 0) injector.injectGlobal(rules);
+		}
+	}
+}
+let _hasGlobalKeyframes = false;
+function hasGlobalKeyframes() {
+	return _hasGlobalKeyframes;
+}
+function getGlobalKeyframes() {
+	return globalKeyframes;
+}
+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;
+}
+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;
+	}
+	mergeGlobalProperties(properties);
+}
+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;
+	}
+	mergeGlobalFontFaces(fontFace);
+}
+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;
+	}
+	mergeGlobalCounterStyles(counterStyle);
+}
+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;
+	}
+	mergeGlobalFunctions(functions);
+}
+function hasGlobalRecipes() {
+	return globalRecipes !== null && Object.keys(globalRecipes).length > 0;
+}
+function getGlobalRecipes() {
+	return globalRecipes;
+}
+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) 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
+	};
+}
+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;
+	}
+	mergeGlobalConfigTokens(styles);
+}
+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;
+	}
+	mergeGlobalStyles(styles);
+}
+function isConfigLocked() {
+	return hasStylesGenerated();
+}
+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);
+	const normalized = normalizeConfig(config);
+	const { propHandlers: mergedPropHandlers, propHandlerSources, baseStyleProps: mergedBaseStyleProps, properties: mergedProperties, keyframes: mergedKeyframes, fontFaces: mergedFontFaces, counterStyles: mergedCounterStyles, tokens: mergedConfigTokens, recipes: mergedRecipes, globalStyles: mergedGlobalStyles } = normalized;
+	const functionDefs = applyStyleConfig(config, normalized, warnOnce);
+	if (!isFunctionsPolyfillEnabled() && Object.keys(functionDefs).length > 0) setGlobalFunction(functionDefs);
+	if (Object.keys(mergedKeyframes).length > 0) setGlobalKeyframes(mergedKeyframes);
+	if (Object.keys(mergedProperties).length > 0) setGlobalProperties(mergedProperties);
+	if (Object.keys(mergedFontFaces).length > 0) setGlobalFontFace(mergedFontFaces);
+	if (Object.keys(mergedCounterStyles).length > 0) setGlobalCounterStyle(mergedCounterStyles);
+	if (Object.keys(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(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;
+	setRuntimeConfigState(fullConfig);
+	const storage = typeof window !== "undefined" ? window : globalThis;
+	storage[GLOBAL_INJECTOR_KEY] = new StyleInjector(fullConfig);
+}
+function getConfig() {
+	if (currentConfig) return currentConfig;
+	const defaultConfig = createDefaultConfig(isTestEnvironment());
+	currentConfig = defaultConfig;
+	setRuntimeConfigState(defaultConfig);
+	return defaultConfig;
+}
+function getNamePrefix() {
+	return currentConfig?.namePrefix ?? "t";
+}
+function getGlobalInjector() {
+	const storage = typeof window !== "undefined" ? window : globalThis;
+	if (!storage[GLOBAL_INJECTOR_KEY]) configure();
+	return storage[GLOBAL_INJECTOR_KEY];
+}
+function resetConfig() {
+	resetStylesGeneratedState();
+	currentConfig = null;
+	globalKeyframes = null;
+	_hasGlobalKeyframes = false;
+	resetGlobalPolyfillsState();
+	globalRecipes = null;
+	resetConfigResources();
+	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
+var ChunkSheetRegistry = class {
+	sheets = /* @__PURE__ */ new Map();
+	sheetToHash = /* @__PURE__ */ new WeakMap();
+	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;
+	}
+	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);
+		}
+	}
+	acquireAll(cssTexts) {
+		return cssTexts.map((text) => this.acquire(text));
+	}
+	releaseAll(sheets) {
+		for (const sheet of sheets) this.release(sheet);
+	}
+	get size() {
+		return this.sheets.size;
+	}
+};
+const chunkSheetRegistry = new ChunkSheetRegistry();
+//#endregion
+//#region src/injector/index.ts
+function inject(rules, options) {
+	const injector = getGlobalInjector();
+	markStylesGenerated();
+	return injector.inject(rules, options);
+}
+function injectGlobal(rules, options) {
+	return getGlobalInjector().injectGlobal(rules, options);
+}
+function injectRawCSS(css, options) {
+	return getGlobalInjector().injectRawCSS(css, options);
+}
+function getRawCSSText(options) {
+	return getGlobalInjector().getRawCSSText(options);
+}
+function keyframes(steps, nameOrOptions) {
+	return getGlobalInjector().keyframes(steps, nameOrOptions);
+}
+function property(name, options) {
+	return getGlobalInjector().property(name, options);
+}
+function isPropertyDefined(name, options) {
+	return getGlobalInjector().isPropertyDefined(name, options);
+}
+function fontFace(family, descriptors, options) {
+	return getGlobalInjector().fontFace(family, descriptors, options);
+}
+function counterStyle(name, descriptors, options) {
+	return getGlobalInjector().counterStyle(name, descriptors, options);
+}
+function func(name, definition, options) {
+	return getGlobalInjector().func(name, definition, options);
+}
+function getCSSText(options) {
+	return getGlobalInjector().getCSSText(options);
+}
+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);
+}
+function holdKeyframes(steps, names, options) {
+	return getGlobalInjector().holdKeyframes(steps, names, options);
+}
+function ownKeyframes(key, className, options) {
+	getGlobalInjector().ownKeyframes(key, className, options);
+}
+function cleanup(root) {
+	return getGlobalInjector().cleanup(root);
+}
+function touch(className, options) {
+	if (!getConfig().gc) return;
+	getGlobalInjector().touch(className, options);
+}
+function gc(options) {
+	return getGlobalInjector().gc(options);
+}
+const injector = { get instance() {
+	return getGlobalInjector();
+} };
+function destroy(root) {
+	return getGlobalInjector().destroy(root);
+}
+function createInjector(config = {}) {
+	return new StyleInjector({
+		...getConfig(),
+		forceTextInjection: config.forceTextInjection ?? isTestEnvironment(),
+		...config
+	});
+}
+//#endregion
+//#region src/rsc-cache.ts
+const getRSCCache = cache(() => ({
+	cacheKeyToClassName: /* @__PURE__ */ new Map(),
+	emittedKeys: /* @__PURE__ */ new Set(),
+	internalsEmitted: false,
+	pendingCSS: [],
+	keyToIndex: /* @__PURE__ */ new Map(),
+	generatedNames: /* @__PURE__ */ new Map()
+}));
+function rscAllocateClassName(rscCache, cacheKey) {
+	const existing = rscCache.cacheKeyToClassName.get(cacheKey);
+	if (existing) return {
+		className: existing,
+		isNew: false
+	};
+	const className = makeClassName(getNamePrefix(), hashString(cacheKey));
+	rscCache.cacheKeyToClassName.set(cacheKey, className);
+	return {
+		className,
+		isNew: true
+	};
+}
+function flushPendingCSS(rscCache) {
+	if (rscCache.pendingCSS.length === 0) return "";
+	const css = rscCache.pendingCSS.join("\n");
+	rscCache.pendingCSS.length = 0;
+	rscCache.keyToIndex.clear();
+	return css;
+}
+function pushRSCCSS(rscCache, key, css, replace) {
+	if (replace) {
+		const pendingIndex = rscCache.keyToIndex.get(key);
+		if (pendingIndex !== void 0) {
+			rscCache.pendingCSS[pendingIndex] = css;
+			return true;
+		}
+	} else if (rscCache.emittedKeys.has(key)) return false;
+	rscCache.emittedKeys.add(key);
+	rscCache.keyToIndex.set(key, rscCache.pendingCSS.length);
+	rscCache.pendingCSS.push(css);
+	return true;
+}
+function getStyleTarget() {
+	const collector = getRegisteredSSRCollector();
+	if (collector) return {
+		mode: "ssr",
+		collector
+	};
+	if (typeof document === "undefined") return {
+		mode: "rsc",
+		cache: getRSCCache()
+	};
+	return { mode: "client" };
+}
+//#endregion
+//#region src/ssr/collect-auto-properties.ts
+function scanAndEmitAutoProperties(rules, styles, emit) {
+	const registered = /* @__PURE__ */ new Set();
+	if (styles) {
+		const localProps = styles["@property"];
+		if (localProps && typeof localProps === "object") for (const token of Object.keys(localProps)) {
+			const parsed = parsePropertyToken(token);
+			if (parsed.isValid) registered.add(parsed.cssName);
+		}
+	}
+	const resolver = new PropertyTypeResolver();
+	for (const rule of rules) {
+		if (!rule.declarations) continue;
+		resolver.scanDeclarations(rule.declarations, (name) => registered.has(name), (name, syntax, initialValue) => {
+			registered.add(name);
+			const css = formatPropertyCSS(name, {
+				syntax,
+				inherits: true,
+				initialValue
+			});
+			if (css) emit(name, css);
+		});
+	}
+}
+function collectAutoInferredProperties(rules, collector, styles) {
+	scanAndEmitAutoProperties(rules, styles, (name, css) => {
+		collector.collectProperty(`__auto:${name}`, css);
+	});
+}
+function collectAutoInferredPropertiesRSC(rules, rscCache, styles) {
+	scanAndEmitAutoProperties(rules, styles, (name, css) => {
+		pushRSCCSS(rscCache, `__auto:${name}`, css);
+	});
+}
+//#endregion
+//#region src/utils/has-keys.ts
+function hasKeys(obj) {
+	for (const _ in obj) return true;
+	return false;
+}
+//#endregion
+//#region src/utils/resolve-recipes.ts
+function resolveRecipes(styles) {
+	return resolveRecipesWith(styles, getGlobalRecipes());
+}
+//#endregion
+//#region src/compute-styles.ts
+const EMPTY_RESULT = { className: "" };
+function collectAncillaryRSC(rscCache, styles, usedKf, keyframeNames) {
+	const parts = [];
+	if (usedKf && keyframeNames) for (const [authored, steps] of Object.entries(usedKf)) {
+		const name = keyframeNames.get(authored);
+		const key = `__kf:${name}`;
+		if (!rscCache.emittedKeys.has(key)) {
+			rscCache.emittedKeys.add(key);
+			parts.push(formatKeyframesCSS(name, steps));
+		}
+	}
+	const localProperties = extractLocalProperties(styles);
+	if (localProperties) for (const [token, definition] of Object.entries(localProperties)) {
+		const key = `__prop:${token}`;
+		if (!rscCache.emittedKeys.has(key)) {
+			rscCache.emittedKeys.add(key);
+			const css = formatPropertyCSS(token, definition);
+			if (css) parts.push(css);
+		}
+	}
+	const localFontFace = extractLocalFontFace(styles);
+	if (localFontFace) for (const [family, input] of Object.entries(localFontFace)) {
+		const descriptors = Array.isArray(input) ? input : [input];
+		for (const desc of descriptors) {
+			const key = `__ff:${fontFaceContentHash(family, desc)}`;
+			if (!rscCache.emittedKeys.has(key)) {
+				rscCache.emittedKeys.add(key);
+				parts.push(formatFontFaceRule(family, desc));
+			}
+		}
+	}
+	const localCounterStyle = extractLocalCounterStyle(styles);
+	if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) {
+		const key = `__cs:${name}:${JSON.stringify(descriptors)}`;
+		if (!rscCache.emittedKeys.has(key)) {
+			rscCache.emittedKeys.add(key);
+			parts.push(formatCounterStyleRule(name, descriptors));
+		}
+	}
+	if (!isFunctionsPolyfillEnabled()) {
+		const localFunctions = extractLocalFunctions(styles);
+		if (localFunctions) for (const [name, definition] of Object.entries(localFunctions)) {
+			const key = `__func:${parseFunctionName(name)}`;
+			if (!rscCache.emittedKeys.has(key)) {
+				rscCache.emittedKeys.add(key);
+				parts.push(formatFunctionRule(name, definition));
+			}
+		}
+	}
+	return parts.join("\n");
+}
+function computeStylesRSC(styles, chunkMap, stableStyles) {
+	const rscCache = getRSCCache();
+	const cssParts = [];
+	const classNames = [];
+	const rscUsedKf = getUsedKeyframes(styles);
+	const rscKeyframeNames = rscUsedKf ? resolveKeyframesNames(rscUsedKf) : null;
+	const pendingCSS = flushPendingCSS(rscCache);
+	if (pendingCSS) cssParts.push(pendingCSS);
+	rscCache.internalsEmitted = true;
+	for (const [chunkName, chunkStyleKeys] of chunkMap) {
+		if (chunkStyleKeys.length === 0) continue;
+		const baseKey = generateChunkCacheKey(styles, chunkName, chunkStyleKeys, stableStyles);
+		const renderResult = renderStylesForChunk(styles, chunkName, chunkStyleKeys);
+		if (renderResult.rules.length === 0) continue;
+		const { rules, cacheKey } = applyKeyframeNames(renderResult.rules, baseKey, rscKeyframeNames);
+		const { className, isNew } = rscAllocateClassName(rscCache, cacheKey);
+		classNames.push(className);
+		if (isNew) {
+			const css = formatRules(rules, className);
+			if (css) cssParts.push(css);
+		}
+	}
+	const ancillaryCSS = collectAncillaryRSC(rscCache, styles, rscUsedKf, rscKeyframeNames);
+	if (ancillaryCSS) cssParts.push(ancillaryCSS);
+	if (classNames.length === 0) return EMPTY_RESULT;
+	const css = cssParts.join("\n");
+	return {
+		className: classNames.join(" "),
+		css: css || void 0
+	};
+}
+function getUsedKeyframes(styles) {
+	const hasLocal = hasLocalKeyframes(styles);
+	const hasGlobal = hasGlobalKeyframes();
+	if (!hasLocal && !hasGlobal) return null;
+	const usedNames = extractAnimationNamesFromStyles(styles);
+	if (usedNames.size === 0) return null;
+	return filterUsedKeyframes(mergeKeyframes(hasLocal ? extractLocalKeyframes(styles) : null, hasGlobal ? getGlobalKeyframes() : null), usedNames);
+}
+function processChunkSSR(collector, styles, chunkName, styleKeys, stableStyles, keyframeNames) {
+	if (styleKeys.length === 0) return null;
+	const baseKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
+	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys);
+	if (renderResult.rules.length === 0) return null;
+	const { rules, cacheKey } = applyKeyframeNames(renderResult.rules, baseKey, keyframeNames);
+	const { className, isNewAllocation } = collector.allocateClassName(cacheKey);
+	if (isNewAllocation) {
+		collector.collectChunk(cacheKey, className, rules);
+		return {
+			className,
+			rules
+		};
+	}
+	return {
+		className,
+		rules: []
+	};
+}
+function applyKeyframeNames(ruleset, baseKey, keyframeNames) {
+	if (!keyframeNames || keyframeNames.size === 0) return {
+		animations: [],
+		rules: ruleset,
+		cacheKey: baseKey
+	};
+	const usedNames = /* @__PURE__ */ new Set();
+	let rules;
+	for (let i = 0; i < ruleset.length; i++) {
+		const rule = ruleset[i];
+		const declarations = replaceAnimationNames(rule.declarations, keyframeNames, usedNames);
+		if (declarations !== rule.declarations) {
+			rules ??= ruleset.slice();
+			rules[i] = {
+				...rule,
+				declarations
+			};
+		}
+	}
+	const animations = [...keyframeNames.keys()].filter((authored) => usedNames.has(authored));
+	if (animations.length === 0) return {
+		animations,
+		rules: ruleset,
+		cacheKey: baseKey
+	};
+	const cacheKey = `${baseKey}\u0000kf:${animations.map((authored) => `${authored}=${keyframeNames.get(authored)}`).sort().join(",")}`;
+	return {
+		animations,
+		rules: rules ?? ruleset,
+		cacheKey
+	};
+}
+function processChunkSync(styles, chunkName, styleKeys, stableStyles, root, keyframeNames) {
+	if (styleKeys.length === 0) return null;
+	const cacheKey = generateChunkCacheKey(styles, chunkName, styleKeys, stableStyles);
+	const renderResult = renderStylesForChunk(styles, chunkName, styleKeys, cacheKey);
+	if (renderResult.rules.length === 0) return null;
+	const { animations, rules, cacheKey: injectKey } = applyKeyframeNames(renderResult.rules, cacheKey, keyframeNames);
+	const { className } = inject(rules, {
+		cacheKey: injectKey,
+		root,
+		pin: false
+	});
+	return {
+		className,
+		animations
+	};
+}
+function injectAncillarySync(styles, root) {
+	const localProperties = extractLocalProperties(styles);
+	if (localProperties) for (const [token, definition] of Object.entries(localProperties)) property(token, {
+		...definition,
+		root
+	});
+	const localFontFace = extractLocalFontFace(styles);
+	if (localFontFace) for (const [family, input] of Object.entries(localFontFace)) {
+		const descriptors = Array.isArray(input) ? input : [input];
+		for (const desc of descriptors) fontFace(family, desc, { root });
+	}
+	const localCounterStyle = extractLocalCounterStyle(styles);
+	if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) counterStyle(name, descriptors, { root });
+	if (!isFunctionsPolyfillEnabled()) {
+		const localFunctions = extractLocalFunctions(styles);
+		if (localFunctions) for (const [name, definition] of Object.entries(localFunctions)) func(name, definition, { root });
+	}
+}
+function collectAncillarySSR(collector, styles, chunks, usedKf, keyframeNames) {
+	if (usedKf && keyframeNames) for (const [authored, steps] of Object.entries(usedKf)) {
+		const name = keyframeNames.get(authored);
+		collector.collectKeyframes(name, formatKeyframesCSS(name, steps));
+	}
+	const localProperties = extractLocalProperties(styles);
+	if (localProperties) for (const [token, definition] of Object.entries(localProperties)) {
+		const css = formatPropertyCSS(token, definition);
+		if (css) collector.collectProperty(token, css);
+	}
+	const localFontFace = extractLocalFontFace(styles);
+	if (localFontFace) for (const [family, input] of Object.entries(localFontFace)) {
+		const descriptors = Array.isArray(input) ? input : [input];
+		for (const desc of descriptors) {
+			const hash = fontFaceContentHash(family, desc);
+			const css = formatFontFaceRule(family, desc);
+			collector.collectFontFace(hash, css);
+		}
+	}
+	const localCounterStyle = extractLocalCounterStyle(styles);
+	if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) {
+		const css = formatCounterStyleRule(name, descriptors);
+		collector.collectCounterStyle(name, css);
+	}
+	if (!isFunctionsPolyfillEnabled()) {
+		const localFunctions = extractLocalFunctions(styles);
+		if (localFunctions) for (const [name, definition] of Object.entries(localFunctions)) {
+			const css = formatFunctionRule(name, definition);
+			collector.collectFunction(parseFunctionName(name), css);
+		}
+	}
+	if (getConfig().autoPropertyTypes !== false) {
+		const allRules = chunks.flatMap((chunk) => chunk.rules ?? []);
+		if (allRules.length > 0) collectAutoInferredProperties(allRules, collector, styles);
+	}
+}
+function computeStyles(styles, options) {
+	if (!styles || !hasKeys(styles)) return EMPTY_RESULT;
+	const resolved = resolveRecipes(styles);
+	const stableStyles = options?.stableStyles === true && resolved === styles;
+	if (isFunctionsPolyfillEnabled()) registerLocalFunctionPolyfills(resolved);
+	const chunkMap = categorizeStyleKeys(resolved);
+	const collector = options?.ssrCollector !== void 0 ? options.ssrCollector : getRegisteredSSRCollector();
+	const chunks = [];
+	if (collector) {
+		collector.collectInternals();
+		const ssrKf = getUsedKeyframes(resolved);
+		const ssrKeyframeNames = ssrKf ? resolveKeyframesNames(ssrKf) : null;
+		for (const [chunkName, chunkStyleKeys] of chunkMap) {
+			const chunk = processChunkSSR(collector, resolved, chunkName, chunkStyleKeys, stableStyles, ssrKeyframeNames);
+			if (chunk) chunks.push(chunk);
+		}
+		collectAncillarySSR(collector, resolved, chunks, ssrKf, ssrKeyframeNames);
+	} else if (typeof document === "undefined") return computeStylesRSC(resolved, chunkMap, stableStyles);
+	else {
+		const root = options?.root;
+		injectAncillarySync(resolved, root);
+		const usedKf = getUsedKeyframes(resolved);
+		const keyframeNames = usedKf ? resolveKeyframesNames(usedKf) : null;
+		const keyframeKeys = usedKf && keyframeNames ? holdKeyframes(usedKf, keyframeNames, { root }) : null;
+		for (const [chunkName, chunkStyleKeys] of chunkMap) {
+			const chunk = processChunkSync(resolved, chunkName, chunkStyleKeys, stableStyles, root, keyframeNames);
+			if (chunk) chunks.push(chunk);
+		}
+		if (keyframeKeys) for (const chunk of chunks) for (const authored of chunk.animations ?? []) {
+			const key = keyframeKeys.get(authored);
+			if (key) ownKeyframes(key, chunk.className, { root });
+		}
+		for (const chunk of chunks) touch(chunk.className, { root });
+	}
+	if (chunks.length === 0) return EMPTY_RESULT;
+	if (chunks.length === 1) return { className: chunks[0].className };
+	return { className: chunks.map((c) => c.className).join(" ") };
+}
+//#endregion
+//#region src/utils/filter-base-props.ts
+const BasePropNames = new Set([
+	"role",
+	"as",
+	"element",
+	"css",
+	"qa",
+	"mods",
+	"qaVal",
+	"hidden",
+	"isHidden",
+	"disabled",
+	"isDisabled",
+	"children",
+	"style",
+	"className",
+	"href",
+	"target",
+	"tabIndex"
+]);
+const eventRe = /^on[A-Z].+$/;
+const ignoredEventProps = new Set([
+	"onPress",
+	"onHoverStart",
+	"onHoverEnd",
+	"onPressStart",
+	"onPressEnd"
+]);
+function filterBaseProps(props, opts = {}) {
+	const { propNames, eventProps } = opts;
+	const filteredProps = {};
+	for (const prop of Object.keys(props)) if (prop === "id" || BasePropNames.has(prop) || prop.startsWith("aria-") || eventProps && eventRe.test(prop) && !ignoredEventProps.has(prop) || propNames?.has(prop) || prop.startsWith("data-")) filteredProps[prop] = props[prop];
+	return filteredProps;
+}
+//#endregion
+//#region src/utils/mod-attrs.ts
+const cache$1 = new Lru();
+function modAttrs(map) {
+	if (!map) return null;
+	const cacheKey = JSON.stringify(map);
+	const cached = cache$1.get(cacheKey);
+	if (cached) return cached;
+	const attrs = {};
+	for (const key of Object.keys(map)) {
+		const value = map[key];
+		if (value == null || value === false) continue;
+		const attrName = `data-${camelToKebab(key)}`;
+		if (value === true) attrs[attrName] = "";
+		else if (typeof value === "string") attrs[attrName] = value;
+		else if (typeof value === "number") attrs[attrName] = String(value);
+		else console.warn(`[Tasty] Invalid mod value for "${key}". Expected boolean, string, or number, got ${typeof value}`);
+	}
+	cache$1.set(cacheKey, attrs);
+	return attrs;
+}
+//#endregion
+//#region src/utils/process-tokens.ts
+function isValidTokenValue(value) {
+	if (value === void 0 || value === null || value === false) return false;
+	if (typeof value === "object") {
+		console.warn("[Tasty] Object values are not allowed in tokens prop. Tokens do not support state-based styling. Use a primitive value instead.");
+		return false;
+	}
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function processTokenValue(value) {
+	if (typeof value === "number") {
+		if (value === 0) return "0";
+		return parseStyle(String(value)).output;
+	}
+	return parseStyle(value).output;
+}
+function resolveTokenEntry(key, value) {
+	const name = `--${normalizeDslName(key.slice(1))}`;
+	if (key[0] === "$") return [name, processTokenValue(value === true ? "" : value)];
+	const colorValue = normalizeColorTokenValue(value);
+	if (colorValue === null) return null;
+	return [`${name}-color`, processTokenValue(colorValue)];
+}
+function processTokens(tokens) {
+	if (!tokens) return;
+	const keys = Object.keys(tokens);
+	if (keys.length === 0) return;
+	let result;
+	for (const key of keys) {
+		const value = tokens[key];
+		if (!isValidTokenValue(value)) continue;
+		if (key[0] !== "$" && key[0] !== "#") continue;
+		const entry = resolveTokenEntry(key, value);
+		if (!entry) continue;
+		if (!result) result = {};
+		result[entry[0]] = entry[1];
+	}
+	return result;
+}
+//#endregion
+//#region src/utils/client-state.ts
+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
+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 { propHandlerRegistry as $, ownKeyframes as A, getNamePrefix as B, holdKeyframes as C, injector as D, injectRawCSS as E, configure as F, resetConfig as G, hasGlobalRecipes as H, getConfig as I, closeBatchWindow as J, StyleInjector as K, getGlobalInjector as L, touch as M, ChunkSheetRegistry as N, isPropertyDefined as O, chunkSheetRegistry as P, resetStyleBatch as Q, getGlobalKeyframes as R, getRawCSSText as S, injectGlobal as T, isConfigLocked as U, hasGlobalKeyframes as V, isTestEnvironment as W, hasPendingStyleWrites as X, flushStyles as Y, openBatchWindow as Z, fontFace as _, filterBaseProps as a, getCSSText as b, hasKeys as c, getStyleTarget as d, pushRSCCSS as f, destroy as g, createInjector as h, modAttrs as i, property as j, keyframes as k, collectAutoInferredProperties as l, counterStyle as m, createClientState as n, computeStyles as o, cleanup as p, SheetManager as q, processTokens as r, resolveRecipes as s, depsEqual as t, collectAutoInferredPropertiesRSC as u, func as v, inject as w, getCSSTextForNode as x, gc as y, getGlobalRecipes as z };
+
+//# sourceMappingURL=runtime-engine-DvnE2g-E.js.map