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

package/dist/zero/babel.d.ts

@@ -1,182 +1,2 @@
-import { CounterStyleDescriptors, FontFaceInput, KeyframesSteps } from "../injector/types.js";
-import { StyleDetails, UnitHandler } from "../parser/types.js";
-import { StyleHandlerDefinition } from "../utils/styles.js";
-import { ConfigTokens, RecipeStyles } from "../styles/types.js";
-import { TastyPlugin } from "../plugins/types.js";
-import * as _$_babel_core0 from "@babel/core";
-import { PluginPass } from "@babel/core";
-
-//#region src/zero/babel.d.ts
-/**
- * Build-time configuration for zero-runtime mode.
- * Subset of TastyConfig that applies at build time.
- */
-interface TastyZeroConfig {
-  /**
-   * Global predefined states for advanced state mapping.
-   * Example: { '@mobile': '@media(w < 768px)', '@dark': '@root(theme=dark)' }
-   */
-  states?: Record<string, string>;
-  /**
-   * Enable development mode features: source comments in generated CSS.
-   * Default: false
-   */
-  devMode?: boolean;
-  /**
-   * Parser LRU cache size (default: 1000).
-   * Larger values improve performance for builds with many unique style values.
-   */
-  parserCacheSize?: number;
-  /**
-   * Custom units for the style parser (merged with built-in units).
-   * Units transform numeric values like `2x` → `calc(2 * var(--gap))`.
-   * @example { em: 'em', vw: 'vw', custom: (n) => `${n * 10}px` }
-   */
-  units?: Record<string, string | UnitHandler>;
-  /**
-   * Custom functions for the style parser (merged with existing).
-   * Functions process parsed style groups and return CSS values.
-   * @example { myFunc: (groups) => groups.map(g => g.output).join(' ') }
-   */
-  funcs?: Record<string, (groups: StyleDetails[]) => string>;
-  /**
-   * Plugins that extend tasty with custom functions, units, states, and handlers.
-   * Plugins are processed in order, with later plugins overriding earlier ones.
-   * @example
-   * ```ts
-   * import { okhslPlugin } from '@tenphi/tasty';
-   *
-   * // babel.config.js
-   * module.exports = {
-   *   plugins: [
-   *     ['@tenphi/tasty/babel-plugin', {
-   *       config: { plugins: [okhslPlugin()] }
-   *     }]
-   *   ]
-   * };
-   * ```
-   */
-  plugins?: TastyPlugin[];
-  /**
-   * Global keyframes definitions for static extraction.
-   * Keys are animation names, values are keyframes step definitions.
-   * @example { fadeIn: { from: { opacity: 0 }, to: { opacity: 1 } } }
-   */
-  keyframes?: Record<string, KeyframesSteps>;
-  /**
-   * Global @font-face definitions for static extraction.
-   * Keys are font-family names, values are descriptors or arrays of descriptors.
-   */
-  fontFace?: Record<string, FontFaceInput>;
-  /**
-   * Global @counter-style definitions for static extraction.
-   * Keys are counter-style names, values are descriptor objects.
-   */
-  counterStyle?: Record<string, CounterStyleDescriptors>;
-  /**
-   * Custom style handlers that transform style properties into CSS declarations.
-   * Handlers replace built-in handlers for the same style name.
-   * @example
-   * ```ts
-   * handlers: {
-   *   fill: ({ fill }) => fill ? { 'background-color': fill } : undefined,
-   *   elevation: ({ elevation }) => ({
-   *     'box-shadow': `0 ${elevation}px ${elevation * 2}px rgba(0,0,0,0.1)`,
-   *   }),
-   * }
-   * ```
-   */
-  handlers?: Record<string, StyleHandlerDefinition>;
-  /**
-   * Design tokens injected as CSS custom properties on `:root`.
-   * Values are parsed through the Tasty DSL. Supports state maps.
-   * @example { '$gap': '4px', '#primary': { '': '#purple', '@dark': '#light-purple' } }
-   */
-  tokens?: ConfigTokens;
-  /**
-   * Predefined tokens replaced during style parsing (parse-time substitution).
-   * Use `$name` for custom properties and `#name` for color tokens.
-   * @example { $spacing: '2x', '#accent': '#purple' }
-   */
-  replaceTokens?: Record<`$${string}` | `#${string}`, string | number>;
-  /**
-   * Predefined style recipes -- named style bundles that can be applied via `recipe` style property.
-   * Recipe values are flat tasty styles (no sub-element keys).
-   * @example
-   * ```ts
-   * recipes: {
-   *   card: { padding: '4x', fill: '#surface', radius: '1r', border: true },
-   *   elevated: { shadow: '2x 2x 4x #shadow' },
-   * }
-   * ```
-   */
-  recipes?: Record<string, RecipeStyles>;
-  /**
-   * Automatically infer and register CSS @property declarations from values.
-   * @default true
-   */
-  autoPropertyTypes?: boolean;
-}
-interface TastyZeroBabelOptions {
-  /** Output path for generated CSS (default: 'tasty.css') */
-  output?: string;
-  /**
-   * Tasty configuration for build-time processing.
-   * Can be a static object or a factory function that returns fresh config.
-   * A factory is called on each plugin invocation, enabling hot reload
-   * of config values that depend on external files (e.g. theme tokens).
-   */
-  config?: TastyZeroConfig | (() => TastyZeroConfig);
-  /**
-   * Absolute path to a TypeScript/JavaScript module that default-exports
-   * a `TastyZeroConfig` object. The module is loaded via jiti on each
-   * plugin invocation, enabling hot reload when the file changes.
-   *
-   * This option is JSON-serializable and is the primary way Turbopack
-   * passes config to the Babel plugin (since Turbopack loader options
-   * must be plain primitives/objects/arrays).
-   *
-   * When both `config` and `configFile` are set, `config` takes precedence.
-   *
-   * @example '/absolute/path/to/tasty-zero.config.ts'
-   */
-  configFile?: string;
-  /**
-   * Absolute file paths whose content affects the generated CSS.
-   * When any of these files change, babel-loader invalidates its cache
-   * and re-runs the plugin with fresh config values.
-   *
-   * Typically includes theme files that define Glaze palettes or token values.
-   * Paths must be absolute (resolved by the Next.js wrapper).
-   */
-  configDeps?: string[];
-  /**
-   * Automatically replace `@tenphi/tasty/static` imports with an import
-   * of the generated CSS file. This eliminates the need for users to
-   * manually import the CSS in their app entry point.
-   *
-   * @default true
-   */
-  injectImport?: boolean;
-  /**
-   * Output mode for extracted CSS.
-   *
-   * - `'file'` (default): CSS is written to a single output file and
-   *   the `@tenphi/tasty/static` import is rewritten to import that file.
-   * - `'inject'`: CSS is embedded inline in the JS output and injected
-   *   at runtime via a tiny injector from `@tenphi/tasty/static/inject`.
-   *   No CSS file is written. Each `tastyStatic` call becomes
-   *   self-contained. Best for reusable components and extensions.
-   *
-   * When `mode` is `'inject'`, `output` and `injectImport` are ignored.
-   *
-   * @default 'file'
-   */
-  mode?: 'file' | 'inject';
-}
-/** Clear the shared CSSWriter cache. Exposed for testing. */
-declare function clearWriterCache(): void;
-declare const _default: (api: object, options: TastyZeroBabelOptions | null | undefined, dirname: string) => _$_babel_core0.PluginObj<PluginPass>;
-//#endregion
-export { TastyZeroBabelOptions, TastyZeroConfig, clearWriterCache, _default as default };
-//# sourceMappingURL=babel.d.ts.map
+import { n as _default, r as TastyZeroConfig, t as TastyZeroBabelOptions } from "../babel-Zs1Q03qt.js";
+export { TastyZeroBabelOptions, type TastyZeroConfig, _default as default };

