@tenphi/tasty 0.0.0-snapshot.01d8a9e

package/dist/utils/typography.js

@@ -0,0 +1,51 @@
+//#region src/utils/typography.ts
+const RESERVED_PRESET_NAMES = new Set([
+	"strong",
+	"bold",
+	"italic",
+	"icon",
+	"tight"
+]);
+/**
+* Generate typography tokens with $ prefix for CSS custom properties.
+*
+* Each preset generates the following CSS custom properties:
+* - `${name}-font-size`
+* - `${name}-line-height`
+* - `${name}-letter-spacing`
+* - `${name}-font-weight`
+* - `${name}-bold-font-weight` (if defined)
+* - `${name}-icon-size` (if defined)
+* - `${name}-text-transform` (if defined)
+* - `${name}-font-family` (if defined)
+* - `${name}-font-style` (if defined)
+*
+* @param presets - Typography presets object
+* @returns ConfigTokens object with $ prefixed keys
+*
+* @example
+* const customTokens = generateTypographyTokens({
+*   myHeading: { fontSize: '24px', lineHeight: '32px', fontWeight: '700' },
+*   body: { fontSize: '16px', lineHeight: '24px', fontWeight: '400' },
+* });
+*/
+function generateTypographyTokens(presets) {
+	const tokens = {};
+	for (const [name, preset] of Object.entries(presets)) {
+		if (RESERVED_PRESET_NAMES.has(name)) throw new Error(`Invalid typography preset name "${name}". This name is reserved as a preset modifier.`);
+		tokens[`$${name}-font-size`] = preset.fontSize;
+		tokens[`$${name}-line-height`] = preset.lineHeight;
+		tokens[`$${name}-letter-spacing`] = preset.letterSpacing ?? "normal";
+		tokens[`$${name}-font-weight`] = preset.fontWeight;
+		if (preset.boldFontWeight !== void 0) tokens[`$${name}-bold-font-weight`] = preset.boldFontWeight;
+		if (preset.iconSize !== void 0) tokens[`$${name}-icon-size`] = preset.iconSize;
+		if (preset.textTransform !== void 0) tokens[`$${name}-text-transform`] = preset.textTransform;
+		if (preset.fontFamily !== void 0) tokens[`$${name}-font-family`] = preset.fontFamily;
+		if (preset.fontStyle !== void 0) tokens[`$${name}-font-style`] = preset.fontStyle;
+	}
+	return tokens;
+}
+//#endregion
+export { generateTypographyTokens };
+
+//# sourceMappingURL=typography.js.map

