@tenphi/tasty 0.0.0-snapshot.1c5dff6 → 0.0.0-snapshot.1f1c00a

package/dist/zero/babel.d.ts

@@ -1,113 +1,2 @@
-import { KeyframesSteps } from "../injector/types.js";
-import { StyleDetails, UnitHandler } from "../parser/types.js";
-import { StyleHandlerDefinition } from "../utils/styles.js";
-import { 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, handlers, or tokens.
-   * 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>;
-  /**
-   * 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>;
-  /**
-   * Predefined tokens that are replaced during style parsing.
-   * Use `$name` for custom properties and `#name` for color tokens.
-   * @example { $spacing: '2x', '#accent': '#purple' }
-   */
-  tokens?: 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 */
-  config?: TastyZeroConfig;
-}
-declare const _default: (api: object, options: TastyZeroBabelOptions | null | undefined, dirname: string) => _babel_core0.PluginObj<PluginPass>;
-//#endregion
-export { TastyZeroBabelOptions, TastyZeroConfig, _default as default };
-//# sourceMappingURL=babel.d.ts.map
+import { n as _default, r as TastyZeroConfig, t as TastyZeroBabelOptions } from "../babel-rZcEwPLM.js";
+export { TastyZeroBabelOptions, type TastyZeroConfig, _default as default };

package/dist/zero/babel.js

