tailwind-styled-v4 5.0.9 → 5.0.10

package/dist/animate.js

@@ -1,55 +1,23 @@
 'use strict';
 
-require('fs');
+require('crypto');
+var fs = require('fs');
+var path = require('path');
+var url = require('url');
+var module$1 = require('module');
 var zod = require('zod');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
 var __getOwnPropNames = Object.getOwnPropertyNames;
-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('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-
-// packages/domain/shared/src/index.ts
-function getNodeModuleRef() {
-  if (isBrowser) return null;
-  if (nodeModuleRef !== null) return nodeModuleRef;
-  try {
-    const test = typeof __require === "function" ? __require("module") : null;
-    nodeModuleRef = test;
-    return test;
-  } catch {
-    nodeModuleRef = null;
-    return null;
-  }
-}
-function getNodeFs() {
-  if (isBrowser) throw new Error("node:fs not available in browser");
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeFs) _nodeFs = nodeRequire.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('animate.js', document.baseURI).href)))("node:fs");
-  return _nodeFs;
-}
-function getNodePath() {
-  if (isBrowser) throw new Error("node:path not available in browser");
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodePath) _nodePath = nodeRequire.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('animate.js', document.baseURI).href)))("node:path");
-  return _nodePath;
-}
-function getNodeUrl() {
-  if (isBrowser) throw new Error("node:url not available in browser");
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeUrl) _nodeUrl = nodeRequire.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('animate.js', document.baseURI).href)))("node:url");
-  return _nodeUrl;
-}
 function createDebugLogger(namespace, label) {
   const prefix = label ? `[${namespace}:${label}]` : `[${namespace}]`;
   return (msg) => {
@@ -58,24 +26,19 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path) {
-  if (!path || path.length === 0) return "(root)";
-  return path.map(
+function formatIssuePath(path2) {
+  if (!path2 || path2.length === 0) return "(root)";
+  return path2.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
 function loadNativeBinding(options) {
-  if (isBrowser) {
-    return { binding: null, loadErrors: [{ path: "", message: "Native bindings not available in browser" }] };
-  }
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
-  const path = getNodePath();
-  const fs2 = getNodeFs();
   for (const candidate of candidates) {
-    const candidatePath = path.resolve(runtimeDir, candidate);
+    const candidatePath = path__default.default.resolve(runtimeDir, candidate);
     try {
-      if (!fs2.existsSync(candidatePath) && !fs2.existsSync(candidatePath + ".node")) {
+      if (!fs__default.default.existsSync(candidatePath) && !fs__default.default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -89,77 +52,56 @@ function loadNativeBinding(options) {
   }
   return { binding: null, loadErrors };
 }
-function getRequire() {
-  if (isBrowser) return (() => {
-    throw new Error("require not available in browser");
-  });
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) return (() => {
-    throw new Error("require not available");
-  });
-  return nodeRequire.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('animate.js', document.baseURI).href)));
-}
-function requireNativeModule(path) {
-  return _require(path);
+function requireNativeModule(p) {
+  return _require(p);
 }
 function resolveNativeBindingCandidates(options) {
-  if (isBrowser) return [];
-  const { runtimeDir, envVarNames = [], includeDefaultCandidates = true, enforceNodeExtensionForEnvPath = false } = options;
+  const {
+    envVarNames = ["TW_NATIVE_PATH", "TWS_NATIVE_PATH"],
+    includeDefaultCandidates = true,
+    enforceNodeExtensionForEnvPath = false
+  } = options;
+  const runtimeDir = options.runtimeDir || process.cwd();
   const candidates = [];
-  const path = getNodePath();
-  const fs2 = getNodeFs();
   for (const envVar of envVarNames) {
     const envPath = process.env[envVar];
     if (envPath) {
-      if (enforceNodeExtensionForEnvPath && !envPath.endsWith(".node")) {
-        candidates.push(envPath + ".node");
-      } else {
-        candidates.push(envPath);
-      }
+      candidates.push(enforceNodeExtensionForEnvPath && !envPath.endsWith(".node") ? envPath + ".node" : envPath);
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs2.existsSync(runtimeDir)) {
+  if (fs__default.default.existsSync(runtimeDir)) {
     try {
-      const entries = fs2.readdirSync(runtimeDir);
-      for (const entry of entries) {
-        if (entry.endsWith(".node")) {
-          candidates.push(entry);
-        }
+      for (const entry of fs__default.default.readdirSync(runtimeDir)) {
+        if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
     }
   }
-  const platform = typeof process !== "undefined" ? process.platform : "";
-  const ext = platform === "win32" ? ".dll" : platform === "darwin" ? ".dylib" : ".so";
-  const defaultBindingName = `tailwind_styled_parser${ext}`;
-  candidates.push(path.resolve(runtimeDir, "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path.resolve(runtimeDir, "..", "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path.resolve(process.cwd(), "native", defaultBindingName));
+  const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
+  const napiPlatform = process.platform === "linux" && process.arch === "x64" ? "linux-x64-gnu" : process.platform === "linux" && process.arch === "arm64" ? "linux-arm64-gnu" : `${process.platform}-${process.arch}`;
+  for (const bin of BINARY_NAMES) {
+    candidates.push(path__default.default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path__default.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path__default.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path__default.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path__default.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path__default.default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path__default.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+  }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (isBrowser) return "";
-  if (dir) return getNodePath().resolve(dir);
+  if (dir) return path__default.default.resolve(dir);
   try {
-    return getNodeUrl().fileURLToPath(importMetaUrl);
+    return path__default.default.dirname(url.fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
 }
-function formatErrorMessage(error) {
-  if (error instanceof TwError) return error.toString();
-  if (error instanceof Error) return error.message;
-  return String(error);
-}
-var isBrowser, nodeModuleRef, _nodeFs, _nodePath, _nodeUrl, TwError, _require, LRUCache;
+var TwError, _require, LRUCache;
 var init_src = __esm({
   "packages/domain/shared/src/index.ts"() {
-    isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
-    nodeModuleRef = null;
-    _nodeFs = null;
-    _nodePath = null;
-    _nodeUrl = null;
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -193,8 +135,8 @@ var init_src = __esm({
       /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
       static fromZod(err) {
         const first = err.issues?.[0] ?? err.errors?.[0];
-        const path = formatIssuePath(first?.path);
-        const message = first ? `${path}: ${first.message}` : "Schema validation failed";
+        const path2 = formatIssuePath(first?.path);
+        const message = first ? `${path2}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -212,7 +154,7 @@ var init_src = __esm({
         return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
       }
     };
-    _require = getRequire();
+    _require = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('animate.js', document.baseURI).href)));
     LRUCache = class {
       capacity;
       cache;
@@ -442,7 +384,7 @@ init_src();
 // packages/domain/analyzer/src/utils.ts
 init_src();
 var DEBUG_NAMESPACE2 = "tailwind-styled:analyzer";
-function formatErrorMessage2(error) {
+function formatErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var debugLog2 = createDebugLogger(DEBUG_NAMESPACE2, "tailwind-styled/analyzer");
@@ -532,7 +474,7 @@ async function requireNativeCssCompiler() {
 
 // packages/domain/analyzer/src/schemas.ts
 init_src();
-var formatIssuePath2 = (path) => path.length > 0 ? path.map(
+var formatIssuePath2 = (path2) => path2.length > 0 ? path2.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var isPlainObject = (value) => {
@@ -541,8 +483,8 @@ var isPlainObject = (value) => {
   return proto === Object.prototype || proto === null;
 };
 var formatIssues = (error) => error.issues.map((issue) => {
-  const path = formatIssuePath2(issue.path);
-  return `${path}: ${issue.message}`;
+  const path2 = formatIssuePath2(issue.path);
+  return `${path2}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -636,8 +578,11 @@ var parseNativeCssCompileResult = (result, className) => parseWithSchema(
 var parseClassToCssOptions = (options) => parseWithSchema(ClassToCssOptionsSchema, options ?? {}, "classToCss options are invalid");
 
 // packages/domain/analyzer/src/classToCss.ts
-var normalizeClassInput = (input) => {
+var normalizeClassInput = (input, _binding) => {
   if (typeof input === "string") {
+    if (_binding?.normalizeClassInput) {
+      return _binding.normalizeClassInput(input);
+    }
     return input.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
   }
   if (!Array.isArray(input)) {
@@ -659,27 +604,26 @@ var normalizeClassToCssOptions = (options) => {
   const prefix = parsed.prefix ?? null;
   return { prefix, strict };
 };
-var mergeDeclarationMap = (target, css) => {
-  for (const ruleMatch of css.matchAll(/\{([^}]*)\}/g)) {
-    const body = ruleMatch[1];
-    for (const raw of body.split(";")) {
-      const declaration = raw.trim();
-      if (declaration.length === 0) continue;
-      const colonIndex = declaration.indexOf(":");
-      if (colonIndex <= 0) continue;
-      const property = declaration.slice(0, colonIndex).trim();
-      const value = declaration.slice(colonIndex + 1).trim();
-      if (property.length === 0 || value.length === 0) continue;
-      if (target.has(property)) target.delete(property);
-      target.set(property, value);
-    }
+var mergeDeclarationMap = (target, css, binding) => {
+  if (!binding.parseCssRules) {
+    throw new Error("FATAL: Native binding 'parseCssRules' is required but not available.");
+  }
+  const rules = binding.parseCssRules(css);
+  for (const rule of rules) {
+    if (target.has(rule.property)) target.delete(rule.property);
+    target.set(rule.property, rule.isImportant ? `${rule.value} !important` : rule.value);
   }
 };
-var declarationMapToString = (declarationMap) => {
-  return Array.from(declarationMap.entries()).map(([property, value]) => `${property}: ${value}`).join("; ");
+var declarationMapToString = (declarationMap, binding) => {
+  const entries = Array.from(declarationMap.entries()).map(([property, value]) => ({ property, value }));
+  if (binding?.declarationMapToString) {
+    return binding.declarationMapToString(entries);
+  }
+  return entries.map(({ property, value }) => `${property}: ${value}`).join("; ");
 };
 var classToCss = async (input, options = {}) => {
-  const inputClasses = normalizeClassInput(input);
+  const binding = await requireNativeCssCompiler();
+  const inputClasses = normalizeClassInput(input, binding);
   const normalizedOptions = normalizeClassToCssOptions(options);
   if (inputClasses.length === 0) {
     return {
@@ -691,7 +635,6 @@ var classToCss = async (input, options = {}) => {
       sizeBytes: 0
     };
   }
-  const binding = await requireNativeCssCompiler();
   const prefix = normalizedOptions.prefix;
   const results = await Promise.all(
     inputClasses.map(async (className) => {
@@ -700,7 +643,7 @@ var classToCss = async (input, options = {}) => {
           return binding.compileCss([className], prefix);
         } catch (error) {
           throw new Error(
-            `Native analyzer failed while compiling class "${className}": ${formatErrorMessage2(error)}`,
+            `Native analyzer failed while compiling class "${className}": ${formatErrorMessage(error)}`,
             { cause: error }
           );
         }
@@ -724,7 +667,7 @@ var classToCss = async (input, options = {}) => {
   const sizeBytes = results.reduce((sum, r) => sum + r.sizeBytes, 0);
   const declarationMap = /* @__PURE__ */ new Map();
   for (const result of results) {
-    mergeDeclarationMap(declarationMap, result.css);
+    mergeDeclarationMap(declarationMap, result.css, binding);
   }
   const uniqueUnknown = Array.from(new Set(unknownClasses));
   if (normalizedOptions.strict && uniqueUnknown.length > 0) {
@@ -733,7 +676,7 @@ var classToCss = async (input, options = {}) => {
   return {
     inputClasses,
     css: cssChunks.filter((chunk) => chunk.length > 0).join("\n"),
-    declarations: declarationMapToString(declarationMap),
+    declarations: declarationMapToString(declarationMap, binding),
     resolvedClasses: Array.from(new Set(resolvedClasses)),
     unknownClasses: uniqueUnknown,
     sizeBytes
@@ -767,8 +710,8 @@ function stableKeyframesEntries(stops) {
 }
 function animationCacheKey(opts) {
   const normalized = {
-    from: opts.from.trim(),
-    to: opts.to.trim(),
+    from: (opts.from ?? "").trim(),
+    to: (opts.to ?? "").trim(),
     duration: normalizeNumber(opts.duration, DEFAULT_DURATION),
     easing: (opts.easing ?? DEFAULT_EASING).trim(),
     delay: normalizeNumber(opts.delay, DEFAULT_DELAY),
@@ -782,7 +725,10 @@ function animationCacheKey(opts) {
 function keyframesCacheKey(name, stops) {
   return `${name}::${JSON.stringify(stableKeyframesEntries(stops))}`;
 }
-function splitClasses(classList) {
+function splitClasses(classList, binding) {
+  if (binding?.splitAnimateClasses) {
+    return binding.splitAnimateClasses(classList);
+  }
   return classList.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
 }
 async function validateTailwindClasses(entries) {
@@ -790,147 +736,101 @@ async function validateTailwindClasses(entries) {
   const unknownByContext = /* @__PURE__ */ new Map();
   const failures = [];
   for (const entry of entries) {
-    const classes = splitClasses(entry.classList);
+    const classes = splitClasses(entry.classList, binding);
     if (classes.length === 0) continue;
-    try {
-      if (typeof binding.compileCss === "function") {
-        const compiled = binding.compileCss(classes, null);
-        if (!compiled) {
-          failures.push(
-            `Animation ${entry.context} failed validation: native compileCss returned no result.`
-          );
-          continue;
-        }
-        if (compiled.unknownClasses.length > 0) {
-          const bucket = unknownByContext.get(entry.context) ?? /* @__PURE__ */ new Set();
-          for (const className of compiled.unknownClasses) bucket.add(className);
-          unknownByContext.set(entry.context, bucket);
-        }
-        continue;
-      }
-      const checked = await classToCss(classes, { strict: false });
-      if (checked.unknownClasses.length > 0) {
-        const bucket = unknownByContext.get(entry.context) ?? /* @__PURE__ */ new Set();
-        for (const className of checked.unknownClasses) bucket.add(className);
-        unknownByContext.set(entry.context, bucket);
-      }
-    } catch (error) {
-      failures.push(`Animation ${entry.context} failed validation: ${formatErrorMessage(error)}`);
+    const result = await classToCss(classes);
+    if (result.unknownClasses.length > 0) {
+      unknownByContext.set(entry.context, new Set(result.unknownClasses));
     }
   }
-  const issues = [];
-  for (const [context, classes] of unknownByContext.entries()) {
-    issues.push(
-      `Animation ${context} contains unknown Tailwind classes: ${Array.from(classes).join(", ")}`
-    );
+  for (const [context, unknownSet] of unknownByContext.entries()) {
+    failures.push(`[${context}] unknown classes: ${Array.from(unknownSet).join(", ")}`);
   }
-  issues.push(...failures);
-  if (issues.length > 0) {
-    throw new Error(issues.join("\n"));
+  if (failures.length > 0) {
+    throw new Error(`Animation validation failed:
+${failures.join("\n")}`);
   }
 }
-var AnimationRegistry = class {
-  animations;
-  animationBySignature;
-  keyframesBySignature;
-  constructor(options = {}) {
-    const cacheLimit = normalizeCacheLimit(options.cacheLimit);
-    this.animations = new LRUCache(cacheLimit);
-    this.animationBySignature = new LRUCache(cacheLimit);
-    this.keyframesBySignature = new LRUCache(cacheLimit);
-  }
-  async compileAnimation(opts) {
-    const signature = animationCacheKey(opts);
-    const existingClassName = this.animationBySignature.get(signature);
-    if (existingClassName) {
-      const cached = this.animations.get(existingClassName);
+function createAnimationRegistry(options = {}) {
+  const cacheLimit = normalizeCacheLimit(options.cacheLimit);
+  const cache = new LRUCache(cacheLimit);
+  const cssChunks = [];
+  const classNames = /* @__PURE__ */ new Set();
+  return {
+    async compileAnimation(opts) {
+      const key = animationCacheKey(opts);
+      const cached = cache.get(key);
       if (cached) return cached;
-      this.animationBySignature.delete(signature);
-    }
-    await validateTailwindClasses([
-      { classList: opts.from, context: `"from" in ${opts.name ?? "anonymous animation"}` },
-      { classList: opts.to, context: `"to" in ${opts.name ?? "anonymous animation"}` }
-    ]);
-    const binding = await getAnimateBinding();
-    const duration = normalizeNumber(opts.duration, DEFAULT_DURATION);
-    const easing = opts.easing ?? DEFAULT_EASING;
-    const delay = normalizeNumber(opts.delay, DEFAULT_DELAY);
-    const fill = opts.fill ?? DEFAULT_FILL;
-    const iterations = normalizeIterations(opts.iterations);
-    const direction = opts.direction ?? DEFAULT_DIRECTION;
-    const compiled = binding.compileAnimation?.(
-      opts.from,
-      opts.to,
-      opts.name ?? null,
-      duration,
-      easing,
-      delay,
-      fill,
-      iterations,
-      direction
-    );
-    if (!compiled) {
-      throw new Error(
-        `Native animate backend failed to compile animation "${opts.name ?? "anonymous animation"}".`
+      const binding = await getAnimateBinding();
+      const classesToValidate = [
+        { classList: opts.from ?? "", context: "from" },
+        { classList: opts.to ?? "", context: "to" }
+      ].filter((entry) => entry.classList.trim().length > 0);
+      if (classesToValidate.length > 0) {
+        await validateTailwindClasses(classesToValidate);
+      }
+      if (!binding.compileAnimation) {
+        throw new Error("FATAL: Native binding 'compileAnimation' is required but not available.");
+      }
+      const result = binding.compileAnimation(
+        opts.from,
+        opts.to,
+        opts.name ?? null,
+        normalizeNumber(opts.duration, DEFAULT_DURATION),
+        opts.easing ?? DEFAULT_EASING,
+        normalizeNumber(opts.delay, DEFAULT_DELAY),
+        opts.fill ?? DEFAULT_FILL,
+        normalizeIterations(opts.iterations),
+        opts.direction ?? DEFAULT_DIRECTION
       );
-    }
-    const result = {
-      className: compiled.className,
-      keyframesCss: compiled.keyframesCss,
-      animationCss: compiled.animationCss
-    };
-    this.animations.set(result.className, result);
-    this.animationBySignature.set(signature, result.className);
-    return result;
-  }
-  async compileKeyframes(name, stops) {
-    const signature = keyframesCacheKey(name, stops);
-    const existingClassName = this.keyframesBySignature.get(signature);
-    if (existingClassName) {
-      const cached = this.animations.get(existingClassName);
+      if (!result) {
+        throw new Error(`compileAnimation returned null for opts: ${JSON.stringify(opts)}`);
+      }
+      const compiled = {
+        className: result.className,
+        keyframesCss: result.keyframesCss,
+        animationCss: result.animationCss
+      };
+      cache.set(key, compiled);
+      if (result.keyframesCss) cssChunks.push(result.keyframesCss);
+      if (result.animationCss) cssChunks.push(result.animationCss);
+      return compiled;
+    },
+    async compileKeyframes(name, stops) {
+      const key = keyframesCacheKey(name, stops);
+      const cached = cache.get(key);
       if (cached) return cached;
-      this.keyframesBySignature.delete(signature);
-    }
-    await validateTailwindClasses(
-      Object.entries(stops).map(([offset, classes]) => ({
-        classList: classes,
-        context: `"${offset}" stop in keyframes "${name}"`
-      }))
-    );
-    const binding = await getAnimateBinding();
-    const stopsJson = JSON.stringify(stableKeyframesEntries(stops));
-    const compiled = binding.compileKeyframes?.(name, stopsJson);
-    if (!compiled) {
-      throw new Error(`Native animate backend failed to compile keyframes "${name}".`);
-    }
-    const result = {
-      className: compiled.className,
-      keyframesCss: compiled.keyframesCss,
-      animationCss: compiled.animationCss
-    };
-    this.animations.set(result.className, result);
-    this.keyframesBySignature.set(signature, result.className);
-    return result;
-  }
-  extractCss() {
-    const lines = [];
-    for (const [, compiled] of this.animations.entries()) {
-      lines.push(compiled.keyframesCss);
-      lines.push(`.${compiled.className} { ${compiled.animationCss} }`);
+      const binding = await getAnimateBinding();
+      const stopsJson = JSON.stringify(stableKeyframesEntries(stops));
+      if (!binding.compileKeyframes) {
+        throw new Error("FATAL: Native binding 'compileKeyframes' is required but not available.");
+      }
+      const result = binding.compileKeyframes(name, stopsJson);
+      if (!result) {
+        throw new Error(`compileKeyframes returned null for name: ${name}`);
+      }
+      const compiled = {
+        className: result.className,
+        keyframesCss: result.keyframesCss,
+        animationCss: result.animationCss
+      };
+      cache.set(key, compiled);
+      if (result.keyframesCss) cssChunks.push(result.keyframesCss);
+      if (result.animationCss) cssChunks.push(result.animationCss);
+      return compiled;
+    },
+    extractCss() {
+      return cssChunks.join("\n");
+    },
+    reset() {
+      cache.clear?.();
+      cssChunks.length = 0;
+      classNames.clear();
+    },
+    has(className) {
+      return classNames.has(className);
     }
-    return lines.join("\n\n");
-  }
-  reset() {
-    this.animations.clear();
-    this.animationBySignature.clear();
-    this.keyframesBySignature.clear();
-  }
-  has(className) {
-    return this.animations.has(className);
-  }
-};
-function createAnimationRegistry(options = {}) {
-  return new AnimationRegistry(options);
+  };
 }
 
 // packages/domain/animate/src/index.ts
@@ -941,8 +841,14 @@ async function initAnimate2() {
 function getDefaultAnimationRegistry() {
   return defaultRegistry;
 }
-async function compileAnimation(opts, registry = defaultRegistry) {
-  return registry.compileAnimation(opts);
+async function compileAnimation(optsOrName, secondArg) {
+  if (typeof optsOrName === "string") {
+    const partialOpts = secondArg && typeof secondArg.compileAnimation !== "function" ? secondArg : {};
+    const opts = { from: "", to: "", ...partialOpts, name: optsOrName };
+    return defaultRegistry.compileAnimation(opts);
+  }
+  const registry = secondArg && typeof secondArg.compileAnimation === "function" ? secondArg : defaultRegistry;
+  return registry.compileAnimation(optsOrName);
 }
 async function compileKeyframes(name, stops, registry = defaultRegistry) {
   return registry.compileKeyframes(name, stops);
@@ -983,7 +889,7 @@ function injectAnimationCss(registry = defaultRegistry, options = {}) {
 }
 var animations = createAnimationPresets(defaultRegistry);
 
-exports.AnimationRegistry = AnimationRegistry;
+exports.AnimationRegistry = createAnimationRegistry;
 exports.animate = animate;
 exports.animations = animations;
 exports.compileAnimation = compileAnimation;