package/dist/utils/typography.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typography.js","names":[],"sources":["../../src/utils/typography.ts"],"sourcesContent":["import type { ConfigTokens } from '../styles/types';\n\nconst RESERVED_PRESET_NAMES = new Set([\n  'strong',\n  'bold',\n  'italic',\n  'icon',\n  'tight',\n]);\n\n/**\n * A typography token value: plain value or a state map for responsive/theme-aware presets.\n *\n * @example\n * // Plain value\n * fontWeight: '400'\n * // State map\n * fontWeight: { '': '400', '@dark': '300' }\n */\nexport type TypographyTokenValue =\n  | string\n  | number\n  | Record<string, string | number | undefined | null | '@inherit'>;\n\n/**\n * Typography preset configuration.\n * Each preset defines font properties that get expanded into CSS custom properties.\n * All fields accept plain values or state maps for responsive/theme-aware tokens.\n *\n * Use with `generateTypographyTokens()` to create typography tokens for your design system.\n */\nexport interface TypographyPreset {\n  fontSize: TypographyTokenValue;\n  lineHeight: TypographyTokenValue;\n  letterSpacing?: TypographyTokenValue;\n  fontWeight: TypographyTokenValue;\n  boldFontWeight?: TypographyTokenValue;\n  iconSize?: TypographyTokenValue;\n  textTransform?: TypographyTokenValue;\n  fontFamily?: TypographyTokenValue;\n  fontStyle?: TypographyTokenValue;\n}\n\n/**\n * Generate typography tokens with $ prefix for CSS custom properties.\n *\n * Each preset generates the following CSS custom properties:\n * - `${name}-font-size`\n * - `${name}-line-height`\n * - `${name}-letter-spacing`\n * - `${name}-font-weight`\n * - `${name}-bold-font-weight` (if defined)\n * - `${name}-icon-size` (if defined)\n * - `${name}-text-transform` (if defined)\n * - `${name}-font-family` (if defined)\n * - `${name}-font-style` (if defined)\n *\n * @param presets - Typography presets object\n * @returns ConfigTokens object with $ prefixed keys\n *\n * @example\n * const customTokens = generateTypographyTokens({\n *   myHeading: { fontSize: '24px', lineHeight: '32px', fontWeight: '700' },\n *   body: { fontSize: '16px', lineHeight: '24px', fontWeight: '400' },\n * });\n */\nexport function generateTypographyTokens(\n  presets: Record<string, TypographyPreset>,\n): ConfigTokens {\n  const tokens: ConfigTokens = {} as ConfigTokens;\n\n  for (const [name, preset] of Object.entries(presets)) {\n    if (RESERVED_PRESET_NAMES.has(name)) {\n      throw new Error(\n        `Invalid typography preset name \"${name}\". This name is reserved as a preset modifier.`,\n      );\n    }\n\n    tokens[`$${name}-font-size`] = preset.fontSize;\n    tokens[`$${name}-line-height`] = preset.lineHeight;\n    tokens[`$${name}-letter-spacing`] = preset.letterSpacing ?? 'normal';\n    tokens[`$${name}-font-weight`] = preset.fontWeight;\n\n    if (preset.boldFontWeight !== undefined) {\n      tokens[`$${name}-bold-font-weight`] = preset.boldFontWeight;\n    }\n\n    if (preset.iconSize !== undefined) {\n      tokens[`$${name}-icon-size`] = preset.iconSize;\n    }\n\n    if (preset.textTransform !== undefined) {\n      tokens[`$${name}-text-transform`] = preset.textTransform;\n    }\n\n    if (preset.fontFamily !== undefined) {\n      tokens[`$${name}-font-family`] = preset.fontFamily;\n    }\n\n    if (preset.fontStyle !== undefined) {\n      tokens[`$${name}-font-style`] = preset.fontStyle;\n    }\n  }\n\n  return tokens;\n}\n"],"mappings":";AAEA,MAAM,wBAAwB,IAAI,IAAI;CACpC;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AA0DF,SAAgB,yBACd,SACc;CACd,MAAM,SAAuB,EAAE;AAE/B,MAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,QAAQ,EAAE;AACpD,MAAI,sBAAsB,IAAI,KAAK,CACjC,OAAM,IAAI,MACR,mCAAmC,KAAK,gDACzC;AAGH,SAAO,IAAI,KAAK,eAAe,OAAO;AACtC,SAAO,IAAI,KAAK,iBAAiB,OAAO;AACxC,SAAO,IAAI,KAAK,oBAAoB,OAAO,iBAAiB;AAC5D,SAAO,IAAI,KAAK,iBAAiB,OAAO;AAExC,MAAI,OAAO,mBAAmB,KAAA,EAC5B,QAAO,IAAI,KAAK,sBAAsB,OAAO;AAG/C,MAAI,OAAO,aAAa,KAAA,EACtB,QAAO,IAAI,KAAK,eAAe,OAAO;AAGxC,MAAI,OAAO,kBAAkB,KAAA,EAC3B,QAAO,IAAI,KAAK,oBAAoB,OAAO;AAG7C,MAAI,OAAO,eAAe,KAAA,EACxB,QAAO,IAAI,KAAK,iBAAiB,OAAO;AAG1C,MAAI,OAAO,cAAc,KAAA,EACvB,QAAO,IAAI,KAAK,gBAAgB,OAAO;;AAI3C,QAAO"}

package/dist/utils/warnings.d.ts