@@ -1,58 +1,152 @@
-import { configure } from "../config.js";
-import { mergeStyles } from "../utils/merge-styles.js";
-import { resolveRecipes } from "../utils/resolve-recipes.js";
-import { extractKeyframesFromStyles, extractPropertiesFromStyles, extractStylesForSelector, extractStylesWithChunks } from "./extractor.js";
-import { CSSWriter } from "./css-writer.js";
+import { t as mergeStyles } from "../chunks/shared-utils-y-HjvPN4.js";
+import "../chunks/css-definitions-DotDkIXt.js";
+import { t as resolveRecipesWith } from "../chunks/config-engine-DEmmPPdp.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-gJrKBRiw.js";
+import { n as functionsForExtraction, r as resetZeroConfig, t as configureZero } from "../chunks/build-config-CL4eRu2z.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;
+	} catch {
+		return null;
+	}
+}
+function clearRequireCacheTree(filePath) {
+	let resolved;
+	try {
+		resolved = __require.resolve(filePath);
+	} catch {
+		return;
+	}
+	const mod = __require.cache[resolved];
+	if (!mod) return;
+	const dir = resolved.substring(0, resolved.lastIndexOf("/"));
+	if (mod.children) {
+		for (const child of mod.children) if (child.id.startsWith(dir) && !child.id.includes("node_modules")) clearRequireCacheTree(child.id);
+	}
+	delete __require.cache[resolved];
+}
 var babel_default = declare((api, options) => {
 	api.assertVersion(7);
+	const mode = options.mode ?? "file";
 	const outputPath = options.output || "tasty.css";
-	const config = options.config || {};
-	const devMode = config.devMode ?? false;
-	configure(config);
-	const cssWriter = new CSSWriter(outputPath, { devMode });
-	const globalRegistry = {};
+	const resolvedOutputPath = path.resolve(outputPath);
+	const injectImport = options.injectImport ?? true;
+	if (mode === "file" && injectImport) {
+		const dir = path.dirname(resolvedOutputPath);
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		if (!fs.existsSync(resolvedOutputPath)) fs.writeFileSync(resolvedOutputPath, "/* Generated by @tenphi/tasty/zero - DO NOT EDIT */\n");
+	}
+	const configDeps = [...options.configFile ? [options.configFile] : [], ...options.configDeps || []];
+	const configKey = configDeps.length > 0 ? configDeps.map(mtime).join(",") : "";
+	if (configDeps.length > 0) {
+		api.cache.using(() => configKey);
+		for (const dep of configDeps) try {
+			api.addExternalDependency(dep);
+		} catch {}
+	} else api.cache.forever();
+	if (configDeps.length > 0) for (const dep of configDeps) clearRequireCacheTree(dep);
+	const cached = writerCache.get(resolvedOutputPath);
+	if (!cached || cached.configKey !== configKey) {
+		const configOption = options.config;
+		let resolvedConfig;
+		if (configOption) resolvedConfig = typeof configOption === "function" ? configOption() : configOption;
+		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;
+		resetZeroConfig();
+		const finalConfig = {
+			namePrefix: "ts",
+			...resolvedConfig
+		};
+		const config = configureZero(finalConfig);
+		setExtractorNamePrefix(finalConfig.namePrefix ?? "ts");
+		const newWriter = new CSSWriter(outputPath, { devMode });
+		if (mode !== "inject") {
+			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
+		});
+	}
+	const entry = writerCache.get(resolvedOutputPath);
+	const cssWriter = entry.writer;
+	const globalRegistry = entry.registry;
+	const config = entry.config;
+	const sourceConfig = config.source;
+	const devMode = sourceConfig.devMode ?? false;
+	setExtractorNamePrefix(sourceConfig.namePrefix ?? "ts");
+	let tokenCSS;
+	let globalStylesCSS;
+	if (mode === "inject") {
+		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 {
 		name: "tasty-zero",
 		pre() {
 			this.staticStyleRegistry = {};
+			this._fileAddedCSS = false;
 			if (devMode && this.filename) this.sourceFile = this.filename.split("/").pop() || this.filename;
 		},
 		visitor: {
-			ImportDeclaration(path) {
-				const source = path.node.source.value;
-				if (source === "@tenphi/tasty/static" || source.endsWith("/tasty/static")) path.remove();
+			ImportDeclaration(nodePath, state) {
+				const source = nodePath.node.source.value;
+				if (source === "@tenphi/tasty/static" || source.endsWith("/tasty/static")) {
+					if (mode === "inject") nodePath.replaceWith(t.importDeclaration([t.importSpecifier(t.identifier("_$i"), t.identifier("injectCSS"))], t.stringLiteral("@tenphi/tasty/static/inject")));
+					else if (injectImport) {
+						let importPath = resolvedOutputPath;
+						if (state.filename) {
+							const sourceDir = path.dirname(state.filename);
+							importPath = path.relative(sourceDir, resolvedOutputPath);
+							if (!importPath.startsWith(".")) importPath = "./" + importPath;
+						}
+						nodePath.replaceWith(t.importDeclaration([], t.stringLiteral(importPath)));
+					} else nodePath.remove();
+				}
 			},
 			CallExpression(path, state) {
 				const callee = path.node.callee;
 				if (!t.isIdentifier(callee, { name: "tastyStatic" })) return;
+				state._fileAddedCSS = true;
 				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, state.sourceFile, config.keyframes, config.autoPropertyTypes);
-				else if (t.isObjectExpression(firstArg)) handleStylesMode(path, args, cssWriter, state, globalRegistry, config.keyframes, config.autoPropertyTypes);
-				else if (t.isIdentifier(firstArg)) handleExtensionMode(path, args, cssWriter, state, globalRegistry, config.keyframes, config.autoPropertyTypes);
+				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) {
@@ -76,57 +170,64 @@ var babel_default = declare((api, options) => {
 			}
 		},
 		post() {
-			if (cssWriter.size > 0) cssWriter.write();
+			if (mode === "inject") {
+				if (this._fileAddedCSS && (tokenCSS || globalStylesCSS)) {
+					const program = this.file.ast.program;
+					let insertIndex = 0;
+					for (let i = 0; i < program.body.length; i++) if (t.isImportDeclaration(program.body[i])) insertIndex = i + 1;
+					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;
+			}
+			if (this._fileAddedCSS && cssWriter.size > 0) cssWriter.write();
 		}
 	};
 });
-/**
-* 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, globalKeyframes, autoPropertyTypes) {
+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 rawStyles = evaluateObjectExpression(stylesArg, path);
+	const styles = resolveRecipesWith(rawStyles, globalRecipes ?? null);
 	const { keyframes, nameMap } = extractKeyframesFromStyles(styles, globalKeyframes);
-	for (const kf of keyframes) cssWriter.add(kf.css, kf.css, state.sourceFile);
 	const properties = extractPropertiesFromStyles(styles, { autoPropertyTypes });
-	for (const prop of properties) cssWriter.add(prop.css, prop.css, state.sourceFile);
+	const fontFaces = extractFontFaceFromStyles(styles, globalFontFace);
+	const counterStyles = extractCounterStyleFromStyles(styles, globalCounterStyle);
+	const functions = extractFunctionsFromStyles(styles, globalFunction);
 	const chunks = extractStylesWithChunks(styles);
-	for (const chunk of chunks) {
-		const css = nameMap.size > 0 ? replaceAnimationNamesInCSS(chunk.css, nameMap) : chunk.css;
-		cssWriter.add(chunk.className, css, state.sourceFile);
-	}
 	const className = chunks.length > 0 ? chunks.map((c) => c.className).join(" ") : "";
 	const staticStyleObject = createStaticStyleAST(className, styles);
-	path.replaceWith(staticStyleObject);
+	if (mode === "inject") {
+		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, 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, globalKeyframes, autoPropertyTypes) {
+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];
@@ -136,46 +237,88 @@ function handleExtensionMode(path, args, cssWriter, state, globalRegistry, globa
 	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);
-	for (const kf of keyframes) cssWriter.add(kf.css, kf.css, state.sourceFile);
 	const properties = extractPropertiesFromStyles(mergedStyles, { autoPropertyTypes });
-	for (const prop of properties) cssWriter.add(prop.css, prop.css, state.sourceFile);
+	const fontFaces = extractFontFaceFromStyles(mergedStyles, globalFontFace);
+	const counterStyles = extractCounterStyleFromStyles(mergedStyles, globalCounterStyle);
+	const functions = extractFunctionsFromStyles(mergedStyles, globalFunction);
 	const chunks = extractStylesWithChunks(mergedStyles);
-	for (const chunk of chunks) {
-		const css = nameMap.size > 0 ? replaceAnimationNamesInCSS(chunk.css, nameMap) : chunk.css;
-		cssWriter.add(chunk.className, css, state.sourceFile);
-	}
 	const className = chunks.length > 0 ? chunks.map((c) => c.className).join(" ") : "";
 	const staticStyleObject = createStaticStyleAST(className, mergedStyles);
-	path.replaceWith(staticStyleObject);
+	if (mode === "inject") {
+		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, 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, sourceFile, globalKeyframes, autoPropertyTypes) {
+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 rawStyles = evaluateObjectExpression(stylesArg, path);
+	const styles = resolveRecipesWith(rawStyles, globalRecipes ?? null);
 	const { keyframes, nameMap } = extractKeyframesFromStyles(styles, globalKeyframes);
-	for (const kf of keyframes) cssWriter.add(kf.css, kf.css, sourceFile);
 	const properties = extractPropertiesFromStyles(styles, { autoPropertyTypes });
-	for (const prop of properties) cssWriter.add(prop.css, prop.css, sourceFile);
+	const fontFaces = extractFontFaceFromStyles(styles, globalFontFace);
+	const counterStyles = extractCounterStyleFromStyles(styles, globalCounterStyle);
+	const functions = extractFunctionsFromStyles(styles, globalFunction);
 	const result = extractStylesForSelector(selector, styles);
-	const css = nameMap.size > 0 ? replaceAnimationNamesInCSS(result.css, nameMap) : result.css;
-	cssWriter.add(selector, css, sourceFile);
-	const parent = path.parentPath;
-	if (parent && t.isExpressionStatement(parent.node)) parent.remove();
-	else path.replaceWith(t.identifier("undefined"));
+	const selectorCSS = nameMap.size > 0 ? replaceAnimationNamesInCSS(result.css, nameMap) : result.css;
+	if (mode === "inject") {
+		const cssParts = [];
+		for (const kf of keyframes) cssParts.push(kf.css);
+		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, 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"));
+	}
+}
+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");
+}
+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);
+	}
+}
+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)),
@@ -183,9 +326,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)) {
@@ -203,9 +343,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");
@@ -219,10 +356,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) {
@@ -232,13 +365,11 @@ function evaluateObjectExpression(node, path) {
 		if (t.isIdentifier(prop.key)) key = prop.key.name;
 		else if (t.isStringLiteral(prop.key)) key = prop.key.value;
 		else throw path.buildCodeFrameError("Dynamic property keys are not supported in tastyStatic()");
-		result[key] = evaluateExpression(prop.value, path);
+		const value = evaluateExpression(prop.value, path);
+		result[key] = value;
 	}
 	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;
@@ -261,10 +392,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) => {
@@ -276,13 +403,10 @@ function replaceAnimationNamesInCSS(css, nameMap) {
 		return `${prop}: ${newValue}`;
 	});
 }
-/**
-* Escape special regex characters.
-*/
 function escapeRegex(str) {
 	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-
 //#endregion
 export { babel_default as default };
+
 //# sourceMappingURL=babel.js.map