tailwind-styled-v4 5.0.0 → 5.0.1

package/dist/index.js

@@ -1,10 +1,877 @@
-import { __require } from './chunk-VZEJV27B.js';
-import React from 'react';
-import { twMerge } from 'tailwind-merge';
+'use strict';
 
-/* tailwind-styled-v4 v4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+var fs = require('fs');
+var module$1 = require('module');
+var os = require('os');
+var path = require('path');
+var url = require('url');
+var React = require('react');
+var tailwindMerge = require('tailwind-merge');
 
-// src/containerQuery.ts
+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 os__default = /*#__PURE__*/_interopDefault(os);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+/* tailwind-styled-v4 v5.0.1 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/shared/src/cache.ts
+var LRUCache;
+var init_cache = __esm({
+  "packages/shared/src/cache.ts"() {
+    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 getPlatformExtension() {
+  const platform = os__default.default.platform();
+  switch (platform) {
+    case "win32":
+      return ".node";
+    case "darwin":
+      return ".dylib";
+    case "linux":
+      return ".so";
+    default:
+      return ".node";
+  }
+}
+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 ?? ["TWS_NATIVE_PATH"];
+  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) {
+    const ext = options.platformExtension ?? getPlatformExtension();
+    const defaultBindingName = `tailwind_styled_parser${ext}`;
+    out.push(path__default.default.resolve(process.cwd(), "native", defaultBindingName));
+    out.push(path__default.default.resolve(options.runtimeDir, "..", "..", "..", "native", defaultBindingName));
+  }
+  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 init_nativeBinding = __esm({
+  "packages/shared/src/nativeBinding.ts"() {
+  }
+});
+
+// packages/shared/src/index.ts
+var init_src = __esm({
+  "packages/shared/src/index.ts"() {
+    init_cache();
+    init_nativeBinding();
+  }
+});
+
+// packages/animate/src/binding.ts
+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('index.js', 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();
+}
+var bindingPromise, DEBUG_NAMESPACE, debugLog;
+var init_binding = __esm({
+  "packages/animate/src/binding.ts"() {
+    init_src();
+    bindingPromise = null;
+    DEBUG_NAMESPACE = "tailwind-styled:animate";
+    debugLog = createDebugLogger(DEBUG_NAMESPACE, "tailwind-styled/animate");
+  }
+});
+
+// packages/animate/src/preset.ts
+function createAnimationPresets(registry) {
+  const cache2 = new LRUCache(DEFAULT_PRESET_CACHE_LIMIT);
+  const withCache = (cacheKey, factory) => async () => {
+    const cached = cache2.get(cacheKey);
+    if (cached) {
+      const className = await cached;
+      if (registry.has(className)) return className;
+      cache2.delete(cacheKey);
+    }
+    const pending = factory();
+    cache2.set(cacheKey, pending);
+    try {
+      return await pending;
+    } catch (error) {
+      cache2.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 DEFAULT_PRESET_CACHE_LIMIT;
+var init_preset = __esm({
+  "packages/animate/src/preset.ts"() {
+    init_src();
+    DEFAULT_PRESET_CACHE_LIMIT = 32;
+  }
+});
+function formatErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var DEBUG_NAMESPACE2, debugLog2;
+var init_utils = __esm({
+  "packages/analyzer/src/utils.ts"() {
+    init_src();
+    DEBUG_NAMESPACE2 = "tailwind-styled:analyzer";
+    debugLog2 = createDebugLogger(DEBUG_NAMESPACE2, "tailwind-styled/analyzer");
+  }
+});
+
+// packages/analyzer/src/binding.ts
+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('index.js', 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}.`);
+}
+var bindingCache, bindingCandidateCache, bindingLoadErrorsCache, loadedBindingPathCache;
+var init_binding2 = __esm({
+  "packages/analyzer/src/binding.ts"() {
+    init_src();
+    init_utils();
+    bindingCandidateCache = [];
+    bindingLoadErrorsCache = [];
+    loadedBindingPathCache = null;
+  }
+});
+
+// packages/analyzer/src/classToCss.ts
+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
+  };
+}
+var init_classToCss = __esm({
+  "packages/analyzer/src/classToCss.ts"() {
+    init_binding2();
+    init_utils();
+  }
+});
+
+// packages/analyzer/src/index.ts
+var init_src2 = __esm({
+  "packages/analyzer/src/index.ts"() {
+    init_classToCss();
+  }
+});
+
+// packages/animate/src/registry.ts
+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"));
+  }
+}
+function createAnimationRegistry(options = {}) {
+  return new AnimationRegistry(options);
+}
+var DEFAULT_DURATION, DEFAULT_EASING, DEFAULT_DELAY, DEFAULT_FILL, DEFAULT_ITERATIONS, DEFAULT_DIRECTION, DEFAULT_CACHE_LIMIT, AnimationRegistry;
+var init_registry = __esm({
+  "packages/animate/src/registry.ts"() {
+    init_src2();
+    init_src();
+    init_binding();
+    DEFAULT_DURATION = 300;
+    DEFAULT_EASING = "ease-out";
+    DEFAULT_DELAY = 0;
+    DEFAULT_FILL = "both";
+    DEFAULT_ITERATIONS = 1;
+    DEFAULT_DIRECTION = "normal";
+    DEFAULT_CACHE_LIMIT = 512;
+    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);
+      }
+    };
+  }
+});
+
+// packages/animate/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnimationRegistry: () => AnimationRegistry,
+  animate: () => animate,
+  animations: () => animations,
+  compileAnimation: () => compileAnimation,
+  compileKeyframes: () => compileKeyframes,
+  createAnimationRegistry: () => createAnimationRegistry,
+  extractAnimationCss: () => extractAnimationCss,
+  getDefaultAnimationRegistry: () => getDefaultAnimationRegistry,
+  initAnimate: () => initAnimate2,
+  injectAnimationCss: () => injectAnimationCss,
+  keyframes: () => keyframes,
+  resetAnimationRegistry: () => resetAnimationRegistry
+});
+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 defaultRegistry, animations;
+var init_src3 = __esm({
+  "packages/animate/src/index.ts"() {
+    init_binding();
+    init_preset();
+    init_registry();
+    init_registry();
+    defaultRegistry = createAnimationRegistry();
+    animations = createAnimationPresets(defaultRegistry);
+  }
+});
+
+// packages/core/src/containerQuery.ts
 var CONTAINER_BREAKPOINTS = {
   xs: "240px",
   sm: "320px",
@@ -154,7 +1021,7 @@ function getContainerRegistry() {
   return containerRegistry;
 }
 
-// src/stateEngine.ts
+// packages/core/src/stateEngine.ts
 var stateRegistry = /* @__PURE__ */ new Map();
 if (typeof window !== "undefined") {
   window.__TW_STATE_REGISTRY__ = stateRegistry;
@@ -330,7 +1197,7 @@ function getStateRegistry() {
   return stateRegistry;
 }
 
-// src/createComponent.ts
+// packages/core/src/createComponent.ts
 var ALWAYS_BLOCKED = /* @__PURE__ */ new Set(["base", "_ref", "state", "container", "containerName"]);
 function makeFilterProps(variantKeys) {
   return function filterProps(props) {
@@ -379,26 +1246,26 @@ function createComponent(tag, config) {
   const filterProps = makeFilterProps(variantKeySet);
   const tagStr = typeof tag === "string" ? tag : tag.displayName ?? "Component";
   if (isStatic || Object.keys(variants).length === 0) {
-    const Component2 = React.forwardRef((props, ref) => {
+    const Component2 = React__default.default.forwardRef((props, ref) => {
       const { className, ...rest } = props;
-      return React.createElement(tag, {
+      return React__default.default.createElement(tag, {
         ref,
         ...filterProps(rest),
-        className: twMerge(base, engineClasses, className)
+        className: tailwindMerge.twMerge(base, engineClasses, className)
       });
     });
     Component2.displayName = `tw.${tagStr}`;
     attachExtend(Component2, tag, base, config);
     return Component2;
   }
-  const Component = React.forwardRef((props, ref) => {
+  const Component = React__default.default.forwardRef((props, ref) => {
     const { className } = props;
     const variantClasses = resolveVariants(variants, props, defaultVariants);
     const compoundClasses = resolveCompound(compoundVariants, props);
-    return React.createElement(tag, {
+    return React__default.default.createElement(tag, {
       ref,
       ...filterProps(props),
-      className: twMerge(base, variantClasses, compoundClasses, engineClasses, className)
+      className: tailwindMerge.twMerge(base, variantClasses, compoundClasses, engineClasses, className)
     });
   });
   Component.displayName = `tw.${tagStr}`;
@@ -408,7 +1275,7 @@ function createComponent(tag, config) {
 function attachExtend(Component, originalTag, base, config) {
   Component.extend = (strings, ..._exprs) => {
     const extra = strings.raw.join("").trim().replace(/\s+/g, " ");
-    const merged = twMerge(base, extra);
+    const merged = tailwindMerge.twMerge(base, extra);
     return createComponent(
       originalTag,
       typeof config === "string" ? merged : { ...config, base: merged }
@@ -432,9 +1299,9 @@ function attachExtend(Component, originalTag, base, config) {
   };
   Component.animate = async (opts) => {
     try {
-      const { animate: animateFn } = __require("@tailwind-styled/animate");
+      const { animate: animateFn } = (init_src3(), __toCommonJS(src_exports));
       const animClass = await animateFn(opts);
-      const merged = twMerge(base, animClass);
+      const merged = tailwindMerge.twMerge(base, animClass);
       return createComponent(
         originalTag,
         typeof config === "string" ? merged : { ...config, base: merged }
@@ -461,23 +1328,23 @@ function cv(config) {
       if (match) classes.push(cls);
     }
     if (props.className) classes.push(props.className);
-    return twMerge(...classes);
+    return tailwindMerge.twMerge(...classes);
   };
 }
 function cn(...inputs) {
   return inputs.filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
 }
 function cx(...inputs) {
-  return twMerge(...inputs.filter(Boolean));
+  return tailwindMerge.twMerge(...inputs.filter(Boolean));
 }
 var cxm = cx;
-function normalizeClassInput(classLists) {
+function normalizeClassInput2(classLists) {
   return classLists.filter(Boolean).map((v) => String(v).trim()).filter((v) => v.length > 0);
 }
 function createTwMerge(_options = {}) {
   return function twMerge5(...classLists) {
-    const clean = normalizeClassInput(classLists);
-    return twMerge(clean.join(" "));
+    const clean = normalizeClassInput2(classLists);
+    return tailwindMerge.twMerge(clean.join(" "));
   };
 }
 var twMerge4 = createTwMerge();
@@ -491,7 +1358,7 @@ function mergeWithRules(rules, ...classLists) {
   return classes.join(" ");
 }
 
-// src/liveTokenEngine.ts
+// packages/core/src/liveTokenEngine.ts
 var _currentTokens = {};
 var _subscribers = /* @__PURE__ */ new Set();
 var _styleEl = null;
@@ -624,7 +1491,7 @@ function createUseTokens() {
   };
 }
 
-// src/styledSystem.ts
+// packages/core/src/styledSystem.ts
 function tokenVarName(prefix, group, name) {
   return `--${prefix}-${group}-${name}`;
 }
@@ -633,8 +1500,8 @@ function tokenVarRef(prefix, group, name) {
 }
 function resolveTokenRef(tokens, prefix, value) {
   if (value.startsWith("token:")) {
-    const path = value.slice(6);
-    const [group, name] = path.split(".");
+    const path2 = value.slice(6);
+    const [group, name] = path2.split(".");
     if (group && name && tokens[group]?.[name] !== void 0) {
       return tokenVarRef(prefix, group, name);
     }
@@ -732,13 +1599,13 @@ function createStyledSystem(config) {
       return createComponent(tag, merged);
     };
   }
-  function token(path) {
-    const [group, name] = path.split(".");
-    if (!group || !name) return path;
+  function token(path2) {
+    const [group, name] = path2.split(".");
+    if (!group || !name) return path2;
     return tokenVarRef(prefix, group, name);
   }
-  function rawToken(path) {
-    const [group, name] = path.split(".");
+  function rawToken(path2) {
+    const [group, name] = path2.split(".");
     if (!group || !name) return void 0;
     return tokens[group]?.[name];
   }
@@ -778,7 +1645,7 @@ function createStyledSystem(config) {
   });
 }
 
-// src/styled.ts
+// packages/core/src/styled.ts
 function resolveVariantClass(options, props) {
   const out = [];
   const variants = options.variants ?? {};
@@ -809,7 +1676,7 @@ function styled(options) {
   };
 }
 
-// src/twProxy.ts
+// packages/core/src/twProxy.ts
 function parseTemplate(strings, exprs) {
   return strings.raw.reduce((acc, str, i) => {
     const expr = exprs[i];
@@ -961,7 +1828,7 @@ var tw = Object.assign(twCallable, tagFactories, {
   server
 });
 
-// src/twTheme.ts
+// packages/core/src/twTheme.ts
 function cssVar(varName, fallback) {
   const name = varName.startsWith("--") ? varName : `--${varName}`;
   return fallback ? `var(${name}, ${fallback})` : `var(${name})`;
@@ -1026,7 +1893,7 @@ var v4Tokens = {
   fontMono: twVar("font", "font-mono")
 };
 
-// src/parser.ts
+// packages/core/src/parser.ts
 var _getNodePath = () => typeof __require !== "undefined" ? __require("path") : null;
 var _getCreateRequire = () => {
   if (typeof __require !== "undefined") {
@@ -1198,7 +2065,7 @@ function parseTailwindClasses(input) {
   return splitClassListJS(input).map(parseClassTokenJS);
 }
 
-// src/themeReader.ts
+// packages/core/src/themeReader.ts
 var THEME_BLOCK_RE = /@theme\s*\{([\s\S]*?)\}/g;
 var CSS_VAR_RE = /--([a-zA-Z0-9_-]+)\s*:\s*([^;]+);/g;
 var cache = /* @__PURE__ */ new Map();
@@ -1300,6 +2167,48 @@ function clearThemeReaderCache() {
   cache.clear();
 }
 
-export { applyTokenSet, clearThemeReaderCache, cn, tokenRef as containerRef, createComponent, createStyledSystem, createTheme, createTwMerge, createUseTokens, cssVar, cv, cx, cxm, extractThemeFromCSS, generateContainerCss, generateStateCss, generateTokenCssString, generateTypeDefinitions, getContainerRegistry, getStateRegistry, getToken, getTokens, liveToken, mergeWithRules, parseClassToken, parseTailwindClasses, processContainer, processState, resolveStyledClassName, resolveThemeValue, server, setToken, setTokens, splitClassList, styled, subscribeTokens, t, tokenRef, tokenVar, tw, twMerge4 as twMerge, twVar, v4Tokens };
+exports.applyTokenSet = applyTokenSet;
+exports.clearThemeReaderCache = clearThemeReaderCache;
+exports.cn = cn;
+exports.containerRef = tokenRef;
+exports.createComponent = createComponent;
+exports.createStyledSystem = createStyledSystem;
+exports.createTheme = createTheme;
+exports.createTwMerge = createTwMerge;
+exports.createUseTokens = createUseTokens;
+exports.cssVar = cssVar;
+exports.cv = cv;
+exports.cx = cx;
+exports.cxm = cxm;
+exports.extractThemeFromCSS = extractThemeFromCSS;
+exports.generateContainerCss = generateContainerCss;
+exports.generateStateCss = generateStateCss;
+exports.generateTokenCssString = generateTokenCssString;
+exports.generateTypeDefinitions = generateTypeDefinitions;
+exports.getContainerRegistry = getContainerRegistry;
+exports.getStateRegistry = getStateRegistry;
+exports.getToken = getToken;
+exports.getTokens = getTokens;
+exports.liveToken = liveToken;
+exports.mergeWithRules = mergeWithRules;
+exports.parseClassToken = parseClassToken;
+exports.parseTailwindClasses = parseTailwindClasses;
+exports.processContainer = processContainer;
+exports.processState = processState;
+exports.resolveStyledClassName = resolveStyledClassName;
+exports.resolveThemeValue = resolveThemeValue;
+exports.server = server;
+exports.setToken = setToken;
+exports.setTokens = setTokens;
+exports.splitClassList = splitClassList;
+exports.styled = styled;
+exports.subscribeTokens = subscribeTokens;
+exports.t = t;
+exports.tokenRef = tokenRef;
+exports.tokenVar = tokenVar;
+exports.tw = tw;
+exports.twMerge = twMerge4;
+exports.twVar = twVar;
+exports.v4Tokens = v4Tokens;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map