@@ -0,0 +1,16 @@
+//#region src/utils/warnings.d.ts
+declare function warn(...args: unknown[]): void;
+declare function deprecationWarning(condition: unknown, {
+  property,
+  name,
+  betterAlternative,
+  reason
+}: {
+  property: string;
+  name: string;
+  betterAlternative: (() => string) | string;
+  reason?: (() => string) | string;
+}): void;
+//#endregion
+export { deprecationWarning, warn };
+//# sourceMappingURL=warnings.d.ts.map

package/dist/utils/warnings.js

@@ -0,0 +1,16 @@
+//#region src/utils/warnings.ts
+const PREFIX = "Tasty";
+function warn(...args) {
+	console.warn(`${PREFIX}:`, ...args);
+}
+function deprecationWarning(condition, { property, name, betterAlternative, reason }) {
+	if (condition) return;
+	console.group(`⚠️ ${PREFIX}: Deprecation in ${name}`);
+	warn(`"${property}" is deprecated, consider better alternative: ${typeof betterAlternative === "function" ? betterAlternative() : betterAlternative}`);
+	if (reason) warn(`Reason: ${typeof reason === "function" ? reason() : reason}`);
+	console.groupEnd();
+}
+//#endregion
+export { deprecationWarning, warn };
+
+//# sourceMappingURL=warnings.js.map