package/dist/zero/babel.js

@@ -1,33 +1,23 @@
-import { __require } from "../_virtual/_rolldown/runtime.js";
-import { configure, getGlobalConfigTokens, resetConfig } from "../config.js";
-import { mergeStyles } from "../utils/merge-styles.js";
-import { resolveRecipes } from "../utils/resolve-recipes.js";
-import { extractCounterStyleFromStyles, extractFontFaceFromStyles, extractKeyframesFromStyles, extractPropertiesFromStyles, extractStylesForSelector, extractStylesWithChunks } from "./extractor.js";
-import { CSSWriter } from "./css-writer.js";
+import { t as mergeStyles } from "../chunks/shared-utils-DWA4LjIa.js";
+import "../chunks/css-definitions-D_it4XZH.js";
+import { t as resolveRecipesWith } from "../chunks/config-engine-C3pF9EK9.js";
+import { a as extractFunctionsFromStyles, c as extractStylesForSelector, i as extractFontFaceFromStyles, l as extractStylesWithChunks, o as extractKeyframesFromStyles, r as extractCounterStyleFromStyles, s as extractPropertiesFromStyles, t as CSSWriter, u as setExtractorNamePrefix } from "../chunks/zero-engine-B6EnYcXY.js";
+import { n as functionsForExtraction, r as resetZeroConfig, t as configureZero } from "../chunks/build-config-CUQVwdWF.js";
 import * as fs from "fs";
 import * as path from "path";
 import { declare } from "@babel/helper-plugin-utils";
 import * as t from "@babel/types";
 import { createJiti } from "jiti";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+//#region src/zero/writer-cache.ts
