@tenphi/tasty 0.0.0-snapshot.bbd10c7 → 0.0.0-snapshot.bbfcd75

package/dist/chunks/react-runtime-O-OUrKLH.js

@@ -0,0 +1,557 @@
+import { n as isSelector, t as mergeStyles } from "./shared-utils-DWA4LjIa.js";
+import { D as makeKeyframeName, E as makeCounterStyleName, U as parseFunctionName, V as formatFunctionRule, W as registerFunctionPolyfill, a as formatPropertyCSS, b as formatFontFaceRule, h as formatCounterStyleRule, i as formatKeyframesCSS, j as hashString, n as formatGlobalRules, v as fontFaceContentHash } from "./css-definitions-D_it4XZH.js";
+import { U as isFunctionsPolyfillEnabled, b as renderStyles, i as baseStylePropsRegistry, s as BASE_STYLES } from "./style-engine-C1ECBZxR.js";
+import { $ as propHandlerRegistry, B as getNamePrefix, E as injectRawCSS, I as getConfig, J as closeBatchWindow, L as getGlobalInjector, M as touch, T as injectGlobal, Z as openBatchWindow, c as hasKeys, d as getStyleTarget, f as pushRSCCSS, i as modAttrs, k as keyframes, l as collectAutoInferredProperties, n as createClientState, o as computeStyles, r as processTokens, s as resolveRecipes, t as depsEqual, u as collectAutoInferredPropertiesRSC } from "./runtime-engine-DvnE2g-E.js";
+import { Fragment, createContext, createElement, forwardRef, useContext, useInsertionEffect } from "react";
+//#region src/utils/get-display-name.ts
+const DEFAULT_NAME = "Anonymous";
+function getDisplayName(Component, fallbackName = DEFAULT_NAME) {
+	if (typeof Component === "function") return Component.displayName ?? Component.name ?? fallbackName;
+	return 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 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: _styleProps, modProps: _modProps, tokenProps: _tokenProps, variants: _variants, elements: _elements, ...defaultProps } = options ?? {};
+	const propsWithStyles = ["styles"];
+	for (const prop of Object.keys(defaultProps)) if (prop.endsWith("Styles")) propsWithStyles.push(prop);
+	const _WrappedComponent = forwardRef((props, ref) => {
+		const { as, element, ...restProps } = props;
+		const mergedStylesMap = {};
+		for (const prop of propsWithStyles) {
+			const restValue = restProps[prop];
+			const defaultValue = defaultProps[prop];
+			mergedStylesMap[prop] = restValue != null && defaultValue != null ? mergeStyles(defaultValue, restValue) : restValue ?? defaultValue;
+		}
+		return createElement(Component, {
+			...defaultProps,
+			...restProps,
+			...mergedStylesMap,
+			as: as ?? extendTag,
+			element: element || extendElement,
+			ref
+		});
+	});
+	_WrappedComponent.displayName = `TastyWrappedComponent(${getDisplayName(Component, defaultProps.qa ?? extendTag ?? "Anonymous")})`;
+	return _WrappedComponent;
+}
+function tastyElement(tastyOptions) {
+	const { as: originalAs = "div", element: defaultElement, styles: defaultStyles, styleProps, modProps: modPropsDef, tokenProps: tokenPropsDef, variants, tokens: defaultTokens, elements, ...defaultProps } = tastyOptions;
+	let variantStylesMap;
+	if (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];
+			}
+		}
+		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;
+	}
+	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 ? Array.isArray(modPropsDef) ? modPropsDef : Object.keys(modPropsDef) : void 0;
+	const tokenPropsMapping = tokenPropsDef ? buildTokenPropsMapping(tokenPropsDef) : void 0;
+	const classNameCache = /* @__PURE__ */ new Map();
+	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];
+			}
+		}
+		let propMods;
+		if (modPropsKeys) {
+			for (const key of modPropsKeys) if (key in otherProps) {
+				if (!propMods) propMods = {};
+				propMods[key] = otherProps[key];
+				delete otherProps[key];
+			}
+		}
+		let propTokens;
+		if (tokenPropsMapping) {
+			for (const [propName, tokenKey] of tokenPropsMapping) if (propName in otherProps) {
+				if (!propTokens) propTokens = {};
+				propTokens[tokenKey] = otherProps[propName];
+				delete otherProps[propName];
+			}
+		}
+		const baseStyles = variantStylesMap ? variantStylesMap[variant || "default"] ?? variantStylesMap["default"] : defaultStyles;
+		const allStyles = styles && hasKeys(styles) || !!propStyles ? mergeStyles(baseStyles, styles, propStyles) : baseStyles;
+		const useFactoryCache = typeof document !== "undefined";
+		let generatedClassName = useFactoryCache && allStyles === baseStyles ? classNameCache.get(allStyles) : void 0;
+		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 (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) {
+			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) {
+		const subElements = {};
+		for (const [name, definition] of Object.entries(elements)) subElements[name] = createSubElement(name, definition);
+		return Object.assign(_TastyComponent, subElements);
+	}
+	return _TastyComponent;
+}
+const Element = /* @__PURE__ */ tasty({});
+//#endregion
+//#region src/ssr/context.ts
+let _ctx;
+function getTastySSRContext() {
+	if (!_ctx) _ctx = createContext(null);
+	return _ctx;
+}
+//#endregion
+//#region src/hooks/useStyles.ts
+function useStyles(styles, options) {
+	return computeStyles(styles, {
+		ssrCollector: useContext(getTastySSRContext()),
+		root: options?.root
+	});
+}
+//#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) {
+		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 styleResults = renderStyles(resolvedStyles, selector);
+	if (styleResults.length === 0) {
+		if (slots) {
+			existing?.dispose();
+			slots.set(slotKey, {
+				stylesKey,
+				dispose: noop
+			});
+		}
+		return;
+	}
+	if (target.mode === "ssr") {
+		target.collector.collectInternals();
+		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") {
+		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) {
+		existing?.dispose();
+		const { dispose } = injectGlobal(styleResults, { root: options?.root });
+		slots.set(slotKey, {
+			stylesKey,
+			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) {
+		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) {
+		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();
+	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-O-OUrKLH.js.map