@tenphi/tasty 3.8.0 → 3.9.1

package/dist/core-DoEZAHJq.js

@@ -1,1732 +0,0 @@
-import { Bt as getGlobalParseFunctions, G as StyleInjector, Gt as parseStyle, It as registerLocalFunctionPolyfills, J as hasLocalCounterStyle, K as extractLocalCounterStyle, Mt as formatFunctionRule, Nt as hasLocalFunctions, Pt as parseFunctionName, Q as hasLocalFontFace, Qt as isDevEnv, Ut as normalizeColorTokenValue, Vt as getGlobalParser, X as fontFaceContentHash, Y as extractLocalFontFace, Z as formatFontFaceRule, _ as isFunctionsPolyfillEnabled, _t as hashString, bt as hasLocalProperties, c as getGlobalInjector, en as Lru, et as STYLE_HANDLER_MAP, f as getNamePrefix, ft as makeClassName, ht as tastyClassRegex, it as PropertyTypeResolver, jt as extractLocalFunctions, l as getGlobalKeyframes, n as getConfig, ot as flushStyles, p as hasGlobalKeyframes, q as formatCounterStyleRule, rt as createStyle, sn as normalizeDslName, tn as overrideColorAlpha, v as isTestEnvironment, vt as extractLocalProperties, wt as CHUNK_NAMES, xt as parsePropertyToken, y as markStylesGenerated, z as camelToKebab } from "./config-yXpe2jAV.js";
-import { a as mergeKeyframes, c as resolveKeyframesNames, d as categorizeStyleKeys, i as hasLocalKeyframes, l as renderStylesForChunk, n as extractLocalKeyframes, o as referencesAnimation, r as filterUsedKeyframes, s as replaceAnimationNames, t as extractAnimationNamesFromStyles, u as generateChunkCacheKey } from "./keyframes-B8uPLZwx.js";
-import { t as getRegisteredSSRCollector } from "./ssr-collector-ref-COs_ioWl.js";
-import { n as formatPropertyCSS, t as formatRules } from "./format-rules-DHuG25KU.js";
-import { t as resolveRecipes } from "./resolve-recipes-BNmjANzT.js";
-import { cache } from "react";
-//#region src/utils/function-color.ts
-const RE_FUNC_NAME = /^([a-z][a-z0-9-]*)\s*\(/i;
-const RE_COLOR_OUT = /^(?:rgb|hsl|hwb|lab|lch|oklab|oklch|color)\(|^#|^var\(--/i;
-/**
-* Resolve a `name(...)` value produced by a registered custom parse function
-* into its concrete color output.
-*
-* A color function is just a `functions` entry whose output is an already
-* supported color (`rgb`, `hsl`, `#…`, `oklch`, …). This helper delegates the
-* value to the global parser (which already runs the registered parse function)
-* and returns the result only when it looks like a color. Returns `null` when
-* `str` is not a registered custom function or its output is not a color.
-*
-* This is the generic replacement for the previously hardcoded okhsl/okhst
-* conversion branches scattered across `strToRgb`, `resolveToRgbaValues`, and
-* the `#token.alpha` injection path.
-*/
-function resolveFunctionColor(str) {
-	const m = RE_FUNC_NAME.exec(str);
-	if (!m) return null;
-	const name = m[1].toLowerCase();
-	getGlobalParser();
-	if (!(name in getGlobalParseFunctions())) return null;
-	const out = getGlobalParser().process(str).output;
-	if (!out || !RE_COLOR_OUT.test(out)) return null;
-	return out;
-}
-//#endregion
-//#region src/injector/chunk-sheet-registry.ts
-/**
-* Global registry mapping CSS content hashes to shared constructable
-* CSSStyleSheet objects with reference counting.
-*
-* Multiple shadow roots adopting the same chunk share a single underlying
-* stylesheet object — parse once, adopt everywhere.
-*/
-var ChunkSheetRegistry = class {
-	sheets = /* @__PURE__ */ new Map();
-	sheetToHash = /* @__PURE__ */ new WeakMap();
-	/**
-	* Get or create a CSSStyleSheet for the given CSS text.
-	* Increments refCount. Uses content hash as the dedup key.
-	*/
-	acquire(cssText) {
-		const hash = hashString(cssText);
-		const existing = this.sheets.get(hash);
-		if (existing) {
-			existing.refCount++;
-			return existing.sheet;
-		}
-		const sheet = new CSSStyleSheet();
-		sheet.replaceSync(cssText);
-		const entry = {
-			sheet,
-			cssText,
-			refCount: 1
-		};
-		this.sheets.set(hash, entry);
-		this.sheetToHash.set(sheet, hash);
-		return sheet;
-	}
-	/**
-	* Decrement refCount for a sheet. When refCount reaches 0,
-	* the sheet is removed from the registry.
-	*/
-	release(sheet) {
-		const hash = this.sheetToHash.get(sheet);
-		if (!hash) return;
-		const entry = this.sheets.get(hash);
-		if (!entry) return;
-		entry.refCount--;
-		if (entry.refCount <= 0) {
-			this.sheets.delete(hash);
-			this.sheetToHash.delete(sheet);
-		}
-	}
-	/**
-	* Bulk acquire — returns an array of CSSStyleSheet in the same order.
-	*/
-	acquireAll(cssTexts) {
-		return cssTexts.map((text) => this.acquire(text));
-	}
-	/**
-	* Bulk release — decrements refCount for each sheet.
-	*/
-	releaseAll(sheets) {
-		for (const sheet of sheets) this.release(sheet);
-	}
-	/** Number of unique sheets currently held. */
-	get size() {
-		return this.sheets.size;
-	}
-};
-/** Module-level singleton shared across the entire application. */
-const chunkSheetRegistry = new ChunkSheetRegistry();
-//#endregion
-//#region src/injector/index.ts
-/**
-* Inject styles and return className with dispose function
-*/
-function inject(rules, options) {
-	const injector = getGlobalInjector();
-	markStylesGenerated();
-	return injector.inject(rules, options);
-}
-/**
-* Inject global rules that should not reserve tasty class names
-*/
-function injectGlobal(rules, options) {
-	return getGlobalInjector().injectGlobal(rules, options);
-}
-/**
-* Inject raw CSS text directly without parsing
-* This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.
-* The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.
-*
-* @example
-* ```tsx
-* // Inject raw CSS
-* const { dispose } = injectRawCSS(`
-*   body { margin: 0; padding: 0; }
-*   .my-class { color: red; }
-* `);
-*
-* // Later, remove the injected CSS
-* dispose();
-* ```
-*/
-function injectRawCSS(css, options) {
-	return getGlobalInjector().injectRawCSS(css, options);
-}
-/**
-* Get raw CSS text for SSR
-*/
-function getRawCSSText(options) {
-	return getGlobalInjector().getRawCSSText(options);
-}
-/**
-* Inject keyframes and return object with toString() and dispose()
-*/
-function keyframes(steps, nameOrOptions) {
-	return getGlobalInjector().keyframes(steps, nameOrOptions);
-}
-/**
-* Define a CSS @property custom property.
-* This enables advanced features like animating custom properties.
-*
-* Note: @property rules are global and persistent once defined.
-* Re-registering the same property name is a no-op.
-*
-* @param name - The custom property name (must start with --)
-* @param options - Property configuration
-*
-* @example
-* ```ts
-* // Define a color property that can be animated
-* property('--my-color', {
-*   syntax: '<color>',
-*   initialValue: 'red',
-* });
-*
-* // Define an angle property
-* property('--rotation', {
-*   syntax: '<angle>',
-*   inherits: false,
-*   initialValue: '0deg',
-* });
-* ```
-*/
-function property(name, options) {
-	return getGlobalInjector().property(name, options);
-}
-/**
-* Check if a CSS @property has already been defined
-*
-* @param name - The custom property name to check
-* @param options - Options including root
-*/
-function isPropertyDefined(name, options) {
-	return getGlobalInjector().isPropertyDefined(name, options);
-}
-/**
-* Inject a CSS @font-face rule.
-*
-* Permanent and global — no dispose or ref-counting.
-* Deduplicates by content hash (family + descriptors).
-*/
-function fontFace(family, descriptors, options) {
-	return getGlobalInjector().fontFace(family, descriptors, options);
-}
-/**
-* Inject a CSS @counter-style rule.
-*
-* Permanent and global — no dispose or ref-counting. Deduplicates by name and
-* overrides an existing rule by default. Pass `weak: true` for global
-* `configure()` definitions, which never clobber an existing rule.
-*/
-function counterStyle(name, descriptors, options) {
-	return getGlobalInjector().counterStyle(name, descriptors, options);
-}
-/**
-* Inject a CSS @function rule (custom function).
-*
-* Permanent and global — no dispose or ref-counting. Deduplicates by function
-* name and overrides an existing rule by default. Pass `weak: true` for global
-* `configure()` definitions, which never clobber an existing rule.
-*
-* @param name - The function name (`$$name`, `$name`, or `--name`)
-* @param definition - Function definition (args, returns, result, local vars)
-*
-* @example
-* ```ts
-* func('$$negative', { args: ['$value'], result: '(-1 * $value)' });
-* ```
-*/
-function func(name, definition, options) {
-	return getGlobalInjector().func(name, definition, options);
-}
-/**
-* Get CSS text from all sheets (for SSR)
-*/
-function getCSSText(options) {
-	return getGlobalInjector().getCSSText(options);
-}
-/**
-* Collect only CSS used by a rendered subtree (like jest-styled-components).
-* Pass the container returned by render(...).
-*/
-function getCSSTextForNode(node, options) {
-	const classRegex = tastyClassRegex(getNamePrefix());
-	const classSet = /* @__PURE__ */ new Set();
-	const readClasses = (el) => {
-		const cls = el.getAttribute("class");
-		if (!cls) return;
-		for (const token of cls.split(/\s+/)) if (classRegex.test(token)) classSet.add(token);
-	};
-	if (node.getAttribute) readClasses(node);
-	const elements = node.querySelectorAll ? node.querySelectorAll("[class]") : [];
-	if (elements) elements.forEach(readClasses);
-	return getGlobalInjector().getCSSTextForClasses(classSet, options);
-}
-/**
-* Take a reference on local `@keyframes` under the deterministic names the
-* caller resolved, and report which entry holds each. Pair with
-* `ownKeyframes()` once the rules exist to inspect.
-*/
-function holdKeyframes(steps, names, options) {
-	return getGlobalInjector().holdKeyframes(steps, names, options);
-}
-/**
-* Record that a class animates these keyframes, so the reference is released
-* when the last such class is collected.
-*/
-function ownKeyframes(key, className, options) {
-	getGlobalInjector().ownKeyframes(key, className, options);
-}
-/**
-* Remove every injected rule that is neither in the DOM nor held by an
-* outstanding `inject()` handle. Equivalent to `gc({ force: true })`.
-*/
-function cleanup(root) {
-	return getGlobalInjector().cleanup(root);
-}
-/**
-* Count a render, so that a collection pass is scheduled every
-* `gc.touchInterval` of them. Used internally by computeStyles and tasty().
-*
-* @deprecated The class name is ignored — collection asks the DOM what is
-* rendered rather than recording usage per class. The argument is kept so
-* existing calls still compile.
-*/
-function touch(className, options) {
-	if (!getConfig().gc) return;
-	getGlobalInjector().touch(className, options);
-}
-/**
-* Synchronous garbage collection of unused styles — those no element carries
-* and no `inject()` handle references. Evicts the oldest ones once they exceed
-* capacity. With `{ force: true }`, removes all of them regardless of capacity.
-*
-* @returns Number of styles evicted.
-*/
-function gc(options) {
-	return getGlobalInjector().gc(options);
-}
-/**
-* Get the global injector instance for debugging
-*/
-const injector = { get instance() {
-	return getGlobalInjector();
-} };
-/**
-* Destroy all resources and clean up
-*/
-function destroy(root) {
-	return getGlobalInjector().destroy(root);
-}
-/**
-* Create a new isolated injector instance
-*/
-function createInjector(config = {}) {
-	return new StyleInjector({
-		...getConfig(),
-		forceTextInjection: config.forceTextInjection ?? isTestEnvironment(),
-		...config
-	});
-}
-//#endregion
-//#region src/rsc-cache.ts
-/**
-* Shared RSC (React Server Components) inline style cache.
-*
-* Uses React.cache for per-request memoization in Server Components.
-* Both computeStyles() and standalone style functions (useGlobalStyles,
-* useRawCSS, useKeyframes, useProperty, useFontFace, useCounterStyle)
-* share this cache so that CSS accumulated by standalone functions is
-* flushed into inline <style> tags by the next tasty() component.
-*/
-/**
-* Per-request RSC style cache using React.cache.
-* React.cache provides per-request memoization in Server Components,
-* so each request gets its own isolated cache.
-*/
-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
-	};
-}
-/**
-* Flush any pending CSS accumulated by standalone functions.
-* Returns the CSS string and clears the buffer.
-*/
-function flushPendingCSS(rscCache) {
-	if (rscCache.pendingCSS.length === 0) return "";
-	const css = rscCache.pendingCSS.join("\n");
-	rscCache.pendingCSS.length = 0;
-	rscCache.keyToIndex.clear();
-	return css;
-}
-/**
-* Push CSS into the RSC pending buffer with dedup via emittedKeys.
-* Returns true if the CSS was added, false if it was already emitted.
-*
-* Pass `replace` for slot-keyed entries (an explicit `id`), where the last write
-* must win to match the client's update-tracking behavior. If the slot has
-* already been flushed into a `<style>` tag the new CSS is appended instead,
-* which still wins by cascade order.
-*/
-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;
-}
-/**
-* Determine the current style injection target.
-* Centralizes the three-way detection (SSR collector / RSC cache / client DOM)
-* used by all style functions.
-*/
-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
-/**
-* Scan rendered rules for auto-inferable custom properties and emit
-* @property CSS via the provided callback.
-*/
-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);
-		});
-	}
-}
-/**
-* Scan rendered rules for custom property declarations and collect
-* auto-inferred @property rules via the SSR collector.
-*
-* @param rules - Rendered style rules containing CSS declarations
-* @param collector - SSR collector to emit @property CSS into
-* @param styles - Original styles object (used to skip explicit @property)
-*/
-function collectAutoInferredProperties(rules, collector, styles) {
-	scanAndEmitAutoProperties(rules, styles, (name, css) => {
-		collector.collectProperty(`__auto:${name}`, css);
-	});
-}
-/**
-* RSC variant: scan rendered rules and push auto-inferred @property CSS
-* into the RSC pending buffer.
-*/
-function collectAutoInferredPropertiesRSC(rules, rscCache, styles) {
-	scanAndEmitAutoProperties(rules, styles, (name, css) => {
-		pushRSCCSS(rscCache, `__auto:${name}`, css);
-	});
-}
-//#endregion
-//#region src/ssr/format-keyframes.ts
-/**
-* Convert keyframes steps to a CSS string.
-* Replicates SheetManager.stepsToCSS() without the class instance.
-*/
-function stepsToCSS(steps) {
-	const rules = [];
-	for (const [key, value] of Object.entries(steps)) {
-		if (typeof value === "string") {
-			rules.push(`${key} { ${value.trim()} }`);
-			continue;
-		}
-		const styleMap = value || {};
-		const styleNames = Object.keys(styleMap).sort();
-		const handlerQueue = [];
-		const seenHandlers = /* @__PURE__ */ new Set();
-		styleNames.forEach((styleName) => {
-			let handlers = STYLE_HANDLER_MAP[styleName];
-			if (!handlers) handlers = STYLE_HANDLER_MAP[styleName] = [createStyle(styleName)];
-			handlers.forEach((handler) => {
-				if (!seenHandlers.has(handler)) {
-					seenHandlers.add(handler);
-					handlerQueue.push(handler);
-				}
-			});
-		});
-		const declarationPairs = [];
-		handlerQueue.forEach((handler) => {
-			const result = handler(handler.__lookupStyles.reduce((acc, name) => {
-				const v = styleMap[name];
-				if (v !== void 0) acc[name] = v;
-				return acc;
-			}, {}));
-			if (!result) return;
-			(Array.isArray(result) ? result : [result]).forEach((cssMap) => {
-				if (!cssMap || typeof cssMap !== "object") return;
-				const { $: _$, ...props } = cssMap;
-				Object.entries(props).forEach(([prop, val]) => {
-					if (val == null || val === "") return;
-					if (Array.isArray(val)) val.forEach((v) => {
-						if (v != null && v !== "") declarationPairs.push({
-							prop,
-							value: String(v)
-						});
-					});
-					else declarationPairs.push({
-						prop,
-						value: String(val)
-					});
-				});
-			});
-		});
-		const declarations = declarationPairs.map((d) => `${d.prop}: ${d.value}`).join("; ");
-		rules.push(`${key} { ${declarations.trim()} }`);
-	}
-	return rules.join(" ");
-}
-/**
-* Format a @keyframes rule as a CSS string.
-*/
-function formatKeyframesCSS(name, steps) {
-	return `@keyframes ${name} { ${stepsToCSS(steps)} }`;
-}
-//#endregion
-//#region src/utils/has-keys.ts
-/**
-* Check if an object has any own enumerable keys.
-* Avoids the array allocation of Object.keys(obj).length > 0.
-*/
-function hasKeys(obj) {
-	for (const _ in obj) return true;
-	return false;
-}
-//#endregion
-//#region src/compute-styles.ts
-/**
-* Hook-free, synchronous style computation.
-*
-* Extracts the core logic from useStyles() into a plain function that can
-* be called during React render without any hooks. Three code paths:
-*
-* 1. SSR collector — styles collected via ServerStyleCollector
-* 2. Client inject — styles injected synchronously into the DOM
-* 3. RSC inline — styles returned as CSS strings for inline <style> emission
-*
-* This enables tasty() components to work as React Server Components.
-*/
-const EMPTY_RESULT = { className: "" };
-/**
-* Mark internals as emitted for this RSC request.
-*
-* Internals (tokens, @property, @font-face, @counter-style) are emitted
-* exclusively by the SSR collector via ServerStyleCollector.collectInternals().
-* The SSR path is reliable because TastyRegistry is always present as a
-* client component in the root layout, guaranteeing SSR runs for every page.
-*
-* Previously this function also emitted internals and coordinated with SSR
-* via a globalThis flag, but that flag leaked across requests in the same
-* Node.js process, causing pages without RSC-rendered tasty components
-* (e.g. the playground route) to lose all token CSS.
-*/
-function collectInternalsRSC(rscCache) {
-	if (rscCache.internalsEmitted) return "";
-	rscCache.internalsEmitted = true;
-	return "";
-}
-/**
-* Collect per-component ancillary CSS (keyframes, @property, font-face,
-* counter-style) for RSC mode.
-*/
-function collectAncillaryRSC(rscCache, styles) {
-	const parts = [];
-	const usedKf = getUsedKeyframes(styles);
-	const rscKeyframeNames = usedKf ? resolveKeyframesNames(usedKf) : null;
-	if (usedKf && rscKeyframeNames) for (const [authored, steps] of Object.entries(usedKf)) {
-		const name = rscKeyframeNames.get(authored);
-		const key = `__kf:${name}`;
-		if (!rscCache.emittedKeys.has(key)) {
-			rscCache.emittedKeys.add(key);
-			parts.push(formatKeyframesCSS(name, steps));
-		}
-	}
-	if (hasLocalProperties(styles)) {
-		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);
-			}
-		}
-	}
-	if (hasLocalFontFace(styles)) {
-		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));
-				}
-			}
-		}
-	}
-	if (hasLocalCounterStyle(styles)) {
-		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() && hasLocalFunctions(styles)) {
-		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");
-}
-/**
-* Process all chunks in RSC mode: render CSS to strings, allocate classNames,
-* and return combined { className, css }.
-*/
-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);
-	const internalsCSS = collectInternalsRSC(rscCache);
-	if (internalsCSS) cssParts.push(internalsCSS);
-	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);
-	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
-	};
-}
-/**
-* Get keyframes that are actually used in styles.
-* Returns null if no keyframes are used (fast path for zero overhead).
-*/
-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);
-}
-/**
-* Process a chunk on the SSR path: allocate via collector, render, collect CSS.
-*/
-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 { animations, rules, cacheKey } = applyKeyframeNames(renderResult.rules, baseKey, keyframeNames);
-	const { className, isNewAllocation } = collector.allocateClassName(cacheKey);
-	if (isNewAllocation) {
-		collector.collectChunk(cacheKey, className, rules);
-		return {
-			name: chunkName,
-			styleKeys,
-			cacheKey,
-			renderResult: {
-				...renderResult,
-				rules
-			},
-			className,
-			animations
-		};
-	}
-	return {
-		name: chunkName,
-		styleKeys,
-		cacheKey,
-		renderResult: { rules: [] },
-		className
-	};
-}
-/**
-* Point a chunk's rules at the resolved keyframe names, and fold those names
-* into its cache key.
-*
-* Both halves matter, and both have to happen before the rules are written
-* anywhere: the declarations have to name the animation that will exist, and
-* the key has to distinguish two components that authored the same shorthand
-* over different definitions. Shared by the client and the server so they
-* cannot disagree about either.
-*/
-function applyKeyframeNames(ruleset, baseKey, keyframeNames) {
-	if (!keyframeNames || keyframeNames.size === 0) return {
-		animations: [],
-		rules: ruleset,
-		cacheKey: baseKey
-	};
-	const animations = [...keyframeNames.keys()].filter((authored) => ruleset.some((rule) => referencesAnimation(rule.declarations, authored)));
-	if (animations.length === 0) return {
-		animations,
-		rules: ruleset,
-		cacheKey: baseKey
-	};
-	return {
-		animations,
-		rules: ruleset.map((rule) => ({
-			...rule,
-			declarations: replaceAnimationNames(rule.declarations, keyframeNames)
-		})),
-		cacheKey: `${baseKey}\u0000kf:${animations.map((authored) => `${authored}=${keyframeNames.get(authored)}`).sort().join(",")}`
-	};
-}
-/**
-* Process a chunk on the client: render, allocate className, and inject
-* CSS synchronously. The injector's cache makes this idempotent.
-*/
-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 {
-		name: chunkName,
-		styleKeys,
-		cacheKey: injectKey,
-		renderResult: {
-			...renderResult,
-			rules
-		},
-		className,
-		animations
-	};
-}
-/**
-* Inject all ancillary rules (properties, font-faces, counter-styles) synchronously.
-*/
-function injectAncillarySync(styles, root) {
-	if (hasLocalProperties(styles)) {
-		const localProperties = extractLocalProperties(styles);
-		if (localProperties) for (const [token, definition] of Object.entries(localProperties)) property(token, {
-			...definition,
-			root
-		});
-	}
-	if (hasLocalFontFace(styles)) {
-		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 });
-		}
-	}
-	if (hasLocalCounterStyle(styles)) {
-		const localCounterStyle = extractLocalCounterStyle(styles);
-		if (localCounterStyle) for (const [name, descriptors] of Object.entries(localCounterStyle)) counterStyle(name, descriptors, { root });
-	}
-	if (!isFunctionsPolyfillEnabled() && hasLocalFunctions(styles)) {
-		const localFunctions = extractLocalFunctions(styles);
-		if (localFunctions) for (const [name, definition] of Object.entries(localFunctions)) func(name, definition, { root });
-	}
-}
-/**
-* Collect all ancillary rules into the SSR collector.
-*/
-function collectAncillarySSR(collector, styles, chunks) {
-	const usedKf = getUsedKeyframes(styles);
-	if (usedKf) {
-		const names = resolveKeyframesNames(usedKf);
-		for (const [authored, steps] of Object.entries(usedKf)) {
-			const name = names.get(authored);
-			collector.collectKeyframes(name, formatKeyframesCSS(name, steps));
-		}
-	}
-	if (hasLocalProperties(styles)) {
-		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);
-		}
-	}
-	if (hasLocalFontFace(styles)) {
-		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);
-			}
-		}
-	}
-	if (hasLocalCounterStyle(styles)) {
-		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() && hasLocalFunctions(styles)) {
-		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((c) => c.renderResult.rules);
-		if (allRules.length > 0) collectAutoInferredProperties(allRules, collector, styles);
-	}
-}
-/**
-* Synchronous, hook-free style computation.
-*
-* Resolves recipes, categorizes style keys into chunks, renders CSS rules,
-* allocates class names, and injects / collects / returns the CSS.
-*
-* Three code paths:
-* 1. SSR collector — discovered via ALS or passed explicitly; CSS collected
-* 2. RSC inline — no collector and no `document`; CSS returned as `result.css`
-*    for the caller to emit as an inline `<style>` tag
-* 3. Client inject — CSS injected synchronously into the DOM (idempotent)
-*
-* @param styles - Tasty styles object (or undefined for no styles)
-* @param options - Optional SSR collector override
-*/
-function computeStyles(styles, options) {
-	if (!styles || !hasKeys(styles)) return EMPTY_RESULT;
-	const resolved = resolveRecipes(styles);
-	const stableStyles = options?.stableStyles === true && resolved === styles;
-	if (isFunctionsPolyfillEnabled() && hasLocalFunctions(resolved)) 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);
-	} 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 DOMPropNames = new Set(["id"]);
-const BasePropNames = new Set([
-	"role",
-	"as",
-	"element",
-	"css",
-	"qa",
-	"mods",
-	"qaVal",
-	"hidden",
-	"isHidden",
-	"disabled",
-	"isDisabled",
-	"children",
-	"style",
-	"className",
-	"href",
-	"target",
-	"tabIndex"
-]);
-const ignoreEventPropsNames = new Set([
-	"onPress",
-	"onHoverStart",
-	"onHoverEnd",
-	"onPressStart",
-	"onPressEnd"
-]);
-const propRe = /^((data-).*)$/;
-const eventRe = /^on[A-Z].+$/;
-/**
-* Filters out all props that aren't valid DOM props or defined via override prop obj.
-* @param props - The component props to be filtered.
-* @param opts - Props to override.
-*/
-function filterBaseProps(props, opts = {}) {
-	const { propNames, eventProps } = opts;
-	const filteredProps = {};
-	for (const prop in props) if (Object.prototype.hasOwnProperty.call(props, prop) && (DOMPropNames.has(prop) || BasePropNames.has(prop) || prop.startsWith("aria-") || eventProps && eventRe.test(prop) && !ignoreEventPropsNames.has(prop) || propNames?.has(prop) || propRe.test(prop))) filteredProps[prop] = props[prop];
-	return filteredProps;
-}
-//#endregion
-//#region src/utils/colors.ts
-function color(name, opacity = 1) {
-	if (opacity !== 1) return overrideColorAlpha(`var(--${name}-color)`, String(opacity));
-	return `var(--${name}-color)`;
-}
-//#endregion
-//#region src/utils/cache-wrapper.ts
-/**
-* Create a function that caches the result with LRU eviction.
-*/
-function cacheWrapper(handler, limit = 1e3) {
-	const cache = new Lru(limit);
-	return (firstArg, secondArg) => {
-		const key = typeof firstArg === "string" && secondArg == null ? firstArg : JSON.stringify([firstArg, secondArg]);
-		let result = cache.get(key);
-		if (result === void 0) {
-			result = secondArg == null ? handler(firstArg) : handler(firstArg, secondArg);
-			cache.set(key, result);
-		}
-		return result;
-	};
-}
-//#endregion
-//#region src/utils/mod-attrs.ts
-function modAttrs(map) {
-	return map ? Object.keys(map).reduce((attrs, key) => {
-		const value = map[key];
-		if (value == null || value === false) return attrs;
-		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}`);
-		return attrs;
-	}, {}) : null;
-}
-const _modAttrs = cacheWrapper(modAttrs);
-//#endregion
-//#region src/utils/dotize.ts
-const dotize = {
-	valTypes: {
-		none: "NONE",
-		primitive: "PRIM",
-		object: "OBJECT",
-		array: "ARRAY"
-	},
-	getValType: function(val) {
-		if (!val || typeof val != "object" || Array.isArray(val)) return dotize.valTypes.primitive;
-		if (typeof val == "object") return dotize.valTypes.object;
-	},
-	getPathType: function(arrPath) {
-		const arrPathTypes = [];
-		for (const path in arrPath) {
-			const pathVal = arrPath[path];
-			if (!pathVal) arrPathTypes.push(dotize.valTypes.none);
-			else if (dotize.isNumber(pathVal)) arrPathTypes.push(dotize.valTypes.array);
-			else arrPathTypes.push(dotize.valTypes.object);
-		}
-		return arrPathTypes;
-	},
-	isUndefined: function(obj) {
-		return typeof obj == "undefined";
-	},
-	isNumber: function(f) {
-		return !isNaN(parseInt(f));
-	},
-	isEmptyObj: function(obj) {
-		for (const prop in obj) if (Object.hasOwnProperty.call(obj, prop)) return false;
-		return JSON.stringify(obj) === JSON.stringify({});
-	},
-	isPlainObject: function(obj) {
-		if (typeof obj !== "object" || obj === null) return false;
-		return Object.getPrototypeOf(obj) === Object.prototype;
-	},
-	isNotObject: function(obj) {
-		return !obj || !this.isPlainObject(obj);
-	},
-	isEmptyArray: function(arr) {
-		return Array.isArray(arr) && arr.length == 0;
-	},
-	isNotArray: function(arr) {
-		return Array.isArray(arr) == false;
-	},
-	removeEmptyArrayItem: function(arr) {
-		return arr.filter(function(el) {
-			return el != null && el != "";
-		});
-	},
-	getFieldName: function(field, prefix, isRoot, isArrayItem, isArray) {
-		if (isArray) return (prefix ? prefix : "") + (dotize.isNumber(field) ? "[" + field + "]" : (isRoot && !prefix ? "" : ".") + field);
-		else if (isArrayItem) return (prefix ? prefix : "") + "[" + field + "]";
-		else return (prefix ? prefix + "." : "") + field;
-	},
-	startsWith: function(val, valToSearch) {
-		return val.indexOf(valToSearch) == 0;
-	},
-	convert: function(obj, prefix = "") {
-		let newObj = {};
-		if (dotize.isNotObject(obj)) if (prefix) {
-			newObj[prefix] = obj;
-			return newObj;
-		} else return obj;
-		return (function recurse(o, p, isRoot) {
-			const isArrayItem = Array.isArray(o);
-			for (const f in o) {
-				const currentProp = o[f];
-				if (currentProp && typeof currentProp === "object" && !Array.isArray(currentProp) && dotize.isPlainObject(currentProp)) {
-					if (isArrayItem && dotize.isEmptyObj(currentProp) == false) newObj = recurse(currentProp, dotize.getFieldName(f, p, isRoot, true));
-					else if (dotize.isEmptyObj(currentProp) == false) newObj = recurse(currentProp, dotize.getFieldName(f, p, isRoot));
-					else if (dotize.isEmptyObj(currentProp)) newObj[dotize.getFieldName(f, p, isRoot, isArrayItem)] = currentProp;
-				} else if (isArrayItem || dotize.isNumber(f)) newObj[dotize.getFieldName(f, p, isRoot, true)] = currentProp;
-				else newObj[dotize.getFieldName(f, p, isRoot)] = currentProp;
-			}
-			return newObj;
-		})(obj, prefix, true);
-	},
-	backward: function(obj, prefix) {
-		let newObj = {};
-		const arStartRegex = /\[(\d+)\]/g;
-		if (dotize.isNotObject(obj) && dotize.isNotArray(obj)) if (prefix) return obj[prefix];
-		else return obj;
-		for (let tProp in obj) {
-			const tPropVal = obj[tProp];
-			if (prefix) {
-				const prefixRegex = new RegExp("^" + prefix);
-				tProp = tProp.replace(prefixRegex, "");
-			}
-			tProp = tProp.replace(arStartRegex, ".$1");
-			if (dotize.startsWith(tProp, ".")) tProp = tProp.replace(/^\./, "");
-			const arrPath = tProp.split(".");
-			const arrPathTypes = dotize.getPathType(arrPath);
-			if (!dotize.isUndefined(arrPathTypes) && arrPathTypes[0] == dotize.valTypes.array && Array.isArray(newObj) == false) newObj = [];
-			(function recurse(rPropVal, rObj, rPropValPrev, rObjPrev) {
-				let currentPath = arrPath.shift();
-				const currentPathType = arrPathTypes.shift();
-				if (typeof currentPath == "undefined" || currentPath == "") {
-					newObj = rPropVal;
-					return;
-				}
-				const isArray = currentPathType == dotize.valTypes.array;
-				if (dotize.isNumber(currentPath)) currentPath = parseInt(currentPath);
-				if (arrPath.length > 0) {
-					if (typeof rObj[currentPath] == "undefined") if (isArray) rObj[currentPath] = [];
-					else rObj[currentPath] = {};
-					recurse(rPropVal, rObj[currentPath], currentPath, rObj);
-					return;
-				}
-				if (currentPathType == dotize.valTypes.array && rPropValPrev && rObjPrev) {
-					if (Array.isArray(rObjPrev[rPropValPrev]) == false) rObjPrev[rPropValPrev] = [];
-					rObjPrev[rPropValPrev].push(rPropVal);
-				} else rObj[currentPath] = rPropVal;
-			})(tPropVal, newObj);
-		}
-		return newObj;
-	}
-};
-//#endregion
-//#region src/utils/process-tokens.ts
-/**
-* Check if a value is a valid token value (string, number, or boolean - not object).
-* Returns false for `false` values (they mean "skip this token").
-*/
-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";
-}
-/**
-* Process a single token value through the tasty parser.
-* Numbers are converted to strings; 0 stays as "0".
-*/
-function processTokenValue(value) {
-	if (typeof value === "number") {
-		if (value === 0) return "0";
-		return parseStyle(String(value)).output;
-	}
-	return parseStyle(value).output;
-}
-/**
-* Resolve one `$name` / `#name` entry to the custom property it declares and
-* the value to declare, or `null` when the entry declares nothing.
-*
-* The two sigils differ only in the property name they build and in how `true`
-* is read: for a custom property it is the empty value, for a color it is
-* `transparent`.
-*/
-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)];
-}
-/**
-* Process tokens object into inline style properties.
-* - `$name` -> `--name` with the parsed value
-* - `#name` -> `--name-color` with the parsed value
-*
-* @param tokens - The tokens object to process
-* @returns CSSProperties object or undefined if no tokens to process
-*/
-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/debug.ts
-function fmtSize(bytes) {
-	return bytes > 1024 ? `${(bytes / 1024).toFixed(1)}KB` : `${bytes}B`;
-}
-function countRules(css) {
-	return (css.match(/\{[^}]*\}/g) || []).length;
-}
-function sortTastyClasses(classes) {
-	return Array.from(classes).sort((a, b) => a.localeCompare(b));
-}
-/**
-* The root these helpers read, or `null` where there is no DOM.
-*
-* `document` used to be a default parameter value, and a default is evaluated
-* at the call site — so every read below threw a bare `ReferenceError` under
-* Node, taking out five of the eight public methods. A debug utility must not
-* be able to fail an SSR render because a call was left in, so the DOM-less
-* case reports an empty result and says why.
-*/
-function defaultRoot() {
-	return typeof document === "undefined" ? null : document;
-}
-let warnedNoDom = false;
-/** Say once why the numbers are empty. Silent under `{ raw: true }`. */
-function warnNoDom(raw) {
-	if (raw || warnedNoDom) return;
-	warnedNoDom = true;
-	console.warn("[Tasty] tastyDebug reads the DOM and this environment has none, so the result is empty. During SSR, read the ServerStyleCollector instead.");
-}
-/**
-* The registry for `root`, with every queued write landed first.
-*
-* Every injector read API is a flush point, and the reads below reach past
-* those APIs straight into the registry and the sheet manager. Without this
-* they would report a batch window's contents as absent — a rule that is
-* enqueued but not yet in a sheet is missing from `globalRules`, from the
-* sheets, and from anything counting either.
-*/
-function getRegistry(root = defaultRoot()) {
-	if (!root) return void 0;
-	flushStyles();
-	return injector.instance._sheetManager?.getRegistry(root);
-}
-function findDomTastyClasses(root = defaultRoot()) {
-	if (!root) return [];
-	const classes = /* @__PURE__ */ new Set();
-	const elements = root.querySelectorAll?.("[class]") || [];
-	const classRegex = tastyClassRegex(getNamePrefix());
-	elements.forEach((el) => {
-		const attr = el.getAttribute("class");
-		if (attr) {
-			for (const cls of attr.split(/\s+/)) if (classRegex.test(cls)) classes.add(cls);
-		}
-	});
-	return sortTastyClasses(classes);
-}
-/**
-* Everything this injector holds in `root`, in the order the engine applies it,
-* with the sources kept byte-for-byte — trimming would report a total smaller
-* than one of its own parts whenever raw CSS has edge whitespace.
-*/
-function getAllCSS(root = defaultRoot()) {
-	const registry = getRegistry(root);
-	const sheetManager = injector.instance._sheetManager;
-	if (!root || !registry || !sheetManager) return "";
-	return sheetManager.getOwnedCSSInOrder(registry, root).join("\n");
-}
-/**
-* The injector's own readers fall back to `document` when `root` is omitted, so
-* they have to be reached with a real root or not at all.
-*/
-function cssTextForClasses(classNames, root) {
-	if (!root) return "";
-	return injector.instance.getCSSTextForClasses(classNames, { root });
-}
-function getInjectorMetrics(root) {
-	if (!root) return null;
-	return injector.instance.getMetrics({ root });
-}
-/**
-* Injected classes that no element carries and nobody pinned — the exact set
-* `gc({ force: true })` would delete.
-*
-* Deliberately borrowed from the injector rather than recomputed here: the two
-* drifted apart once before, when this file still read "unused" off the pin
-* counts the render path had stopped maintaining.
-*/
-function getUnusedClasses(root = defaultRoot()) {
-	if (!root) return [];
-	return sortTastyClasses(injector.instance.getUnusedClasses({ root }));
-}
-/** Every class this injector holds CSS for in `root`. */
-function getOwnedClasses(root = defaultRoot()) {
-	const registry = getRegistry(root);
-	if (!registry) return [];
-	const owned = [];
-	for (const [className, info] of registry.rules) if (info.sheetIndex >= 0) owned.push(className);
-	return sortTastyClasses(owned);
-}
-function prettifyCSS(css) {
-	if (!css || !css.trim()) return "";
-	const out = [];
-	let depth = 0;
-	const indent = () => "  ".repeat(depth);
-	let normalized = css.replace(/\s+/g, " ").trim();
-	normalized = normalized.replace(/\s*\{\s*/g, " { ");
-	normalized = normalized.replace(/\s*\}\s*/g, " } ");
-	normalized = normalized.replace(/;\s*/g, "; ");
-	const tokens = normalized.split(/\s+/);
-	let buf = "";
-	for (const t of tokens) if (t === "{") {
-		const header = buf.trim();
-		if (header) {
-			const parts = splitOutsideParens(header, ",");
-			if (parts.length > 1) out.push(parts.map((p, idx) => idx === 0 ? `${indent()}${p.trim()},` : `${indent()}${p.trim()}${idx < parts.length - 1 ? "," : ""}`).join("\n") + " {");
-			else out.push(`${indent()}${header} {`);
-		} else out.push(`${indent()}{`);
-		depth++;
-		buf = "";
-	} else if (t === "}") {
-		if (buf.trim()) {
-			for (const decl of buf.split(";").filter((s) => s.trim())) out.push(`${indent()}${decl.trim()};`);
-			buf = "";
-		}
-		depth = Math.max(0, depth - 1);
-		out.push(`${indent()}}`);
-	} else if (t.endsWith(";")) {
-		buf += ` ${t}`;
-		const full = buf.trim();
-		if (full) out.push(`${indent()}${full}`);
-		buf = "";
-	} else buf += ` ${t}`;
-	if (buf.trim()) out.push(buf.trim());
-	return out.filter((l) => l.trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
-}
-/** Split `str` by `sep` only when not inside parentheses */
-function splitOutsideParens(str, sep) {
-	const parts = [];
-	let depth = 0;
-	let start = 0;
-	for (let i = 0; i < str.length; i++) {
-		const ch = str[i];
-		if (ch === "(") depth++;
-		else if (ch === ")") depth--;
-		else if (depth === 0 && str.startsWith(sep, i)) {
-			parts.push(str.slice(start, i));
-			start = i + sep.length;
-		}
-	}
-	parts.push(str.slice(start));
-	return parts;
-}
-function extractChunkName(cacheKey) {
-	for (const part of cacheKey.split("\0")) {
-		if (part.startsWith("[states:")) continue;
-		if (!part.includes(":") && part.length > 0) return part;
-	}
-	return null;
-}
-function getChunkForClass(className, root = defaultRoot()) {
-	const registry = getRegistry(root);
-	if (!registry) return null;
-	for (const [key, cn] of registry.cacheKeyToClassName) if (cn === className) return extractChunkName(key);
-	return null;
-}
-function buildChunkBreakdown(root = defaultRoot()) {
-	const registry = getRegistry(root);
-	if (!root || !registry) return {
-		byChunk: {},
-		totalChunkTypes: 0,
-		totalClasses: 0
-	};
-	const byChunk = {};
-	for (const [cacheKey, className] of registry.cacheKeyToClassName) {
-		const chunk = extractChunkName(cacheKey) || "unknown";
-		if (!byChunk[chunk]) byChunk[chunk] = {
-			classes: [],
-			cssSize: 0,
-			ruleCount: 0
-		};
-		byChunk[chunk].classes.push(className);
-		const css = injector.instance.getCSSTextForClasses([className], { root });
-		byChunk[chunk].cssSize += css.length;
-		byChunk[chunk].ruleCount += countRules(css);
-	}
-	for (const entry of Object.values(byChunk)) entry.classes = sortTastyClasses(entry.classes);
-	const totalClasses = Object.values(byChunk).reduce((s, e) => s + e.classes.length, 0);
-	return {
-		byChunk,
-		totalChunkTypes: Object.keys(byChunk).length,
-		totalClasses
-	};
-}
-/**
-* Every prefix `registry.globalRules` is keyed by. Anything missing here is a
-* rule the summary would hold but never count, which is how the totals stopped
-* adding up the first time.
-*/
-const GLOBAL_RULE_PREFIXES = {
-	global: "global:",
-	property: "property:",
-	fontFace: "fontface:",
-	counterStyle: "counterstyle:",
-	function: "function:"
-};
-function getGlobalTypeCSS(type, root = defaultRoot()) {
-	const registry = getRegistry(root);
-	if (!root || !registry) return {
-		css: "",
-		ruleCount: 0,
-		size: 0
-	};
-	const chunks = [];
-	let rc = 0;
-	if (type === "raw") {
-		const css = injector.instance.getRawCSSText({ root });
-		const sheetManager = injector.instance._sheetManager;
-		return {
-			css: prettifyCSS(css),
-			ruleCount: sheetManager?.getRawRuleCount(root) ?? 0,
-			size: css.length
-		};
-	}
-	if (type === "keyframes") for (const [, entry] of registry.keyframesCache) {
-		const info = entry.info;
-		const sheetInfo = registry.sheets[info.sheetIndex];
-		const sm = injector.instance._sheetManager;
-		const ss = sheetInfo && sm ? sm.getCSSSheet(sheetInfo) : null;
-		if (ss && info.ruleIndex < ss.cssRules.length) {
-			const rule = ss.cssRules[info.ruleIndex];
-			if (rule) {
-				chunks.push(rule.cssText);
-				rc++;
-			}
-		} else if (info.cssText) {
-			chunks.push(info.cssText);
-			rc++;
-		}
-	}
-	else {
-		const prefix = GLOBAL_RULE_PREFIXES[type];
-		for (const [key, ri] of registry.globalRules) {
-			if (!key.startsWith(prefix)) continue;
-			const sheetInfo = registry.sheets[ri.sheetIndex];
-			const sm = injector.instance._sheetManager;
-			const ss = sheetInfo && sm ? sm.getCSSSheet(sheetInfo) : null;
-			if (ss) {
-				const start = Math.max(0, ri.ruleIndex);
-				const end = Math.min(ss.cssRules.length - 1, ri.endRuleIndex ?? ri.ruleIndex);
-				if (start >= 0 && end >= start && start < ss.cssRules.length) for (let i = start; i <= end; i++) {
-					const rule = ss.cssRules[i];
-					if (rule) {
-						chunks.push(rule.cssText);
-						rc++;
-					}
-				}
-			} else if (ri.cssText?.length) {
-				chunks.push(...ri.cssText);
-				rc += ri.cssText.length;
-			}
-		}
-	}
-	const raw = chunks.join("\n");
-	return {
-		css: prettifyCSS(raw),
-		ruleCount: rc,
-		size: raw.length
-	};
-}
-function getSourceCssForClasses(classNames, root = defaultRoot()) {
-	const registry = getRegistry(root);
-	if (!registry) return null;
-	const chunks = [];
-	let found = false;
-	for (const cls of classNames) {
-		const info = registry.rules.get(cls);
-		if (info?.cssText?.length) {
-			chunks.push(...info.cssText);
-			found = true;
-		}
-	}
-	return found ? chunks.join("\n") : null;
-}
-function getDefs(root = defaultRoot()) {
-	const registry = getRegistry(root);
-	let properties = [];
-	if (registry?.injectedProperties) properties = Array.from(registry.injectedProperties.keys()).sort();
-	const keyframes = [];
-	if (registry) {
-		for (const entry of registry.keyframesCache.values()) keyframes.push({
-			name: entry.name,
-			refCount: entry.refCount
-		});
-		keyframes.sort((a, b) => a.name.localeCompare(b.name));
-	}
-	return {
-		properties,
-		keyframes
-	};
-}
-const CHUNK_ORDER = [
-	CHUNK_NAMES.COMBINED,
-	CHUNK_NAMES.APPEARANCE,
-	CHUNK_NAMES.FONT,
-	CHUNK_NAMES.DIMENSION,
-	CHUNK_NAMES.DISPLAY,
-	CHUNK_NAMES.LAYOUT,
-	CHUNK_NAMES.POSITION,
-	CHUNK_NAMES.MISC,
-	CHUNK_NAMES.SUBCOMPONENTS
-];
-const tastyDebug = {
-	css(target, opts) {
-		const { root = defaultRoot(), prettify = true, raw = false, source = false } = opts || {};
-		if (!root) {
-			warnNoDom(raw);
-			return "";
-		}
-		let css = "";
-		const classRegex = tastyClassRegex(getNamePrefix());
-		if (source && typeof target === "string" && classRegex.test(target)) {
-			const src = getSourceCssForClasses([target], root);
-			if (src) css = src;
-			else {
-				if (!raw) console.warn("[Tasty] source CSS not available (requires dev mode or TASTY_DEBUG=true). Falling back to live CSSOM.");
-				css = injector.instance.getCSSTextForClasses([target], { root });
-			}
-		} else if (source && Array.isArray(target)) {
-			const src = getSourceCssForClasses(target, root);
-			if (src) css = src;
-			else {
-				if (!raw) console.warn("[Tasty] source CSS not available. Falling back to live CSSOM.");
-				css = injector.instance.getCSSTextForClasses(target, { root });
-			}
-		} else if (typeof target === "string") if (target === "all") css = getAllCSS(root);
-		else if (target === "global") {
-			css = getGlobalTypeCSS("global", root).css;
-			return css;
-		} else if (target === "active") {
-			const active = findDomTastyClasses(root);
-			css = injector.instance.getCSSTextForClasses(active, { root });
-		} else if (target === "unused") {
-			const unused = getUnusedClasses(root);
-			css = injector.instance.getCSSTextForClasses(unused, { root });
-		} else if (target === "page") css = getPageCSS(root);
-		else if (classRegex.test(target)) css = injector.instance.getCSSTextForClasses([target], { root });
-		else {
-			const el = root.querySelector?.(target);
-			if (el) css = getCSSTextForNode(el, { root });
-		}
-		else if (Array.isArray(target)) css = injector.instance.getCSSTextForClasses(target, { root });
-		else if (target instanceof Element) css = getCSSTextForNode(target, { root });
-		const result = prettify ? prettifyCSS(css) : css;
-		if (!raw) {
-			const label = Array.isArray(target) ? `[${target.join(", ")}]` : target;
-			const rc = countRules(css);
-			console.group(`CSS for ${label} (${rc} rules, ${fmtSize(css.length)})`);
-			console.log(result || "(empty)");
-			console.groupEnd();
-		}
-		return result;
-	},
-	inspect(target, opts) {
-		const { root = defaultRoot(), raw = false } = opts || {};
-		const element = !root ? null : typeof target === "string" ? root.querySelector?.(target) : target;
-		if (!root) warnNoDom(raw);
-		if (!element) {
-			const empty = {
-				element: null,
-				classes: [],
-				chunks: [],
-				css: "",
-				size: 0,
-				rules: 0
-			};
-			if (!raw && root) console.warn("[Tasty] debug.inspect: element not found");
-			return empty;
-		}
-		const classList = element.getAttribute("class") || "";
-		const classRegex = tastyClassRegex(getNamePrefix());
-		const tastyClasses = classList.split(/\s+/).filter((cls) => classRegex.test(cls));
-		const chunks = tastyClasses.map((className) => ({
-			className,
-			chunkName: getChunkForClass(className, root)
-		}));
-		const css = getCSSTextForNode(element, { root: root ?? void 0 });
-		const rules = countRules(css);
-		const result = {
-			element,
-			classes: tastyClasses,
-			chunks,
-			css: prettifyCSS(css),
-			size: css.length,
-			rules
-		};
-		if (!raw) {
-			const tag = element.tagName.toLowerCase();
-			const id = element.id ? `#${element.id}` : "";
-			console.group(`inspect ${tag}${id} — ${tastyClasses.length} classes, ${rules} rules, ${fmtSize(css.length)}`);
-			if (chunks.length) console.log("Chunks:", chunks.map((c) => `${c.className}→${c.chunkName || "?"}`).join(", "));
-			console.groupCollapsed("CSS");
-			console.log(result.css || "(empty)");
-			console.groupEnd();
-			console.groupEnd();
-		}
-		return result;
-	},
-	summary(opts) {
-		const { root = defaultRoot(), raw = false } = opts || {};
-		if (!root) warnNoDom(raw);
-		const activeClasses = findDomTastyClasses(root);
-		const unusedClasses = getUnusedClasses(root);
-		const ownedClasses = getOwnedClasses(root);
-		const totalStyledClasses = sortTastyClasses(new Set([...activeClasses, ...ownedClasses]));
-		const unusedSet = new Set(unusedClasses);
-		const activeSet = new Set(activeClasses);
-		const hotClasses = ownedClasses.filter((className) => !activeSet.has(className) && !unusedSet.has(className));
-		const hotCSS = cssTextForClasses(hotClasses, root);
-		const activeCSS = cssTextForClasses(activeClasses, root);
-		const unusedCSS = cssTextForClasses(unusedClasses, root);
-		const allCSS = getAllCSS(root);
-		const activeRuleCount = countRules(activeCSS);
-		const unusedRuleCount = countRules(unusedCSS);
-		const globalData = getGlobalTypeCSS("global", root);
-		const rawData = getGlobalTypeCSS("raw", root);
-		const kfData = getGlobalTypeCSS("keyframes", root);
-		const propData = getGlobalTypeCSS("property", root);
-		const atRuleData = [
-			"fontFace",
-			"counterStyle",
-			"function"
-		].reduce((all, type) => {
-			const data = getGlobalTypeCSS(type, root);
-			return {
-				css: data.css ? `${all.css}\n${data.css}`.trim() : all.css,
-				ruleCount: all.ruleCount + data.ruleCount,
-				size: all.size + data.size
-			};
-		}, {
-			css: "",
-			ruleCount: 0,
-			size: 0
-		});
-		const totalRuleCount = activeRuleCount + unusedRuleCount + countRules(hotCSS) + globalData.ruleCount + atRuleData.ruleCount + rawData.ruleCount + kfData.ruleCount + propData.ruleCount;
-		const metrics = getInjectorMetrics(root);
-		const defs = getDefs(root);
-		const chunkBreakdown = buildChunkBreakdown(root);
-		const summary = {
-			activeClasses,
-			unusedClasses,
-			hotClasses,
-			totalStyledClasses,
-			activeCSSSize: activeCSS.length,
-			unusedCSSSize: unusedCSS.length,
-			globalCSSSize: globalData.size + atRuleData.size,
-			rawCSSSize: rawData.size,
-			keyframesCSSSize: kfData.size,
-			propertyCSSSize: propData.size,
-			totalCSSSize: allCSS.length,
-			activeRuleCount,
-			unusedRuleCount,
-			globalRuleCount: globalData.ruleCount + atRuleData.ruleCount,
-			rawRuleCount: rawData.ruleCount,
-			keyframesRuleCount: kfData.ruleCount,
-			propertyRuleCount: propData.ruleCount,
-			totalRuleCount,
-			metrics,
-			definedProperties: defs.properties,
-			definedKeyframes: defs.keyframes,
-			chunkBreakdown
-		};
-		if (!raw) {
-			console.group("Tasty Summary");
-			console.log(`Active:   ${activeClasses.length} classes, ${activeRuleCount} rules, ${fmtSize(activeCSS.length)}`);
-			console.log(`Unused:   ${unusedClasses.length} classes, ${unusedRuleCount} rules, ${fmtSize(unusedCSS.length)}`);
-			if (hotClasses.length) console.log(`Held:     ${hotClasses.length} classes, ${countRules(hotCSS)} rules, ${fmtSize(hotCSS.length)} (not rendered, not yet collectable)`);
-			console.log(`Global:   ${globalData.ruleCount + atRuleData.ruleCount} rules, ${fmtSize(globalData.size + atRuleData.size)}`);
-			if (rawData.ruleCount) console.log(`Raw:      ${rawData.ruleCount} rules, ${fmtSize(rawData.size)}`);
-			if (kfData.ruleCount) console.log(`Keyframes: ${kfData.ruleCount} rules, ${fmtSize(kfData.size)}`);
-			if (propData.ruleCount) console.log(`@property: ${propData.ruleCount} rules, ${fmtSize(propData.size)}`);
-			console.log(`Total:    ${totalStyledClasses.length} classes, ${totalRuleCount} rules, ${fmtSize(allCSS.length)}`);
-			if (metrics) {
-				const total = metrics.hits + metrics.misses;
-				const rate = total > 0 ? (metrics.hits / total * 100).toFixed(1) : 0;
-				console.log(`Cache:    ${rate}% hit rate (${total} lookups)`);
-			}
-			if (chunkBreakdown.totalChunkTypes > 0) {
-				console.groupCollapsed(`Chunks (${chunkBreakdown.totalChunkTypes} types, ${chunkBreakdown.totalClasses} classes)`);
-				for (const name of CHUNK_ORDER) {
-					const d = chunkBreakdown.byChunk[name];
-					if (d) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
-				}
-				for (const [name, d] of Object.entries(chunkBreakdown.byChunk)) if (!CHUNK_ORDER.includes(name)) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
-				console.groupEnd();
-			}
-			if (defs.properties.length || defs.keyframes.length) console.log(`Defs:     ${defs.properties.length} @property, ${defs.keyframes.length} @keyframes`);
-			console.groupEnd();
-		}
-		return summary;
-	},
-	chunks(opts) {
-		const { root = defaultRoot(), raw = false } = opts || {};
-		if (!root) warnNoDom(raw);
-		const breakdown = buildChunkBreakdown(root);
-		if (!raw) {
-			console.group(`Chunks (${breakdown.totalChunkTypes} types, ${breakdown.totalClasses} classes)`);
-			for (const name of CHUNK_ORDER) {
-				const d = breakdown.byChunk[name];
-				if (d) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
-			}
-			for (const [name, d] of Object.entries(breakdown.byChunk)) if (!CHUNK_ORDER.includes(name)) console.log(`  ${name}: ${d.classes.length} cls, ${d.ruleCount} rules, ${fmtSize(d.cssSize)}`);
-			console.groupEnd();
-		}
-		return breakdown;
-	},
-	cache(opts) {
-		const { root = defaultRoot(), raw = false } = opts || {};
-		if (!root) warnNoDom(raw);
-		const active = findDomTastyClasses(root);
-		const unused = getUnusedClasses(root);
-		const metrics = getInjectorMetrics(root);
-		const status = {
-			classes: {
-				active,
-				unused,
-				all: sortTastyClasses(new Set([...active, ...getOwnedClasses(root)]))
-			},
-			metrics
-		};
-		if (!raw) {
-			console.group("Cache");
-			console.log(`Active: ${active.length}, Unused: ${unused.length}`);
-			if (metrics) {
-				const total = metrics.hits + metrics.misses;
-				const rate = total > 0 ? (metrics.hits / total * 100).toFixed(1) : 0;
-				console.log(`Hits: ${metrics.hits}, Misses: ${metrics.misses}, Rate: ${rate}%`);
-			}
-			console.groupEnd();
-		}
-		return status;
-	},
-	cleanup(opts) {
-		const root = opts?.root ?? defaultRoot();
-		if (!root) return;
-		injector.instance.cleanup(root);
-	},
-	help() {
-		console.log(`tastyDebug API:
-  .summary()            — overview (classes, rules, sizes)
-  .css("active")        — CSS for classes in DOM
-  .css("t42")           — CSS for a specific class
-  .css("t42",{source:1})— original CSS before browser parsing (dev only)
-  .css(".selector")     — CSS for a DOM element
-  .inspect(".selector") — element details (classes, chunks, rules)
-  .chunks()             — style chunk breakdown
-  .cache()              — cache status and metrics
-  .cleanup()            — force unused style cleanup
-Options: { raw: true } suppresses logging, { root: shadowRoot } targets Shadow DOM`);
-	},
-	install() {
-		if (typeof window !== "undefined" && window.tastyDebug !== tastyDebug) {
-			window.tastyDebug = tastyDebug;
-			console.log("tastyDebug installed. Run tastyDebug.help() for commands.");
-		}
-	}
-};
-function getPageCSS(root = defaultRoot()) {
-	if (!root) return "";
-	const chunks = [];
-	try {
-		if ("styleSheets" in root) for (const sheet of Array.from(root.styleSheets)) try {
-			if (sheet.cssRules) chunks.push(Array.from(sheet.cssRules).map((r) => r.cssText).join("\n"));
-		} catch {}
-	} catch {}
-	return chunks.join("\n");
-}
-if (typeof window !== "undefined" && isDevEnv()) tastyDebug.install();
-//#endregion
-export { keyframes as A, getRawCSSText as C, injectRawCSS as D, injectGlobal as E, chunkSheetRegistry as F, resolveFunctionColor as I, property as M, touch as N, injector as O, ChunkSheetRegistry as P, getCSSTextForNode as S, inject as T, destroy as _, color as a, gc as b, hasKeys as c, collectAutoInferredPropertiesRSC as d, getStyleTarget as f, createInjector as g, counterStyle as h, _modAttrs as i, ownKeyframes as j, isPropertyDefined as k, formatKeyframesCSS as l, cleanup as m, processTokens as n, filterBaseProps as o, pushRSCCSS as p, dotize as r, computeStyles as s, tastyDebug as t, collectAutoInferredProperties as u, fontFace as v, holdKeyframes as w, getCSSText as x, func as y };
-
-//# sourceMappingURL=core-DoEZAHJq.js.map