+const writerCache = /* @__PURE__ */ new Map();
+//#endregion
 //#region src/zero/babel.ts
-/**
-* Babel plugin for zero-runtime tasty static site generation.
-*
-* Transforms:
-* - `tastyStatic(styles)` → StaticStyle object { className, styles, toString() }
-* - `tastyStatic(base, styles)` → StaticStyle object with merged styles
-* - `tastyStatic(selector, styles)` → removed entirely
-*
-* Usage:
-* ```javascript
-* // babel.config.js
-* module.exports = {
-*   plugins: [
-*     ['@tenphi/tasty/babel-plugin', { output: 'public/tasty.css' }]
-*   ]
-* };
-* ```
-*/
 function mtime(filePath) {
 	try {
 		return fs.statSync(filePath).mtimeMs;
@@ -50,11 +40,6 @@ function clearRequireCacheTree(filePath) {
 	}
 	delete __require.cache[resolved];
 }
-const writerCache = /* @__PURE__ */ new Map();
-/** Clear the shared CSSWriter cache. Exposed for testing. */
-function clearWriterCache() {
-	writerCache.clear();
-}
 var babel_default = declare((api, options) => {
 	api.assertVersion(7);
 	const mode = options.mode ?? "file";
@@ -80,37 +65,53 @@ var babel_default = declare((api, options) => {
 		const configOption = options.config;
 		let resolvedConfig;
 		if (configOption) resolvedConfig = typeof configOption === "function" ? configOption() : configOption;
-		else if (options.configFile) resolvedConfig = createJiti(path.dirname(options.configFile), { moduleCache: false })(options.configFile);
-		else resolvedConfig = {};
+		else if (options.configFile) {
+			const loaded = createJiti(path.dirname(options.configFile), { moduleCache: false })(options.configFile);
+			resolvedConfig = loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
+		} else resolvedConfig = {};
 		const devMode = resolvedConfig.devMode ?? false;
-		if (cached) resetConfig();
-		configure(resolvedConfig);
+		resetZeroConfig();
+		const finalConfig = {
+			namePrefix: "ts",
+			...resolvedConfig
+		};
+		const config = configureZero(finalConfig);
+		setExtractorNamePrefix(finalConfig.namePrefix ?? "ts");
 		const newWriter = new CSSWriter(outputPath, { devMode });
 		if (mode !== "inject") {
-			const tokenStyles = getGlobalConfigTokens();
-			if (tokenStyles && Object.keys(tokenStyles).length > 0) {
-				const result = extractStylesForSelector(":root", tokenStyles);
-				if (result.css) newWriter.add(":root:tokens", result.css);
+			const tokenCSS = extractCSSFromStyles(":root", config.normalized.tokens);
+			if (tokenCSS) newWriter.add(":root:tokens", tokenCSS);
+			for (const [selector, styles] of Object.entries(config.normalized.globalStyles)) {
+				const css = extractCSSFromStyles(selector, styles);
+				if (css) newWriter.add(`global:${selector}`, css);
 			}
 		}
 		writerCache.set(resolvedOutputPath, {
 			writer: newWriter,
 			configKey,
 			registry: {},
-			config: resolvedConfig
+			config
 		});
 	}
 	const entry = writerCache.get(resolvedOutputPath);
 	const cssWriter = entry.writer;
 	const globalRegistry = entry.registry;
 	const config = entry.config;
-	const devMode = config.devMode ?? false;
+	const sourceConfig = config.source;
+	const devMode = sourceConfig.devMode ?? false;
+	setExtractorNamePrefix(sourceConfig.namePrefix ?? "ts");
 	let tokenCSS;
+	let globalStylesCSS;
 	if (mode === "inject") {
-		const tokenStyles = getGlobalConfigTokens();
-		if (tokenStyles && Object.keys(tokenStyles).length > 0) {
-			const result = extractStylesForSelector(":root", tokenStyles);
-			if (result.css) tokenCSS = result.css;
+		tokenCSS = extractCSSFromStyles(":root", config.normalized.tokens);
+		const gs = config.normalized.globalStyles;
+		if (Object.keys(gs).length > 0) {
+			globalStylesCSS = /* @__PURE__ */ new Map();
+			for (const [selector, styles] of Object.entries(gs)) {
+				const css = extractCSSFromStyles(selector, styles);
+				if (css) globalStylesCSS.set(selector, css);
+			}
+			if (globalStylesCSS.size === 0) globalStylesCSS = void 0;
 		}
 	}
 	return {
@@ -141,9 +142,9 @@ var babel_default = declare((api, options) => {
 				const args = path.node.arguments;
 				if (args.length === 0) throw path.buildCodeFrameError("tastyStatic() requires at least one argument");
 				const firstArg = args[0];
-				if (t.isStringLiteral(firstArg)) handleSelectorMode(path, args, cssWriter, mode, state.sourceFile, config.keyframes, config.autoPropertyTypes, config.fontFace, config.counterStyle);
-				else if (t.isObjectExpression(firstArg)) handleStylesMode(path, args, cssWriter, state, globalRegistry, mode, config.keyframes, config.autoPropertyTypes, config.fontFace, config.counterStyle);
-				else if (t.isIdentifier(firstArg)) handleExtensionMode(path, args, cssWriter, state, globalRegistry, mode, config.keyframes, config.autoPropertyTypes, config.fontFace, config.counterStyle);
+				if (t.isStringLiteral(firstArg)) handleSelectorMode(path, args, cssWriter, mode, state.sourceFile, config.normalized.keyframes, sourceConfig.autoPropertyTypes, config.normalized.fontFaces, config.normalized.counterStyles, functionsForExtraction(config), config.normalized.recipes);
+				else if (t.isObjectExpression(firstArg)) handleStylesMode(path, args, cssWriter, state, globalRegistry, mode, config.normalized.keyframes, sourceConfig.autoPropertyTypes, config.normalized.fontFaces, config.normalized.counterStyles, functionsForExtraction(config), config.normalized.recipes);
+				else if (t.isIdentifier(firstArg)) handleExtensionMode(path, args, cssWriter, state, globalRegistry, mode, config.normalized.keyframes, sourceConfig.autoPropertyTypes, config.normalized.fontFaces, config.normalized.counterStyles, functionsForExtraction(config), config.normalized.recipes);
 				else throw path.buildCodeFrameError("tastyStatic() first argument must be an object (styles), identifier (base StaticStyle), or string (selector)");
 			},
 			VariableDeclarator(path, state) {
@@ -168,12 +169,20 @@ var babel_default = declare((api, options) => {
 		},
 		post() {
 			if (mode === "inject") {
-				if (this._fileAddedCSS && tokenCSS) {
+				if (this._fileAddedCSS && (tokenCSS || globalStylesCSS)) {
 					const program = this.file.ast.program;
-					const injectCall = createInjectCallAST(":root", tokenCSS);
 					let insertIndex = 0;
 					for (let i = 0; i < program.body.length; i++) if (t.isImportDeclaration(program.body[i])) insertIndex = i + 1;
-					program.body.splice(insertIndex, 0, t.expressionStatement(injectCall));
+					if (tokenCSS) {
+						const injectCall = createInjectCallAST(":root", tokenCSS);
+						program.body.splice(insertIndex, 0, t.expressionStatement(injectCall));
+						insertIndex++;
+					}
+					if (globalStylesCSS) for (const [selector, css] of globalStylesCSS) {
+						const injectCall = createInjectCallAST(selector, css);
+						program.body.splice(insertIndex, 0, t.expressionStatement(injectCall));
+						insertIndex++;
+					}
 				}
 				return;
 			}
@@ -181,55 +190,41 @@ var babel_default = declare((api, options) => {
 		}
 	};
 });
-/**
-* Check if an object expression looks like a StaticStyle object
-*/
 function isStaticStyleObject(node) {
 	const hasClassName = node.properties.some((p) => t.isObjectProperty(p) && t.isIdentifier(p.key, { name: "className" }));
 	const hasStyles = node.properties.some((p) => t.isObjectProperty(p) && t.isIdentifier(p.key, { name: "styles" }));
 	return hasClassName && hasStyles;
 }
-/**
-* Extract styles object from a StaticStyle object expression
-*/
 function extractStylesFromStaticStyleObject(node, path) {
 	for (const prop of node.properties) if (t.isObjectProperty(prop) && t.isIdentifier(prop.key, { name: "styles" }) && t.isObjectExpression(prop.value)) return evaluateObjectExpression(prop.value, path);
 	return null;
 }
-/**
-* Extract className from a StaticStyle object expression
-*/
 function extractClassNameFromStaticStyleObject(node) {
 	for (const prop of node.properties) if (t.isObjectProperty(prop) && t.isIdentifier(prop.key, { name: "className" }) && t.isStringLiteral(prop.value)) return prop.value.value;
 	return null;
 }
-/**
-* Handle tastyStatic(styles) - returns StaticStyle object
-*/
-function handleStylesMode(path, args, cssWriter, state, globalRegistry, mode, globalKeyframes, autoPropertyTypes, globalFontFace, globalCounterStyle) {
+function handleStylesMode(path, args, cssWriter, state, globalRegistry, mode, globalKeyframes, autoPropertyTypes, globalFontFace, globalCounterStyle, globalFunction, globalRecipes) {
 	const stylesArg = args[0];
 	if (!t.isObjectExpression(stylesArg)) throw path.buildCodeFrameError("tastyStatic(styles) argument must be a static object literal");
-	const styles = resolveRecipes(evaluateObjectExpression(stylesArg, path));
+	const styles = resolveRecipesWith(evaluateObjectExpression(stylesArg, path), globalRecipes ?? null);
 	const { keyframes, nameMap } = extractKeyframesFromStyles(styles, globalKeyframes);
 	const properties = extractPropertiesFromStyles(styles, { autoPropertyTypes });
 	const fontFaces = extractFontFaceFromStyles(styles, globalFontFace);
 	const counterStyles = extractCounterStyleFromStyles(styles, globalCounterStyle);
+	const functions = extractFunctionsFromStyles(styles, globalFunction);
 	const chunks = extractStylesWithChunks(styles);
 	const className = chunks.length > 0 ? chunks.map((c) => c.className).join(" ") : "";
 	const staticStyleObject = createStaticStyleAST(className, styles);
 	if (mode === "inject") {
-		const injectCall = createInjectCallAST(className, collectAllCSS(keyframes, properties, fontFaces, counterStyles, chunks, nameMap));
+		const injectCall = createInjectCallAST(className, collectAllCSS(keyframes, properties, fontFaces, counterStyles, functions, chunks, nameMap));
 		path.replaceWith(t.sequenceExpression([injectCall, staticStyleObject]));
 	} else {
-		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, chunks, nameMap, state.sourceFile);
+		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, functions, chunks, nameMap, state.sourceFile);
 		path.replaceWith(staticStyleObject);
 	}
 	registerIfVariableDeclaration(path, className, styles, state, globalRegistry);
 }
-/**
-* Handle tastyStatic(base, styles) - extends base with additional styles
-*/
-function handleExtensionMode(path, args, cssWriter, state, globalRegistry, mode, globalKeyframes, autoPropertyTypes, globalFontFace, globalCounterStyle) {
+function handleExtensionMode(path, args, cssWriter, state, globalRegistry, mode, globalKeyframes, autoPropertyTypes, globalFontFace, globalCounterStyle, globalFunction, globalRecipes) {
 	if (args.length < 2) throw path.buildCodeFrameError("tastyStatic(base, styles) requires two arguments");
 	const baseArg = args[0];
 	const stylesArg = args[1];
@@ -239,38 +234,37 @@ function handleExtensionMode(path, args, cssWriter, state, globalRegistry, mode,
 	const baseEntry = state.staticStyleRegistry[baseName] || globalRegistry[baseName];
 	if (!baseEntry) throw path.buildCodeFrameError(`Cannot find base StaticStyle '${baseName}'. Make sure it is defined before being extended.`);
 	const overrideStyles = evaluateObjectExpression(stylesArg, path);
-	const mergedStyles = resolveRecipes(mergeStyles(baseEntry.styles, overrideStyles));
+	const mergedStyles = resolveRecipesWith(mergeStyles(baseEntry.styles, overrideStyles), globalRecipes ?? null);
 	const { keyframes, nameMap } = extractKeyframesFromStyles(mergedStyles, globalKeyframes);
 	const properties = extractPropertiesFromStyles(mergedStyles, { autoPropertyTypes });
 	const fontFaces = extractFontFaceFromStyles(mergedStyles, globalFontFace);
 	const counterStyles = extractCounterStyleFromStyles(mergedStyles, globalCounterStyle);
+	const functions = extractFunctionsFromStyles(mergedStyles, globalFunction);
 	const chunks = extractStylesWithChunks(mergedStyles);
 	const className = chunks.length > 0 ? chunks.map((c) => c.className).join(" ") : "";
 	const staticStyleObject = createStaticStyleAST(className, mergedStyles);
 	if (mode === "inject") {
-		const injectCall = createInjectCallAST(className, collectAllCSS(keyframes, properties, fontFaces, counterStyles, chunks, nameMap));
+		const injectCall = createInjectCallAST(className, collectAllCSS(keyframes, properties, fontFaces, counterStyles, functions, chunks, nameMap));
 		path.replaceWith(t.sequenceExpression([injectCall, staticStyleObject]));
 	} else {
-		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, chunks, nameMap, state.sourceFile);
+		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, functions, chunks, nameMap, state.sourceFile);
 		path.replaceWith(staticStyleObject);
 	}
 	registerIfVariableDeclaration(path, className, mergedStyles, state, globalRegistry);
 }
-/**
-* Handle tastyStatic(selector, styles) - removes the call entirely
-*/
-function handleSelectorMode(path, args, cssWriter, mode, sourceFile, globalKeyframes, autoPropertyTypes, globalFontFace, globalCounterStyle) {
+function handleSelectorMode(path, args, cssWriter, mode, sourceFile, globalKeyframes, autoPropertyTypes, globalFontFace, globalCounterStyle, globalFunction, globalRecipes) {
 	if (args.length < 2) throw path.buildCodeFrameError("tastyStatic(selector, styles) requires two arguments");
 	const selectorArg = args[0];
 	const stylesArg = args[1];
 	if (!t.isStringLiteral(selectorArg)) throw path.buildCodeFrameError("tastyStatic(selector, styles) first argument must be a string literal");
 	if (!t.isObjectExpression(stylesArg)) throw path.buildCodeFrameError("tastyStatic(selector, styles) second argument must be a static object literal");
 	const selector = selectorArg.value;
-	const styles = resolveRecipes(evaluateObjectExpression(stylesArg, path));
+	const styles = resolveRecipesWith(evaluateObjectExpression(stylesArg, path), globalRecipes ?? null);
 	const { keyframes, nameMap } = extractKeyframesFromStyles(styles, globalKeyframes);
 	const properties = extractPropertiesFromStyles(styles, { autoPropertyTypes });
 	const fontFaces = extractFontFaceFromStyles(styles, globalFontFace);
 	const counterStyles = extractCounterStyleFromStyles(styles, globalCounterStyle);
+	const functions = extractFunctionsFromStyles(styles, globalFunction);
 	const result = extractStylesForSelector(selector, styles);
 	const selectorCSS = nameMap.size > 0 ? replaceAnimationNamesInCSS(result.css, nameMap) : result.css;
 	if (mode === "inject") {
@@ -279,53 +273,48 @@ function handleSelectorMode(path, args, cssWriter, mode, sourceFile, globalKeyfr
 		for (const prop of properties) cssParts.push(prop.css);
 		for (const ff of fontFaces) cssParts.push(ff.css);
 		for (const cs of counterStyles) cssParts.push(cs.css);
+		for (const fn of functions) cssParts.push(fn.css);
 		cssParts.push(selectorCSS);
 		const injectCall = createInjectCallAST(selector, cssParts.join("\n"));
 		const parent = path.parentPath;
 		if (parent && t.isExpressionStatement(parent.node)) parent.replaceWith(t.expressionStatement(injectCall));
 		else path.replaceWith(injectCall);
 	} else {
-		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, [], nameMap, sourceFile);
+		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, functions, [], nameMap, sourceFile);
 		cssWriter.add(selector, selectorCSS, sourceFile);
 		const parent = path.parentPath;
 		if (parent && t.isExpressionStatement(parent.node)) parent.remove();
 		else path.replaceWith(t.identifier("undefined"));
 	}
 }
-/**
-* Collect all extracted CSS parts into a single string (for inject mode).
-*/
-function collectAllCSS(keyframes, properties, fontFaces, counterStyles, chunks, nameMap) {
+function collectAllCSS(keyframes, properties, fontFaces, counterStyles, functions, chunks, nameMap) {
 	const parts = [];
 	for (const kf of keyframes) parts.push(kf.css);
 	for (const prop of properties) parts.push(prop.css);
 	for (const ff of fontFaces) parts.push(ff.css);
 	for (const cs of counterStyles) parts.push(cs.css);
+	for (const fn of functions) parts.push(fn.css);
 	for (const chunk of chunks) parts.push(nameMap.size > 0 ? replaceAnimationNamesInCSS(chunk.css, nameMap) : chunk.css);
 	return parts.join("\n");
 }
-/**
-* Write all extracted CSS parts to a CSSWriter (for file mode).
-*/
-function writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, chunks, nameMap, sourceFile) {
+function writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, functions, chunks, nameMap, sourceFile) {
 	for (const kf of keyframes) cssWriter.add(kf.css, kf.css, sourceFile);
 	for (const prop of properties) cssWriter.add(prop.css, prop.css, sourceFile);
 	for (const ff of fontFaces) cssWriter.add(ff.css, ff.css, sourceFile);
 	for (const cs of counterStyles) cssWriter.add(cs.css, cs.css, sourceFile);
+	for (const fn of functions) cssWriter.add(fn.css, fn.css, sourceFile);
 	for (const chunk of chunks) {
 		const css = nameMap.size > 0 ? replaceAnimationNamesInCSS(chunk.css, nameMap) : chunk.css;
 		cssWriter.add(chunk.className, css, sourceFile);
 	}
 }
-/**
-* Create an `_$i(id, css)` call expression AST node for inject mode.
-*/
+function extractCSSFromStyles(selector, styles) {
+	if (!styles || Object.keys(styles).length === 0) return void 0;
+	return extractStylesForSelector(selector, styles).css || void 0;
+}
 function createInjectCallAST(id, css) {
 	return t.callExpression(t.identifier("_$i"), [t.stringLiteral(id), t.stringLiteral(css)]);
 }
-/**
-* Create a StaticStyle object AST node
-*/
 function createStaticStyleAST(className, styles) {
 	return t.objectExpression([
 		t.objectProperty(t.identifier("className"), t.stringLiteral(className)),
@@ -333,9 +322,6 @@ function createStaticStyleAST(className, styles) {
 		t.objectMethod("method", t.identifier("toString"), [], t.blockStatement([t.returnStatement(t.memberExpression(t.thisExpression(), t.identifier("className")))]))
 	]);
 }
-/**
-* Register a StaticStyle in the registry if it's being assigned to a variable
-*/
 function registerIfVariableDeclaration(path, className, styles, state, globalRegistry) {
 	const parent = path.parentPath;
 	if (parent && t.isVariableDeclarator(parent.node)) {
@@ -353,9 +339,6 @@ function registerIfVariableDeclaration(path, className, styles, state, globalReg
 		}
 	}
 }
-/**
-* Convert a JavaScript value to an AST node
-*/
 function valueToAST(value) {
 	if (value === null) return t.nullLiteral();
 	if (value === void 0) return t.identifier("undefined");
@@ -369,10 +352,6 @@ function valueToAST(value) {
 	}
 	return t.identifier("undefined");
 }
-/**
-* Evaluate an ObjectExpression to a plain JavaScript object.
-* Only supports static values that can be determined at build time.
-*/
 function evaluateObjectExpression(node, path) {
 	const result = {};
 	for (const prop of node.properties) {
@@ -386,9 +365,6 @@ function evaluateObjectExpression(node, path) {
 	}
 	return result;
 }
-/**
-* Evaluate an expression to a JavaScript value.
-*/
 function evaluateExpression(node, path) {
 	if (t.isStringLiteral(node)) return node.value;
 	if (t.isNumericLiteral(node)) return node.value;
@@ -411,10 +387,6 @@ function evaluateExpression(node, path) {
 	}
 	throw path.buildCodeFrameError(`Dynamic expressions are not supported in tastyStatic() - got ${node.type}. All values must be static literals.`);
 }
-/**
-* Replace animation names in CSS string.
-* Wraps the keyframes replaceAnimationNames to work on full CSS blocks.
-*/
 function replaceAnimationNamesInCSS(css, nameMap) {
 	if (nameMap.size === 0) return css;
 	return css.replace(/(animation(?:-name)?)\s*:\s*([^;}]+)/gi, (match, prop, value) => {
@@ -426,13 +398,10 @@ function replaceAnimationNamesInCSS(css, nameMap) {
 		return `${prop}: ${newValue}`;
 	});
 }
-/**
-* Escape special regex characters.
-*/
 function escapeRegex(str) {
 	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 //#endregion
-export { clearWriterCache, babel_default as default };
+export { babel_default as default };
 
 //# sourceMappingURL=babel.js.map