@tenphi/tasty 0.0.0-snapshot.06c8a41 → 0.0.0-snapshot.07ea4a0

package/dist/chunks/react-runtime-DayjnPuC.js

@@ -0,0 +1,689 @@
+import { n as isSelector, t as mergeStyles } from "./shared-utils-y-HjvPN4.js";
+import { K as parseFunctionName, N as hashString, O as makeCounterStyleName, S as formatFontFaceRule, W as formatFunctionRule, _ as formatCounterStyleRule, b as fontFaceContentHash, i as formatKeyframesCSS, k as makeKeyframeName, m as resolveSelectorKeyframes, n as formatGlobalRules, o as formatPropertyCSS, q as registerFunctionPolyfill } from "./css-definitions-_C7C-daI.js";
+import { b as renderStyles, i as baseStylePropsRegistry, q as isFunctionsPolyfillEnabled, s as BASE_STYLES } from "./style-engine-CVmNIjow.js";
+import { u as getGlobalKeyframes } from "./runtime-state-CVrL92zX.js";
+import { $ as openBatchWindow, B as getGlobalInjector, F as touch, H as getNamePrefix, M as keyframes, O as injectGlobal, X as closeBatchWindow, c as hasKeys, d as checkRequestScope, f as getRSCCache, h as queueRSCCSS, i as modAttrs, k as injectRawCSS, l as collectAutoInferredProperties, m as pushRSCCSS, n as createClientState, o as computeStyles, p as getStyleTarget, r as processTokens, s as resolveRecipes, t as depsEqual, tt as propHandlerRegistry, u as collectAutoInferredPropertiesRSC, z as getConfig } from "./runtime-engine-IwGbSMb4.js";
+import React, { Fragment, createElement, forwardRef } from "react";
+//#region src/utils/get-display-name.ts
+const DEFAULT_NAME = "Anonymous";
+function nameOf(type) {
+	if (typeof type === "string") return type;
+	if (!type || typeof type !== "function" && typeof type !== "object") return;
+	const { displayName, name, render, type: inner } = type;
+	if (displayName) return displayName;
+	if (typeof type === "function") return name || void 0;
+	return nameOf(render) ?? nameOf(inner);
+}
+function getDisplayName(Component, fallbackName = DEFAULT_NAME) {
+	return nameOf(Component) ?? fallbackName;
+}
+//#endregion
+//#region src/utils/is-valid-element-type.ts
+function isValidElementType(value) {
+	if (typeof value === "string" || typeof value === "function") return true;
+	if (typeof value === "object" && value !== null) return typeof value.$$typeof === "symbol";
+	return false;
+}
+//#endregion
+//#region src/tasty.tsx
+function handleIsProperty(props, isProperty, targetAttribute, dataAttribute) {
+	if (isProperty in props) {
+		props[targetAttribute] = props[isProperty];
+		delete props[isProperty];
+	}
+	if (!(dataAttribute in props) && props[targetAttribute]) props[dataAttribute] = "";
+}
+function handleIsProperties(props) {
+	handleIsProperty(props, "isDisabled", "disabled", "data-disabled");
+	handleIsProperty(props, "isHidden", "hidden", "data-hidden");
+	handleIsProperty(props, "isChecked", "checked", "data-checked");
+}
+function createSubElement(elementName, definition) {
+	const config = typeof definition === "string" ? { as: definition } : definition;
+	const tag = config.as ?? "div";
+	const defaultQa = config.qa;
+	const defaultQaVal = config.qaVal;
+	const SubElement = forwardRef((props, ref) => {
+		const { qa, qaVal, mods, tokens, isDisabled, isHidden, isChecked, className, style, ...htmlProps } = props;
+		let modDataAttrs;
+		if (mods) modDataAttrs = modAttrs(mods);
+		const tokenStyle = tokens ? processTokens(tokens) : void 0;
+		let mergedStyle;
+		if (tokenStyle || style) mergedStyle = tokenStyle && style ? {
+			...tokenStyle,
+			...style
+		} : tokenStyle ?? style;
+		const elementProps = {
+			"data-element": elementName,
+			"data-qa": qa ?? defaultQa,
+			"data-qaval": qaVal ?? defaultQaVal,
+			...modDataAttrs || {},
+			...htmlProps,
+			className,
+			style: mergedStyle,
+			isDisabled: isDisabled ?? htmlProps.disabled,
+			isHidden: isHidden ?? htmlProps.hidden,
+			isChecked: isChecked ?? htmlProps.checked,
+			ref
+		};
+		handleIsProperties(elementProps);
+		if (elementProps["data-qa"] === void 0) delete elementProps["data-qa"];
+		if (elementProps["data-qaval"] === void 0) delete elementProps["data-qaval"];
+		return createElement(tag, elementProps);
+	});
+	SubElement.displayName = `SubElement(${elementName})`;
+	return SubElement;
+}
+function createSubElements(elements) {
+	const subElements = {};
+	for (const [name, definition] of Object.entries(elements)) subElements[name] = createSubElement(name, definition);
+	return subElements;
+}
+const REACT_STATICS = /* @__PURE__ */ new Set([
+	"$$typeof",
+	"render",
+	"type",
+	"compare",
+	"displayName",
+	"defaultProps",
+	"propTypes",
+	"contextType",
+	"contextTypes",
+	"childContextTypes",
+	"getDerivedStateFromProps",
+	"getDerivedStateFromError"
+]);
+function hoistComponentStatics(target, source) {
+	for (const key of Object.keys(source)) {
+		if (REACT_STATICS.has(key) || key in target) continue;
+		const value = source[key];
+		if (typeof value !== "string" && isValidElementType(value)) target[key] = value;
+	}
+}
+function buildVariantStylesMap(defaultStyles, variants) {
+	let baseStyles = defaultStyles;
+	let extensionStyles;
+	if (defaultStyles) for (const key of Object.keys(defaultStyles)) {
+		if (isSelector(key)) continue;
+		const value = defaultStyles[key];
+		if (typeof value === "object" && value !== null && !Array.isArray(value) && !("" in value)) {
+			if (!extensionStyles) {
+				baseStyles = { ...defaultStyles };
+				extensionStyles = {};
+			}
+			extensionStyles[key] = value;
+			delete baseStyles[key];
+		}
+	}
+	const variantStylesMap = {};
+	for (const [variant, variantStyles] of Object.entries(variants)) variantStylesMap[variant] = extensionStyles ? mergeStyles(baseStyles, variantStyles, extensionStyles) : mergeStyles(baseStyles, variantStyles);
+	if (!variantStylesMap["default"]) variantStylesMap["default"] = defaultStyles;
+	return variantStylesMap;
+}
+function getMergedStyles(cache, base, extra) {
+	let entry = cache.get(extra);
+	if (!entry || entry.base !== base) {
+		entry = {
+			base,
+			styles: mergeStyles(base, extra)
+		};
+		cache.set(extra, entry);
+	}
+	return entry;
+}
+function takeProps(props, keys) {
+	let taken;
+	for (const key of keys) if (key in props) {
+		if (!taken) taken = {};
+		taken[key] = props[key];
+		delete props[key];
+	}
+	return taken;
+}
+function takeTokenProps(props, mapping) {
+	let tokens;
+	for (const [propName, tokenKey] of mapping) if (propName in props) {
+		if (!tokens) tokens = {};
+		tokens[tokenKey] = props[propName];
+		delete props[propName];
+	}
+	return tokens;
+}
+function getModPropsKeys(def) {
+	return Array.isArray(def) ? def : Object.keys(def);
+}
+function buildTokenPropsMapping(def) {
+	if (Array.isArray(def)) return def.map((propName) => {
+		if (propName.endsWith("Color") && propName.length > 5) return [propName, `#${propName.slice(0, -5)}`];
+		return [propName, `$${propName}`];
+	});
+	return Object.entries(def);
+}
+function tasty(Component, options) {
+	if (isValidElementType(Component)) return tastyWrap(Component, options);
+	return tastyElement(Component);
+}
+function tastyWrap(Component, options) {
+	const { as: extendTag, element: extendElement, styleProps, modProps: modPropsDef, tokenProps: tokenPropsDef, variants, variant: defaultVariant, elements, ...defaultProps } = options ?? {};
+	const defaultStyles = defaultProps.styles;
+	const variantStylesMap = variants ? buildVariantStylesMap(defaultStyles, variants) : void 0;
+	const fallbackVariant = defaultVariant ?? "default";
+	const stylePropNames = styleProps;
+	const modPropsKeys = modPropsDef ? getModPropsKeys(modPropsDef) : void 0;
+	const tokenPropsMapping = tokenPropsDef ? buildTokenPropsMapping(tokenPropsDef) : void 0;
+	const propsWithStyles = ["styles"];
+	for (const prop of Object.keys(defaultProps)) if (prop.endsWith("Styles")) propsWithStyles.push(prop);
+	const mergedCache = /* @__PURE__ */ new WeakMap();
+	const _WrappedComponent = forwardRef((props, ref) => {
+		const { as, element, ...restProps } = props;
+		const propStyles = stylePropNames ? takeProps(restProps, stylePropNames) : void 0;
+		const propMods = modPropsKeys ? takeProps(restProps, modPropsKeys) : void 0;
+		const propTokens = tokenPropsMapping ? takeTokenProps(restProps, tokenPropsMapping) : void 0;
+		const variant = restProps.variant ?? defaultVariant;
+		const baseStyles = variantStylesMap ? variantStylesMap[variant || fallbackVariant] ?? variantStylesMap[fallbackVariant] ?? variantStylesMap["default"] : defaultStyles;
+		const mergedStylesMap = {};
+		for (const prop of propsWithStyles) {
+			const restValue = restProps[prop];
+			const defaultValue = prop === "styles" ? baseStyles : defaultProps[prop];
+			mergedStylesMap[prop] = restValue != null && defaultValue != null ? getMergedStyles(mergedCache, defaultValue, restValue).styles : restValue ?? defaultValue;
+		}
+		if (propStyles) mergedStylesMap.styles = mergeStyles(mergedStylesMap.styles, propStyles);
+		const elementProps = {
+			...defaultProps,
+			...restProps,
+			...mergedStylesMap,
+			as: as ?? extendTag,
+			element: element || extendElement,
+			ref
+		};
+		if (variant !== void 0) elementProps.variant = variant;
+		if (propMods) elementProps.mods = {
+			...elementProps.mods,
+			...propMods
+		};
+		if (propTokens) elementProps.tokens = {
+			...elementProps.tokens,
+			...propTokens
+		};
+		return createElement(Component, elementProps);
+	});
+	_WrappedComponent.displayName = `TastyWrappedComponent(${getDisplayName(Component, defaultProps.qa ?? extendTag ?? "Anonymous")})`;
+	hoistComponentStatics(_WrappedComponent, Component);
+	if (elements) Object.assign(_WrappedComponent, createSubElements(elements));
+	return _WrappedComponent;
+}
+function tastyElement(tastyOptions) {
+	const { as: originalAs = "div", element: defaultElement, styles: defaultStyles, styleProps, modProps: modPropsDef, tokenProps: tokenPropsDef, variants, variant: defaultVariant, tokens: defaultTokens, elements, ...defaultProps } = tastyOptions;
+	const variantStylesMap = variants ? buildVariantStylesMap(defaultStyles, variants) : void 0;
+	const fallbackStyles = variantStylesMap ? variantStylesMap[defaultVariant ?? "default"] ?? variantStylesMap["default"] : defaultStyles;
+	const { qa: defaultQa, qaVal: defaultQaVal, ...otherDefaultProps } = defaultProps;
+	const ownPropsToCheck = styleProps ? styleProps.concat(BASE_STYLES) : BASE_STYLES;
+	let propsToCheck = ownPropsToCheck;
+	let propsToCheckVersion = -1;
+	const modPropsKeys = modPropsDef ? getModPropsKeys(modPropsDef) : void 0;
+	const tokenPropsMapping = tokenPropsDef ? buildTokenPropsMapping(tokenPropsDef) : void 0;
+	let classNameCache = /* @__PURE__ */ new Map();
+	let mergedCache = /* @__PURE__ */ new WeakMap();
+	let cacheInjector;
+	let cacheEvictions = 0;
+	const STABLE_STYLES = { stableStyles: true };
+	const _TastyComponent = forwardRef((incomingProps, ref) => {
+		const applyPropHandlers = propHandlerRegistry.apply;
+		const { as, styles: rawStyles, variant, mods, element, qa, qaVal, className: userClassName, tokens, style, theme, ...otherProps } = applyPropHandlers ? applyPropHandlers(incomingProps) : incomingProps;
+		const styles = rawStyles;
+		let propStyles = null;
+		if (propsToCheckVersion !== baseStylePropsRegistry.version) {
+			const promoted = baseStylePropsRegistry.list;
+			propsToCheck = promoted.length === 0 ? ownPropsToCheck : ownPropsToCheck.concat(promoted);
+			propsToCheckVersion = baseStylePropsRegistry.version;
+		}
+		for (const prop of propsToCheck) {
+			const key = prop;
+			if (key in otherProps) {
+				if (!propStyles) propStyles = {};
+				const value = otherProps[key];
+				propStyles[key] = value;
+				delete otherProps[key];
+			}
+		}
+		const propMods = modPropsKeys ? takeProps(otherProps, modPropsKeys) : void 0;
+		const propTokens = tokenPropsMapping ? takeTokenProps(otherProps, tokenPropsMapping) : void 0;
+		const baseStyles = variantStylesMap ? variant && variantStylesMap[variant] || fallbackStyles : defaultStyles;
+		const hasInstanceStyles = !!styles && hasKeys(styles);
+		const useFactoryCache = typeof document !== "undefined";
+		if (useFactoryCache) {
+			const injector = getGlobalInjector();
+			if (injector !== cacheInjector || injector.evictions !== cacheEvictions) {
+				classNameCache = /* @__PURE__ */ new Map();
+				mergedCache = /* @__PURE__ */ new WeakMap();
+				cacheInjector = injector;
+				cacheEvictions = injector.evictions;
+			}
+		}
+		let allStyles;
+		let generatedClassName;
+		let mergedEntry;
+		if (propStyles) allStyles = mergeStyles(baseStyles, styles, propStyles);
+		else if (hasInstanceStyles) {
+			if (useFactoryCache) {
+				mergedEntry = getMergedStyles(mergedCache, baseStyles, styles);
+				allStyles = mergedEntry.styles;
+				generatedClassName = mergedEntry.className;
+			} else allStyles = mergeStyles(baseStyles, styles);
+		} else {
+			allStyles = baseStyles;
+			if (useFactoryCache) generatedClassName = classNameCache.get(baseStyles);
+		}
+		let rscCSS;
+		if (generatedClassName !== void 0) touch(generatedClassName);
+		else {
+			const result = computeStyles(allStyles, !useFactoryCache && allStyles === baseStyles ? STABLE_STYLES : void 0);
+			generatedClassName = result.className;
+			rscCSS = result.css;
+			if (mergedEntry) mergedEntry.className = generatedClassName;
+			else if (useFactoryCache && allStyles === baseStyles) classNameCache.set(allStyles, generatedClassName);
+		}
+		let mergedTokens;
+		if (defaultTokens || tokens || propTokens) {
+			if (!defaultTokens && !propTokens) mergedTokens = tokens;
+			else if (!tokens && !propTokens) mergedTokens = defaultTokens;
+			else mergedTokens = {
+				...defaultTokens,
+				...tokens,
+				...propTokens
+			};
+		}
+		const processedTokenStyle = processTokens(mergedTokens);
+		let mergedStyle;
+		if (processedTokenStyle || style) {
+			if (!processedTokenStyle) mergedStyle = style;
+			else if (!style) mergedStyle = processedTokenStyle;
+			else mergedStyle = {
+				...processedTokenStyle,
+				...style
+			};
+		}
+		const mergedMods = propMods ? {
+			...mods,
+			...propMods
+		} : mods;
+		let modDataAttrs;
+		if (mergedMods) modDataAttrs = modAttrs(mergedMods);
+		let finalClassName = generatedClassName;
+		if (userClassName) finalClassName = finalClassName ? `${userClassName} ${finalClassName}` : userClassName;
+		const elementProps = {
+			"data-element": element || defaultElement,
+			"data-qa": qa || defaultQa,
+			"data-qaval": qaVal || defaultQaVal,
+			"data-theme": theme,
+			...otherDefaultProps,
+			...modDataAttrs || {},
+			...otherProps,
+			className: finalClassName,
+			style: mergedStyle,
+			ref
+		};
+		handleIsProperties(elementProps);
+		if (elementProps["data-theme"] === void 0) delete elementProps["data-theme"];
+		const el = createElement(as ?? originalAs, elementProps);
+		if (rscCSS) {
+			checkRequestScope();
+			const nonce = getConfig().nonce;
+			return createElement(Fragment, null, createElement("style", {
+				"data-tasty-rsc": "",
+				nonce,
+				dangerouslySetInnerHTML: { __html: rscCSS }
+			}), el);
+		}
+		return el;
+	});
+	_TastyComponent.displayName = `TastyComponent(${defaultProps.qa || originalAs})`;
+	if (elements) return Object.assign(_TastyComponent, createSubElements(elements));
+	return _TastyComponent;
+}
+const Element = /* @__PURE__ */ tasty({});
+//#endregion
+//#region src/ssr/context.ts
+let _ctx;
+function getTastySSRContext() {
+	if (!_ctx) _ctx = React.createContext(null);
+	return _ctx;
+}
+//#endregion
+//#region src/hooks/useStyles.ts
+const useContextCollector = typeof React.useContext === "function" ? () => React.useContext(getTastySSRContext()) : () => null;
+function useStyles(styles, options) {
+	const result = computeStyles(styles, {
+		ssrCollector: useContextCollector(),
+		root: options?.root
+	});
+	if (result.css) {
+		checkRequestScope();
+		queueRSCCSS(getRSCCache(), result.css);
+		return { className: result.className };
+	}
+	return result;
+}
+//#endregion
+//#region src/hooks/useGlobalStyles.ts
+const getClientGlobalSlots = /* @__PURE__ */ createClientState(() => /* @__PURE__ */ new Map());
+const noop = () => {};
+function useGlobalStyles(selector, styles, options) {
+	if (!styles) return;
+	if (!selector) {
+		if (process.env.NODE_ENV !== "production") console.warn("[Tasty] useGlobalStyles: selector is required and cannot be empty. Styles will not be injected.");
+		return;
+	}
+	const target = getStyleTarget();
+	const slots = target.mode === "client" ? getClientGlobalSlots(options?.root ?? document) : null;
+	const slotKey = options?.id ?? selector;
+	const stylesKey = slots ? JSON.stringify(styles) : "";
+	const existing = slots?.get(slotKey);
+	if (existing && existing.stylesKey === stylesKey) return;
+	const resolvedStyles = resolveRecipes(styles);
+	const rendered = renderStyles(resolvedStyles, selector);
+	if (rendered.length === 0) {
+		if (slots) {
+			existing?.dispose();
+			slots.set(slotKey, {
+				stylesKey,
+				dispose: noop
+			});
+		}
+		return;
+	}
+	const { rules: styleResults, keyframes } = resolveSelectorKeyframes(resolvedStyles, rendered, getGlobalKeyframes());
+	if (target.mode === "ssr") {
+		target.collector.collectInternals();
+		if (keyframes) for (const [name, steps] of keyframes) target.collector.collectKeyframes(name, formatKeyframesCSS(name, steps));
+		const css = formatGlobalRules(styleResults);
+		if (css) {
+			const key = options?.id ? `global:${options.id}` : `global:${selector}:${hashString(css)}`;
+			target.collector.collectGlobalStyles(key, css, options?.id != null);
+		}
+		if (getConfig().autoPropertyTypes !== false) collectAutoInferredProperties(styleResults, target.collector, resolvedStyles);
+		return;
+	}
+	if (target.mode === "rsc") {
+		if (keyframes) for (const [name, steps] of keyframes) pushRSCCSS(target.cache, `__kf:${name}`, formatKeyframesCSS(name, steps));
+		const css = formatGlobalRules(styleResults);
+		if (css) {
+			const key = options?.id ? `__global:${options.id}` : `__global:${selector}:${hashString(css)}`;
+			pushRSCCSS(target.cache, key, css, options?.id != null);
+		}
+		if (getConfig().autoPropertyTypes !== false) collectAutoInferredPropertiesRSC(styleResults, target.cache, resolvedStyles);
+		return;
+	}
+	if (slots) {
+		const releaseKeyframes = holdKeyframes(keyframes, options?.root);
+		existing?.dispose();
+		const { dispose } = injectGlobal(styleResults, { root: options?.root });
+		slots.set(slotKey, {
+			stylesKey,
+			dispose: () => {
+				dispose();
+				releaseKeyframes();
+			}
+		});
+	}
+}
+function holdKeyframes(keyframes, root) {
+	if (!keyframes) return noop;
+	const injector = getGlobalInjector();
+	const disposers = [...keyframes].map(([name, steps]) => injector.keyframes(steps, {
+		name,
+		root,
+		distinctByName: true
+	}).dispose);
+	return () => {
+		for (const dispose of disposers) dispose();
+	};
+}
+//#endregion
+//#region src/hooks/useRawCSS.ts
+const getClientState$1 = /* @__PURE__ */ createClientState(() => ({
+	entries: /* @__PURE__ */ new Map(),
+	dedup: /* @__PURE__ */ new Set(),
+	deps: /* @__PURE__ */ new Map()
+}));
+function useRawCSS(cssOrFactory, depsOrOptions, options) {
+	const isFactory = typeof cssOrFactory === "function";
+	const deps = isFactory && Array.isArray(depsOrOptions) ? depsOrOptions : void 0;
+	const opts = isFactory ? options : depsOrOptions;
+	const id = opts?.id;
+	const target = getStyleTarget();
+	const state = target.mode === "client" ? getClientState$1(opts?.root ?? document) : null;
+	if (isFactory && deps && id && state) {
+		const cachedDeps = state.deps.get(id);
+		if (cachedDeps && depsEqual(cachedDeps, deps)) return;
+	}
+	const css = isFactory ? cssOrFactory() : cssOrFactory;
+	if (!css.trim()) return;
+	if (target.mode !== "client") {
+		const key = `${target.mode === "rsc" ? "__" : ""}raw:${id || hashString(css)}`;
+		const replace = id != null;
+		if (target.mode === "ssr") target.collector.collectRawCSS(key, css, replace);
+		else pushRSCCSS(target.cache, key, css, replace);
+		return;
+	}
+	if (!state) return;
+	if (id) {
+		const existing = state.entries.get(id);
+		if (existing) {
+			if (existing.css === css) return;
+			existing.dispose();
+		}
+		const { dispose } = injectRawCSS(css, opts);
+		state.entries.set(id, {
+			css,
+			dispose
+		});
+		if (deps) state.deps.set(id, deps);
+	} else {
+		const contentKey = hashString(css);
+		if (state.dedup.has(contentKey)) return;
+		state.dedup.add(contentKey);
+		injectRawCSS(css, opts);
+	}
+}
+//#endregion
+//#region src/hooks/useKeyframes.ts
+const getClientState = /* @__PURE__ */ createClientState(() => ({
+	contentToName: /* @__PURE__ */ new Map(),
+	namedSlots: /* @__PURE__ */ new Map(),
+	factoryDeps: /* @__PURE__ */ new Map()
+}));
+function useKeyframes(stepsOrFactory, depsOrOptions, options) {
+	const isFactory = typeof stepsOrFactory === "function";
+	const deps = isFactory && Array.isArray(depsOrOptions) ? depsOrOptions : void 0;
+	const opts = isFactory ? options : depsOrOptions;
+	const target = getStyleTarget();
+	const clientState = target.mode === "client" ? getClientState(opts?.root ?? document) : null;
+	if (isFactory && deps && opts?.name && clientState) {
+		const cached = clientState.factoryDeps.get(opts.name);
+		if (cached && depsEqual(cached.deps, deps)) return cached.name;
+	}
+	const steps = isFactory ? stepsOrFactory() : stepsOrFactory;
+	if (!steps || Object.keys(steps).length === 0) return "";
+	if (target.mode === "ssr") {
+		const actualName = target.collector.allocateKeyframeName(opts?.name);
+		const css = formatKeyframesCSS(actualName, steps);
+		target.collector.collectKeyframes(actualName, css);
+		return actualName;
+	}
+	if (target.mode === "rsc") {
+		const serializedContent = JSON.stringify(steps);
+		const key = `__kf:${opts?.name ?? ""}:${serializedContent}`;
+		const existingName = target.cache.generatedNames.get(key);
+		if (existingName) return existingName;
+		const actualName = opts?.name ?? makeKeyframeName(getNamePrefix(), hashString(serializedContent));
+		const css = formatKeyframesCSS(actualName, steps);
+		pushRSCCSS(target.cache, key, css);
+		target.cache.generatedNames.set(key, actualName);
+		return actualName;
+	}
+	const state = clientState ?? getClientState(opts?.root ?? document);
+	const serializedContent = JSON.stringify(steps);
+	const cacheKey = `${opts?.name ?? ""}:${serializedContent}`;
+	const cachedName = state.contentToName.get(cacheKey);
+	if (cachedName) return cachedName;
+	const providedName = opts?.name;
+	if (providedName) {
+		const slot = state.namedSlots.get(providedName);
+		if (slot && slot.cacheKey !== cacheKey) {
+			slot.dispose();
+			state.contentToName.delete(slot.cacheKey);
+			state.namedSlots.delete(providedName);
+		}
+	}
+	const result = keyframes(steps, {
+		name: providedName,
+		root: opts?.root
+	});
+	const name = result.toString();
+	state.contentToName.set(cacheKey, name);
+	if (providedName) {
+		state.namedSlots.set(providedName, {
+			cacheKey,
+			dispose: result.dispose
+		});
+		if (deps) state.factoryDeps.set(providedName, {
+			deps,
+			name
+		});
+	}
+	return name;
+}
+//#endregion
+//#region src/hooks/useProperty.ts
+function useProperty(name, options) {
+	if (!name) {
+		if (process.env.NODE_ENV !== "production") console.warn(`[Tasty] useProperty: property name is required`);
+		return;
+	}
+	const target = getStyleTarget();
+	if (target.mode === "ssr") {
+		target.collector.collectInternals();
+		const css = formatPropertyCSS(name, {
+			syntax: options?.syntax,
+			inherits: options?.inherits,
+			initialValue: options?.initialValue
+		});
+		if (css) target.collector.collectProperty(name, css);
+		return;
+	}
+	if (target.mode === "rsc") {
+		const css = formatPropertyCSS(name, {
+			syntax: options?.syntax,
+			inherits: options?.inherits,
+			initialValue: options?.initialValue
+		});
+		if (css) pushRSCCSS(target.cache, `__prop:${name}`, css);
+		return;
+	}
+	const injector = getGlobalInjector();
+	if (injector.isPropertyDefined(name, { root: options?.root })) return;
+	injector.property(name, {
+		syntax: options?.syntax,
+		inherits: options?.inherits,
+		initialValue: options?.initialValue,
+		root: options?.root
+	});
+}
+//#endregion
+//#region src/hooks/useFontFace.ts
+function useFontFace(family, input, options) {
+	if (!family) return;
+	const descriptors = Array.isArray(input) ? input : [input];
+	const target = getStyleTarget();
+	if (target.mode === "ssr") {
+		for (const desc of descriptors) {
+			const hash = fontFaceContentHash(family, desc);
+			const css = formatFontFaceRule(family, desc);
+			target.collector.collectFontFace(hash, css);
+		}
+		return;
+	}
+	if (target.mode === "rsc") {
+		for (const desc of descriptors) {
+			const hash = fontFaceContentHash(family, desc);
+			const css = formatFontFaceRule(family, desc);
+			pushRSCCSS(target.cache, `__ff:${hash}`, css);
+		}
+		return;
+	}
+	const injector = getGlobalInjector();
+	for (const desc of descriptors) injector.fontFace(family, desc, { root: options?.root });
+}
+//#endregion
+//#region src/hooks/useCounterStyle.ts
+let clientCounterStyleCounter = 0;
+const getClientContentToName = /* @__PURE__ */ createClientState(() => /* @__PURE__ */ new Map());
+function useCounterStyle(descriptors, options) {
+	if (!descriptors || !descriptors.system) return "";
+	const target = getStyleTarget();
+	if (target.mode === "ssr") {
+		const actualName = target.collector.allocateCounterStyleName(options?.name);
+		const css = formatCounterStyleRule(actualName, descriptors);
+		target.collector.collectCounterStyle(actualName, css);
+		return actualName;
+	}
+	if (target.mode === "rsc") {
+		const serializedContent = JSON.stringify(descriptors);
+		const key = `__cs:${options?.name ?? ""}:${serializedContent}`;
+		const existingName = target.cache.generatedNames.get(key);
+		if (existingName) return existingName;
+		const actualName = options?.name ?? makeCounterStyleName(getNamePrefix(), hashString(serializedContent));
+		const css = formatCounterStyleRule(actualName, descriptors);
+		pushRSCCSS(target.cache, key, css);
+		target.cache.generatedNames.set(key, actualName);
+		return actualName;
+	}
+	const contentToName = getClientContentToName(options?.root ?? document);
+	const serializedContent = JSON.stringify(descriptors);
+	const cacheKey = `${options?.name ?? ""}:${serializedContent}`;
+	const existingName = contentToName.get(cacheKey);
+	if (existingName) return existingName;
+	const name = options?.name ?? makeCounterStyleName(getNamePrefix(), String(clientCounterStyleCounter++));
+	contentToName.set(cacheKey, name);
+	getGlobalInjector().counterStyle(name, descriptors, { root: options?.root });
+	return name;
+}
+//#endregion
+//#region src/hooks/useFunction.ts
+function useFunction(name, definition, options) {
+	if (!name) {
+		if (process.env.NODE_ENV !== "production") console.warn(`[Tasty] useFunction: function name is required`);
+		return;
+	}
+	if (isFunctionsPolyfillEnabled()) {
+		registerFunctionPolyfill(name, definition);
+		return;
+	}
+	const target = getStyleTarget();
+	if (target.mode === "ssr") {
+		target.collector.collectInternals();
+		const css = formatFunctionRule(name, definition);
+		if (css) target.collector.collectFunction(parseFunctionName(name), css);
+		return;
+	}
+	if (target.mode === "rsc") {
+		const css = formatFunctionRule(name, definition);
+		if (css) pushRSCCSS(target.cache, `__func:${parseFunctionName(name)}`, css);
+		return;
+	}
+	getGlobalInjector().func(name, definition, { root: options?.root });
+}
+//#endregion
+//#region src/batch-provider.tsx
+function TastyBatchProvider({ children }) {
+	openBatchWindow();
+	React.useInsertionEffect(() => {
+		closeBatchWindow();
+	});
+	return children;
+}
+//#endregion
+export { useProperty as a, useGlobalStyles as c, Element as d, tasty as f, useFontFace as i, useStyles as l, useFunction as n, useKeyframes as o, getDisplayName as p, useCounterStyle as r, useRawCSS as s, TastyBatchProvider as t, getTastySSRContext as u };
+
+//# sourceMappingURL=react-runtime-DayjnPuC.js.map