package/dist/utils/warnings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warnings.js","names":[],"sources":["../../src/utils/warnings.ts"],"sourcesContent":["/* eslint-disable no-console */\nconst PREFIX = 'Tasty';\n\nexport function warn(...args: unknown[]) {\n  console.warn(`${PREFIX}:`, ...args);\n}\n\nexport function deprecationWarning(\n  condition: unknown,\n  {\n    property,\n    name,\n    betterAlternative,\n    reason,\n  }: {\n    property: string;\n    name: string;\n    betterAlternative: (() => string) | string;\n    reason?: (() => string) | string;\n  },\n) {\n  if (condition) return;\n\n  if (process.env.NODE_ENV === 'production') {\n    return warn(\n      `DEPRECATION ${name} \"${property}\" -> ${\n        typeof betterAlternative === 'function'\n          ? betterAlternative()\n          : betterAlternative\n      }`,\n    );\n  }\n\n  // we can make deprecations even better if we add the md syntax in the console.\n  // anyway, everything down below will be stripped in the production build\n  console.group(`⚠️ ${PREFIX}: Deprecation in ${name}`);\n  warn(\n    `\"${property}\" is deprecated, consider better alternative: ${\n      typeof betterAlternative === 'function'\n        ? betterAlternative()\n        : betterAlternative\n    }`,\n  );\n  if (reason) {\n    warn(`Reason: ${typeof reason === 'function' ? reason() : reason}`);\n  }\n  console.groupEnd();\n}\n"],"mappings":";AACA,MAAM,SAAS;AAEf,SAAgB,KAAK,GAAG,MAAiB;AACvC,SAAQ,KAAK,GAAG,OAAO,IAAI,GAAG,KAAK;;AAGrC,SAAgB,mBACd,WACA,EACE,UACA,MACA,mBACA,UAOF;AACA,KAAI,UAAW;AAcf,SAAQ,MAAM,MAAM,OAAO,mBAAmB,OAAO;AACrD,MACE,IAAI,SAAS,gDACX,OAAO,sBAAsB,aACzB,mBAAmB,GACnB,oBAEP;AACD,KAAI,OACF,MAAK,WAAW,OAAO,WAAW,aAAa,QAAQ,GAAG,SAAS;AAErE,SAAQ,UAAU"}

package/dist/zero/babel.d.ts

@@ -0,0 +1,81 @@
+import { TastyConfig } from "../config.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 excluding runtime-only DOM options
+ * (`nonce`, `maxRulesPerSheet`, `forceTextInjection`, `gc`)
+ * and overriding `devMode` default to `false`.
+ */
+type TastyZeroConfig = Omit<TastyConfig, 'nonce' | 'maxRulesPerSheet' | 'forceTextInjection' | 'gc' | 'devMode'> & {
+  /**
+   * Enable development mode features: source comments in generated CSS.
+   * @default false
+   */
+  devMode?: 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

package/dist/zero/babel.js

@@ -0,0 +1,462 @@
+import { __require } from "../_virtual/_rolldown/runtime.js";
+import { configure, getGlobalConfigTokens, getGlobalStyles, 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 * 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 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];
+}
+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";
+	const outputPath = options.output || "tasty.css";
+	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) resolvedConfig = createJiti(path.dirname(options.configFile), { moduleCache: false })(options.configFile);
+		else resolvedConfig = {};
+		const devMode = resolvedConfig.devMode ?? false;
+		if (cached) resetConfig();
+		configure(resolvedConfig);
+		const newWriter = new CSSWriter(outputPath, { devMode });
+		if (mode !== "inject") {
+			const tokenCSS = extractCSSFromStyles(":root", getGlobalConfigTokens());
+			if (tokenCSS) newWriter.add(":root:tokens", tokenCSS);
+			const globalStyles = getGlobalStyles();
+			if (globalStyles) for (const [selector, styles] of Object.entries(globalStyles)) {
+				const css = extractCSSFromStyles(selector, styles);
+				if (css) newWriter.add(`global:${selector}`, css);
+			}
+		}
+		writerCache.set(resolvedOutputPath, {
+			writer: newWriter,
+			configKey,
+			registry: {},
+			config: resolvedConfig
+		});
+	}
+	const entry = writerCache.get(resolvedOutputPath);
+	const cssWriter = entry.writer;
+	const globalRegistry = entry.registry;
+	const config = entry.config;
+	const devMode = config.devMode ?? false;
+	let tokenCSS;
+	let globalStylesCSS;
+	if (mode === "inject") {
+		tokenCSS = extractCSSFromStyles(":root", getGlobalConfigTokens());
+		const gs = getGlobalStyles();
+		if (gs) {
+			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(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, 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);
+				else throw path.buildCodeFrameError("tastyStatic() first argument must be an object (styles), identifier (base StaticStyle), or string (selector)");
+			},
+			VariableDeclarator(path, state) {
+				const init = path.node.init;
+				const id = path.node.id;
+				if (t.isIdentifier(id) && t.isObjectExpression(init) && isStaticStyleObject(init)) {
+					const variableName = id.name;
+					const styles = extractStylesFromStaticStyleObject(init, path);
+					const className = extractClassNameFromStaticStyleObject(init);
+					if (styles && className) {
+						state.staticStyleRegistry[variableName] = {
+							styles,
+							className
+						};
+						globalRegistry[variableName] = {
+							styles,
+							className
+						};
+					}
+				}
+			}
+		},
+		post() {
+			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, mode, globalKeyframes, autoPropertyTypes, globalFontFace, globalCounterStyle) {
+	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 { keyframes, nameMap } = extractKeyframesFromStyles(styles, globalKeyframes);
+	const properties = extractPropertiesFromStyles(styles, { autoPropertyTypes });
+	const fontFaces = extractFontFaceFromStyles(styles, globalFontFace);
+	const counterStyles = extractCounterStyleFromStyles(styles, globalCounterStyle);
+	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));
+		path.replaceWith(t.sequenceExpression([injectCall, staticStyleObject]));
+	} else {
+		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, 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) {
+	if (args.length < 2) throw path.buildCodeFrameError("tastyStatic(base, styles) requires two arguments");
+	const baseArg = args[0];
+	const stylesArg = args[1];
+	if (!t.isIdentifier(baseArg)) throw path.buildCodeFrameError("tastyStatic(base, styles) first argument must be an identifier");
+	if (!t.isObjectExpression(stylesArg)) throw path.buildCodeFrameError("tastyStatic(base, styles) second argument must be a static object literal");
+	const baseName = baseArg.name;
+	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 { keyframes, nameMap } = extractKeyframesFromStyles(mergedStyles, globalKeyframes);
+	const properties = extractPropertiesFromStyles(mergedStyles, { autoPropertyTypes });
+	const fontFaces = extractFontFaceFromStyles(mergedStyles, globalFontFace);
+	const counterStyles = extractCounterStyleFromStyles(mergedStyles, globalCounterStyle);
+	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));
+		path.replaceWith(t.sequenceExpression([injectCall, staticStyleObject]));
+	} else {
+		writeCSSToWriter(cssWriter, keyframes, properties, fontFaces, counterStyles, 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) {
+	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 { keyframes, nameMap } = extractKeyframesFromStyles(styles, globalKeyframes);
+	const properties = extractPropertiesFromStyles(styles, { autoPropertyTypes });
+	const fontFaces = extractFontFaceFromStyles(styles, globalFontFace);
+	const counterStyles = extractCounterStyleFromStyles(styles, globalCounterStyle);
+	const result = extractStylesForSelector(selector, styles);
+	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);
+		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);
+		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) {
+	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 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) {
+	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 chunk of chunks) {
+		const css = nameMap.size > 0 ? replaceAnimationNamesInCSS(chunk.css, nameMap) : chunk.css;
+		cssWriter.add(chunk.className, css, sourceFile);
+	}
+}
+/**
+* Extract CSS for a selector from a styles/tokens object.
+* Returns undefined when there are no styles or no CSS output.
+*/
+function extractCSSFromStyles(selector, styles) {
+	if (!styles || Object.keys(styles).length === 0) return void 0;
+	return extractStylesForSelector(selector, styles).css || void 0;
+}
+/**
+* Create an `_$i(id, css)` call expression AST node for inject mode.
+*/
+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)),
+		t.objectProperty(t.identifier("styles"), valueToAST(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)) {
+		const id = parent.node.id;
+		if (t.isIdentifier(id)) {
+			const variableName = id.name;
+			state.staticStyleRegistry[variableName] = {
+				styles,
+				className
+			};
+			globalRegistry[variableName] = {
+				styles,
+				className
+			};
+		}
+	}
+}
+/**
+* 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");
+	if (typeof value === "string") return t.stringLiteral(value);
+	if (typeof value === "number") return t.numericLiteral(value);
+	if (typeof value === "boolean") return t.booleanLiteral(value);
+	if (Array.isArray(value)) return t.arrayExpression(value.map(valueToAST));
+	if (typeof value === "object") {
+		const properties = Object.entries(value).map(([key, val]) => t.objectProperty(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? t.identifier(key) : t.stringLiteral(key), valueToAST(val)));
+		return t.objectExpression(properties);
+	}
+	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) {
+		if (t.isSpreadElement(prop)) throw path.buildCodeFrameError("Spread elements are not supported in tastyStatic() - styles must be fully static");
+		if (!t.isObjectProperty(prop)) throw path.buildCodeFrameError("Only object properties are supported in tastyStatic()");
+		let key;
+		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);
+	}
+	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;
+	if (t.isBooleanLiteral(node)) return node.value;
+	if (t.isNullLiteral(node)) return null;
+	if (t.isIdentifier(node, { name: "undefined" })) return;
+	if (t.isArrayExpression(node)) return node.elements.map((el) => {
+		if (el === null) return null;
+		if (t.isSpreadElement(el)) throw path.buildCodeFrameError("Spread elements are not supported in tastyStatic()");
+		return evaluateExpression(el, path);
+	});
+	if (t.isObjectExpression(node)) return evaluateObjectExpression(node, path);
+	if (t.isTemplateLiteral(node)) {
+		if (node.expressions.length > 0) throw path.buildCodeFrameError("Template literals with expressions are not supported in tastyStatic()");
+		return node.quasis.map((q) => q.value.cooked).join("");
+	}
+	if (t.isUnaryExpression(node, { operator: "-" })) {
+		const arg = evaluateExpression(node.argument, path);
+		if (typeof arg === "number") return -arg;
+	}
+	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) => {
+		let newValue = value;
+		for (const [original, replacement] of nameMap) {
+			const pattern = new RegExp(`\\b${escapeRegex(original)}\\b`, "g");
+			newValue = newValue.replace(pattern, replacement);
+		}
+		return `${prop}: ${newValue}`;
+	});
+}
+/**
+* Escape special regex characters.
+*/
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+export { clearWriterCache, babel_default as default };
+
+//# sourceMappingURL=babel.js.map