tailwind-styled-v4 1.0.1 → 5.0.0

package/dist/animate.cjs

@@ -0,0 +1,771 @@
+'use strict';
+
+require('./chunk-Y5D3E72P.cjs');
+var fs = require('fs');
+var module$1 = require('module');
+var path = require('path');
+var url = require('url');
+require('crypto');
+require('@tailwind-styled/scanner');
+
+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 v4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+var LRUCache = class {
+  constructor(max = 256, ttlMs = null) {
+    this.map = /* @__PURE__ */ new Map();
+    this.max = max;
+    this.ttlMs = ttlMs;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (!entry) return void 0;
+    if (this.ttlMs !== null && Date.now() - entry.ts > this.ttlMs) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    else if (this.map.size >= this.max) {
+      this.map.delete(this.map.keys().next().value);
+    }
+    this.map.set(key, { value, ts: Date.now() });
+  }
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  delete(key) {
+    this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+  keys() {
+    return this.map.keys();
+  }
+  *values() {
+    for (const entry of this.map.values()) {
+      yield entry.value;
+    }
+  }
+  *entries() {
+    for (const [key, entry] of this.map.entries()) {
+      yield [key, entry.value];
+    }
+  }
+};
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function resolveRuntimeDir(dirnameValue, moduleImportUrl) {
+  if (typeof dirnameValue === "string" && dirnameValue.length > 0) return dirnameValue;
+  return path__default.default.dirname(url.fileURLToPath(moduleImportUrl));
+}
+function resolveNativeBindingCandidates(options) {
+  const out = [];
+  const envVarNames = options.envVarNames ?? [];
+  for (const envVarName of envVarNames) {
+    const raw = process.env[envVarName]?.trim();
+    if (!raw) continue;
+    const resolved = path__default.default.resolve(raw);
+    if (options.enforceNodeExtensionForEnvPath) {
+      if (path__default.default.extname(resolved).toLowerCase() !== ".node") {
+        throw new Error(
+          `Invalid native binding path from ${envVarName}="${raw}". Expected a .node file.`
+        );
+      }
+    }
+    out.push(resolved);
+  }
+  if (options.includeDefaultCandidates !== false) {
+    out.push(path__default.default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"));
+    out.push(path__default.default.resolve(options.runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"));
+  }
+  return Array.from(new Set(out));
+}
+function parseDebugToken(namespace, token) {
+  if (token === "*" || token === namespace || token === "tailwind-styled:*") return true;
+  return token.endsWith("*") && namespace.startsWith(token.slice(0, -1));
+}
+function isDebugNamespaceEnabled(namespace) {
+  if (process.env.TWS_DEBUG === "1" || process.env.TAILWIND_STYLED_DEBUG === "1") return true;
+  const raw = process.env.DEBUG;
+  if (!raw) return false;
+  return raw.split(",").map((token) => token.trim()).some((token) => parseDebugToken(namespace, token));
+}
+function createDebugLogger(namespace, label = namespace) {
+  const debugEnabled = isDebugNamespaceEnabled(namespace);
+  return (message) => {
+    if (!debugEnabled) return;
+    console.debug(`[${label}] ${message}`);
+  };
+}
+function loadNativeBinding(options) {
+  const req = module$1.createRequire(path__default.default.join(options.runtimeDir, "noop.cjs"));
+  const loadErrors = [];
+  for (const candidate of options.candidates) {
+    if (!fs__default.default.existsSync(candidate)) continue;
+    try {
+      const mod = req(candidate);
+      if (options.isValid(mod)) {
+        return {
+          binding: mod,
+          loadedPath: candidate,
+          loadErrors
+        };
+      }
+      loadErrors.push({
+        path: candidate,
+        message: options.invalidExportMessage
+      });
+    } catch (error) {
+      loadErrors.push({
+        path: candidate,
+        message: formatErrorMessage(error)
+      });
+    }
+  }
+  return {
+    binding: null,
+    loadedPath: null,
+    loadErrors
+  };
+}
+var LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+function getEnvLevel() {
+  const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVELS) return env;
+  return process.env.TWS_DEBUG_SCANNER === "1" ? "debug" : "info";
+}
+function createLogger(prefix, level) {
+  let currentLevel = getEnvLevel();
+  const log = (msgLevel, stream, args) => {
+    if (LEVELS[msgLevel] > LEVELS[currentLevel]) return;
+    const line = `[${prefix}] ${args.map(String).join(" ")}
+`;
+    process[stream].write(line);
+  };
+  return {
+    error: (...a) => log("error", "stderr", a),
+    warn: (...a) => log("warn", "stderr", a),
+    info: (...a) => log("info", "stdout", a),
+    debug: (...a) => log("debug", "stderr", a),
+    setLevel: (l) => {
+      currentLevel = l;
+    }
+  };
+}
+createLogger("tailwind-styled");
+
+// ../animate/src/binding.ts
+var bindingPromise = null;
+var DEBUG_NAMESPACE = "tailwind-styled:animate";
+var debugLog = createDebugLogger(DEBUG_NAMESPACE, "tailwind-styled/animate");
+function isAnimateModule(module) {
+  const candidate = module;
+  return typeof candidate?.compileAnimation === "function" && typeof candidate?.compileKeyframes === "function";
+}
+function resolveBindingCandidates(runtimeDir) {
+  return resolveNativeBindingCandidates({
+    runtimeDir,
+    envVarNames: ["TWS_ANIMATE_NATIVE_PATH", "TWS_NATIVE_PATH"],
+    enforceNodeExtensionForEnvPath: true
+  });
+}
+function loadAnimateBinding() {
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    throw new Error("Native animate backend is required in v5. TWS_NO_NATIVE/TWS_NO_RUST is not supported.");
+  }
+  const runtimeDir = resolveRuntimeDir(
+    typeof __dirname === "string" ? __dirname : void 0,
+    (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('animate.cjs', document.baseURI).href))
+  );
+  const candidates = resolveBindingCandidates(runtimeDir);
+  const { binding, loadErrors, loadedPath } = loadNativeBinding({
+    runtimeDir,
+    candidates,
+    isValid: isAnimateModule,
+    invalidExportMessage: "Module loaded but missing compileAnimation/compileKeyframes exports."
+  });
+  if (binding) {
+    debugLog(`native animate binding loaded from: ${loadedPath}`);
+    return binding;
+  }
+  if (loadErrors.length > 0) {
+    debugLog(
+      `native animate binding load failed for ${loadErrors.length} candidate(s): ${loadErrors.map((entry) => `${entry.path} (${entry.message})`).join("; ")}`
+    );
+  } else {
+    debugLog("native animate binding not found in any candidate path");
+  }
+  const lines = [
+    "Native animate backend not found. Ensure `tailwind_styled_parser.node` is built.",
+    "Checked paths:",
+    ...candidates.map((candidate) => `- ${candidate}`)
+  ];
+  if (loadErrors.length > 0) {
+    lines.push("Load errors:");
+    for (const error of loadErrors) lines.push(`- ${error.path}: ${error.message}`);
+  }
+  throw new Error(lines.join("\n"));
+}
+async function getAnimateBinding() {
+  if (!bindingPromise) {
+    bindingPromise = Promise.resolve().then(loadAnimateBinding);
+  }
+  return bindingPromise;
+}
+async function initAnimate() {
+  await getAnimateBinding();
+}
+
+// ../animate/src/preset.ts
+var DEFAULT_PRESET_CACHE_LIMIT = 32;
+function createAnimationPresets(registry) {
+  const cache = new LRUCache(DEFAULT_PRESET_CACHE_LIMIT);
+  const withCache = (cacheKey, factory) => async () => {
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      const className = await cached;
+      if (registry.has(className)) return className;
+      cache.delete(cacheKey);
+    }
+    const pending = factory();
+    cache.set(cacheKey, pending);
+    try {
+      return await pending;
+    } catch (error) {
+      cache.delete(cacheKey);
+      throw error;
+    }
+  };
+  return {
+    fadeIn: withCache(
+      "fadeIn",
+      async () => (await registry.compileAnimation({ from: "opacity-0", to: "opacity-100", duration: 200 })).className
+    ),
+    fadeOut: withCache(
+      "fadeOut",
+      async () => (await registry.compileAnimation({ from: "opacity-100", to: "opacity-0", duration: 200 })).className
+    ),
+    slideUp: withCache(
+      "slideUp",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 translate-y-4",
+        to: "opacity-100 translate-y-0",
+        duration: 300
+      })).className
+    ),
+    slideDown: withCache(
+      "slideDown",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 -translate-y-4",
+        to: "opacity-100 translate-y-0",
+        duration: 300
+      })).className
+    ),
+    slideLeft: withCache(
+      "slideLeft",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 translate-x-4",
+        to: "opacity-100 translate-x-0",
+        duration: 300
+      })).className
+    ),
+    slideRight: withCache(
+      "slideRight",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 -translate-x-4",
+        to: "opacity-100 translate-x-0",
+        duration: 300
+      })).className
+    ),
+    scaleIn: withCache(
+      "scaleIn",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 scale-95",
+        to: "opacity-100 scale-100",
+        duration: 200,
+        easing: "cubic-bezier(0.16,1,0.3,1)"
+      })).className
+    ),
+    scaleOut: withCache(
+      "scaleOut",
+      async () => (await registry.compileAnimation({
+        from: "opacity-100 scale-100",
+        to: "opacity-0 scale-95",
+        duration: 150
+      })).className
+    ),
+    blurIn: withCache(
+      "blurIn",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 blur-sm",
+        to: "opacity-100 blur-none",
+        duration: 300
+      })).className
+    ),
+    bounceIn: withCache(
+      "bounceIn",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 scale-50",
+        to: "opacity-100 scale-100",
+        duration: 400,
+        easing: "cubic-bezier(0.34,1.56,0.64,1)"
+      })).className
+    ),
+    spinIn: withCache(
+      "spinIn",
+      async () => (await registry.compileAnimation({
+        from: "opacity-0 rotate-180 scale-50",
+        to: "opacity-100 rotate-0 scale-100",
+        duration: 400,
+        easing: "cubic-bezier(0.16,1,0.3,1)"
+      })).className
+    )
+  };
+}
+var DEBUG_NAMESPACE2 = "tailwind-styled:analyzer";
+function formatErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var debugLog2 = createDebugLogger(DEBUG_NAMESPACE2, "tailwind-styled/analyzer");
+var bindingCache;
+var bindingCandidateCache = [];
+var bindingLoadErrorsCache = [];
+var loadedBindingPathCache = null;
+function isAnalyzerModule(module) {
+  const candidate = module;
+  return typeof candidate?.analyzeClasses === "function";
+}
+function getNativeBinding() {
+  if (bindingCache !== void 0) return bindingCache;
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    bindingCandidateCache = [];
+    bindingLoadErrorsCache = [];
+    loadedBindingPathCache = null;
+    debugLog2("native binding disabled by TWS_NO_NATIVE/TWS_NO_RUST");
+    bindingCache = null;
+    return bindingCache;
+  }
+  const runtimeDir = resolveRuntimeDir(
+    typeof __dirname === "string" ? __dirname : void 0,
+    (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('animate.cjs', document.baseURI).href))
+  );
+  const candidates = resolveNativeBindingCandidates({
+    runtimeDir,
+    envVarNames: ["TWS_NATIVE_PATH"]
+  });
+  const { binding, loadErrors, loadedPath } = loadNativeBinding({
+    runtimeDir,
+    candidates,
+    isValid: isAnalyzerModule,
+    invalidExportMessage: "Module loaded but missing `analyzeClasses` export."
+  });
+  bindingCandidateCache = candidates;
+  bindingLoadErrorsCache = loadErrors;
+  loadedBindingPathCache = loadedPath;
+  if (binding) {
+    debugLog2(`native binding loaded from: ${loadedPath}`);
+    bindingCache = binding;
+    return bindingCache;
+  }
+  if (bindingLoadErrorsCache.length > 0) {
+    debugLog2(
+      `native binding load failed for ${bindingLoadErrorsCache.length} candidate(s): ${bindingLoadErrorsCache.map((entry) => `${entry.path} (${entry.message})`).join("; ")}`
+    );
+  } else {
+    debugLog2("native binding not found in any candidate path");
+  }
+  bindingCache = null;
+  return bindingCache;
+}
+function requireNativeBinding() {
+  const binding = getNativeBinding();
+  if (binding?.analyzeClasses) return binding;
+  const lines = [
+    "Native analyzer binding not found. Ensure `tailwind_styled_parser.node` is built."
+  ];
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1") {
+    lines.push("Native loading is disabled by TWS_NO_NATIVE/TWS_NO_RUST.");
+  } else {
+    lines.push("Checked paths:");
+    for (const candidate of bindingCandidateCache) lines.push(`- ${candidate}`);
+    if (bindingLoadErrorsCache.length > 0) {
+      lines.push("Load errors:");
+      for (const failure of bindingLoadErrorsCache) {
+        lines.push(`- ${failure.path}: ${failure.message}`);
+      }
+    }
+  }
+  throw new Error(lines.join("\n"));
+}
+function requireNativeCssCompiler() {
+  const binding = requireNativeBinding();
+  if (typeof binding.compileCss === "function") return binding;
+  const loadedPathText = loadedBindingPathCache ? ` (${loadedBindingPathCache})` : "";
+  throw new Error(`Native analyzer compileCss binding is missing in v5${loadedPathText}.`);
+}
+function normalizeClassInput(input) {
+  if (typeof input === "string") {
+    return input.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
+  }
+  if (!Array.isArray(input)) {
+    throw new TypeError("classToCss input must be a string or an array of strings.");
+  }
+  const out = [];
+  for (const item of input) {
+    if (typeof item !== "string") {
+      throw new TypeError("classToCss input array must contain only strings.");
+    }
+    const value = item.trim();
+    if (value.length > 0) out.push(value);
+  }
+  return out;
+}
+function normalizeClassToCssOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError("classToCss options must be an object.");
+  }
+  const strict = options.strict ?? false;
+  if (typeof strict !== "boolean") {
+    throw new TypeError("classToCss options.strict must be a boolean when provided.");
+  }
+  const prefix = options.prefix ?? null;
+  if (prefix !== null && typeof prefix !== "string") {
+    throw new TypeError("classToCss options.prefix must be a string or null when provided.");
+  }
+  return { prefix, strict };
+}
+function mergeDeclarationMap(target, css) {
+  const ruleRegex = /\{([^}]*)\}/g;
+  let ruleMatch = ruleRegex.exec(css);
+  while (ruleMatch) {
+    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);
+    }
+    ruleMatch = ruleRegex.exec(css);
+  }
+}
+function declarationMapToString(declarationMap) {
+  return Array.from(declarationMap.entries()).map(([property, value]) => `${property}: ${value}`).join("; ");
+}
+async function classToCss(input, options = {}) {
+  const inputClasses = normalizeClassInput(input);
+  const normalizedOptions = normalizeClassToCssOptions(options);
+  if (inputClasses.length === 0) {
+    return {
+      inputClasses: [],
+      css: "",
+      declarations: "",
+      resolvedClasses: [],
+      unknownClasses: [],
+      sizeBytes: 0
+    };
+  }
+  const binding = requireNativeCssCompiler();
+  const prefix = normalizedOptions.prefix;
+  const cssChunks = [];
+  const resolvedClasses = [];
+  const unknownClasses = [];
+  let sizeBytes = 0;
+  const declarationMap = /* @__PURE__ */ new Map();
+  for (const className of inputClasses) {
+    let compiled = null;
+    try {
+      compiled = binding.compileCss([className], prefix);
+    } catch (error) {
+      throw new Error(
+        `Native analyzer failed while compiling class "${className}": ${formatErrorMessage2(error)}`,
+        { cause: error }
+      );
+    }
+    if (!compiled) {
+      throw new Error(`Native analyzer returned no result for class "${className}".`);
+    }
+    cssChunks.push(compiled.css);
+    resolvedClasses.push(...compiled.resolvedClasses);
+    unknownClasses.push(...compiled.unknownClasses);
+    sizeBytes += compiled.sizeBytes;
+    mergeDeclarationMap(declarationMap, compiled.css);
+  }
+  const uniqueUnknown = Array.from(new Set(unknownClasses));
+  if (normalizedOptions.strict && uniqueUnknown.length > 0) {
+    throw new Error(`Unknown Tailwind classes: ${uniqueUnknown.join(", ")}`);
+  }
+  return {
+    inputClasses,
+    css: cssChunks.filter((chunk) => chunk.length > 0).join("\n"),
+    declarations: declarationMapToString(declarationMap),
+    resolvedClasses: Array.from(new Set(resolvedClasses)),
+    unknownClasses: uniqueUnknown,
+    sizeBytes
+  };
+}
+
+// ../animate/src/registry.ts
+var DEFAULT_DURATION = 300;
+var DEFAULT_EASING = "ease-out";
+var DEFAULT_DELAY = 0;
+var DEFAULT_FILL = "both";
+var DEFAULT_ITERATIONS = 1;
+var DEFAULT_DIRECTION = "normal";
+var DEFAULT_CACHE_LIMIT = 512;
+function normalizeNumber(value, fallback) {
+  if (!Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.trunc(value));
+}
+function normalizeCacheLimit(value) {
+  if (!Number.isFinite(value)) return DEFAULT_CACHE_LIMIT;
+  return Math.max(1, Math.trunc(value));
+}
+function normalizeIterations(value) {
+  if (value === "infinite") return "infinite";
+  if (!Number.isFinite(value)) return String(DEFAULT_ITERATIONS);
+  return String(Math.max(0, Math.trunc(value)));
+}
+function stableKeyframesEntries(stops) {
+  return Object.entries(stops).map(([offset, classes]) => ({ offset, classes })).sort((left, right) => left.offset.localeCompare(right.offset));
+}
+function animationCacheKey(opts) {
+  const normalized = {
+    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),
+    fill: opts.fill ?? DEFAULT_FILL,
+    iterations: normalizeIterations(opts.iterations),
+    direction: opts.direction ?? DEFAULT_DIRECTION,
+    name: opts.name ?? ""
+  };
+  return JSON.stringify(normalized);
+}
+function keyframesCacheKey(name, stops) {
+  return `${name}::${JSON.stringify(stableKeyframesEntries(stops))}`;
+}
+function splitClasses(classList) {
+  return classList.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
+}
+async function validateTailwindClasses(entries) {
+  const binding = await getAnimateBinding();
+  const unknownByContext = /* @__PURE__ */ new Map();
+  const failures = [];
+  for (const entry of entries) {
+    const classes = splitClasses(entry.classList);
+    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 issues = [];
+  for (const [context, classes] of unknownByContext.entries()) {
+    issues.push(`Animation ${context} contains unknown Tailwind classes: ${Array.from(classes).join(", ")}`);
+  }
+  issues.push(...failures);
+  if (issues.length > 0) {
+    throw new Error(issues.join("\n"));
+  }
+}
+var AnimationRegistry = class {
+  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);
+      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 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 (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} }`);
+    }
+    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);
+}
+
+// ../animate/src/index.ts
+var defaultRegistry = createAnimationRegistry();
+async function initAnimate2() {
+  await initAnimate();
+}
+function getDefaultAnimationRegistry() {
+  return defaultRegistry;
+}
+async function compileAnimation(opts, registry = defaultRegistry) {
+  return registry.compileAnimation(opts);
+}
+async function compileKeyframes(name, stops, registry = defaultRegistry) {
+  return registry.compileKeyframes(name, stops);
+}
+async function animate(opts, registry = defaultRegistry) {
+  return (await registry.compileAnimation(opts)).className;
+}
+async function keyframes(name, stops, registry = defaultRegistry) {
+  return (await registry.compileKeyframes(name, stops)).className;
+}
+function extractAnimationCss(registry = defaultRegistry) {
+  return registry.extractCss();
+}
+function resetAnimationRegistry(registry = defaultRegistry) {
+  registry.reset();
+}
+function injectAnimationCss(registry = defaultRegistry, options = {}) {
+  const targetDocument = options.document ?? (typeof document !== "undefined" ? document : void 0);
+  if (!targetDocument) {
+    if (options.silent) return;
+    throw new Error("injectAnimationCss requires a browser Document.");
+  }
+  const styleId = options.styleId ?? "__tw_animate_styles__";
+  let styleEl = targetDocument.getElementById(styleId);
+  if (!styleEl) {
+    if (!targetDocument.head) {
+      if (options.silent) return;
+      throw new Error("injectAnimationCss requires document.head to exist.");
+    }
+    styleEl = targetDocument.createElement("style");
+    styleEl.id = styleId;
+    targetDocument.head.appendChild(styleEl);
+  }
+  styleEl.textContent = registry.extractCss();
+}
+var animations = createAnimationPresets(defaultRegistry);
+
+exports.AnimationRegistry = AnimationRegistry;
+exports.animate = animate;
+exports.animations = animations;
+exports.compileAnimation = compileAnimation;
+exports.compileKeyframes = compileKeyframes;
+exports.createAnimationRegistry = createAnimationRegistry;
+exports.extractAnimationCss = extractAnimationCss;
+exports.getDefaultAnimationRegistry = getDefaultAnimationRegistry;
+exports.initAnimate = initAnimate2;
+exports.injectAnimationCss = injectAnimationCss;
+exports.keyframes = keyframes;
+exports.resetAnimationRegistry = resetAnimationRegistry;
+//# sourceMappingURL=animate.cjs.map
+//# sourceMappingURL=animate.cjs.map