motionwind-core 2.1.0

package/dist/chunk-A7EAMXLY.js

@@ -0,0 +1,1098 @@
+import { GESTURE_KEYS, GESTURE_MAP, EASING_MAP } from './chunk-Z5I36REG.js';
+import { BUILT_IN_PRESETS } from './chunk-IJZCYKTO.js';
+
+// src/parser.ts
+var CACHE_MAX = 1e3;
+var cache = /* @__PURE__ */ new Map();
+function presetClasses(value) {
+  return (typeof value === "string" ? value.split(/\s+/) : [...value]).filter(
+    Boolean
+  );
+}
+function availablePresets(config) {
+  const pluginPresets = Object.assign(
+    {},
+    ...(config?.plugins ?? []).map((plugin) => plugin.presets ?? {})
+  );
+  return { ...BUILT_IN_PRESETS, ...pluginPresets, ...config?.presets ?? {} };
+}
+function expandConfiguredTokens(className, config, diagnostics) {
+  const presets = availablePresets(config);
+  const output = [];
+  const expand = (token, stack) => {
+    if (!token.startsWith("animate-preset-")) {
+      const durationName = token.startsWith("animate-duration-") ? token.slice("animate-duration-".length) : "";
+      const duration = durationName ? config?.tokens?.durations?.[durationName] : void 0;
+      if (duration !== void 0) {
+        output.push(`animate-duration-${duration}`);
+        return;
+      }
+      const easingName = token.startsWith("animate-ease-") ? token.slice("animate-ease-".length) : "";
+      const easing = easingName ? config?.tokens?.easings?.[easingName] : void 0;
+      if (Array.isArray(easing)) {
+        output.push(`animate-ease-[${easing.join(",")}]`);
+        return;
+      }
+      const springName = token.startsWith("animate-spring-") ? token.slice("animate-spring-".length) : "";
+      const spring = springName ? config?.tokens?.springs?.[springName] : void 0;
+      if (spring) {
+        output.push("animate-spring");
+        if (spring.stiffness !== void 0)
+          output.push(`animate-stiffness-${spring.stiffness}`);
+        if (spring.damping !== void 0)
+          output.push(`animate-damping-${spring.damping}`);
+        if (spring.bounce !== void 0)
+          output.push(`animate-bounce-${spring.bounce}`);
+        if (spring.mass !== void 0)
+          output.push(`animate-mass-${spring.mass}`);
+        return;
+      }
+      output.push(token);
+      return;
+    }
+    const name = token.slice("animate-preset-".length);
+    const preset = presets[name];
+    if (!preset) {
+      diagnostics.push({
+        code: "unknown-preset",
+        message: `Unknown motionwind preset "${name}".`,
+        severity: config?.strict ? "error" : "warning",
+        token
+      });
+      output.push(token);
+      return;
+    }
+    if (stack.includes(name) || stack.length >= 8) {
+      diagnostics.push({
+        code: "circular-preset",
+        message: `Circular motionwind preset expansion: ${[...stack, name].join(" \u2192 ")}.`,
+        severity: "error",
+        token
+      });
+      return;
+    }
+    for (const expanded of presetClasses(preset))
+      expand(expanded, [...stack, name]);
+  };
+  for (const token of className.split(/\s+/).filter(Boolean)) expand(token, []);
+  return output;
+}
+function mergePatch(patch, gestures, transition, viewport, dragConfig, layoutConfig, scroll, variants, variantState) {
+  for (const [key, values] of Object.entries(patch.gestures ?? {})) {
+    gestures[key] = {
+      ...gestures[key] ?? {},
+      ...values ?? {}
+    };
+  }
+  Object.assign(transition, patch.transition);
+  Object.assign(viewport, patch.viewport);
+  Object.assign(dragConfig, patch.dragConfig);
+  Object.assign(layoutConfig, patch.layoutConfig);
+  if (patch.scroll) {
+    Object.assign(scroll, patch.scroll);
+    if (patch.scroll.values)
+      scroll.values = { ...scroll.values, ...patch.scroll.values };
+  }
+  for (const [name, values] of Object.entries(patch.variants ?? {})) {
+    variants[name] = { ...variants[name] ?? {}, ...values };
+  }
+  Object.assign(variantState, patch.variantState);
+}
+var TAILWIND_ANIMATE_CLASSES = /* @__PURE__ */ new Set([
+  "animate-spin",
+  "animate-ping",
+  "animate-pulse",
+  "animate-bounce",
+  "animate-none"
+]);
+function cacheSet(key, value) {
+  if (cache.size >= CACHE_MAX) {
+    const firstKey = cache.keys().next().value;
+    if (firstKey !== void 0) cache.delete(firstKey);
+  }
+  cache.set(key, value);
+}
+var UNIT_MAP = {
+  pct: "%",
+  px: "px",
+  vh: "vh",
+  vw: "vw",
+  rem: "rem",
+  em: "em",
+  dvh: "dvh",
+  svh: "svh",
+  lvh: "lvh"
+};
+function parseNumericWithUnit(str, sign) {
+  if (str === "auto") return "auto";
+  for (const [suffix, unit] of Object.entries(UNIT_MAP)) {
+    if (str.endsWith(suffix)) {
+      const numPart = str.slice(0, -suffix.length);
+      const n2 = Number(numPart);
+      if (isNaN(n2)) return null;
+      return `${n2 * sign}${unit}`;
+    }
+  }
+  const n = Number(str);
+  if (isNaN(n)) return null;
+  return n * sign;
+}
+var ARBITRARY_VALUE_ALLOWLIST = /* @__PURE__ */ new Set([
+  "x",
+  "y",
+  "z",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "scaleZ",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY",
+  "originX",
+  "originY",
+  "originZ",
+  "perspective",
+  "opacity",
+  "filter",
+  "backdropFilter",
+  "clipPath",
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "padding",
+  "margin",
+  "gap",
+  "borderRadius",
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomLeftRadius",
+  "borderBottomRightRadius",
+  "borderWidth",
+  "fontSize",
+  "letterSpacing",
+  "lineHeight",
+  "backgroundColor",
+  "color",
+  "borderColor",
+  "boxShadow",
+  "textShadow",
+  "zIndex",
+  "pathLength",
+  "pathOffset",
+  "pathSpacing"
+]);
+function parsePropertyValue(raw) {
+  if (raw.startsWith("[") && raw.endsWith("]")) {
+    const inner = raw.slice(1, -1);
+    const eqIdx = inner.indexOf("=");
+    if (eqIdx === -1) return null;
+    const key = inner.slice(0, eqIdx);
+    if (!ARBITRARY_VALUE_ALLOWLIST.has(key)) return null;
+    const val = inner.slice(eqIdx + 1);
+    const num = Number(val);
+    return { key, value: isNaN(num) ? val : num };
+  }
+  let negative = false;
+  let str = raw;
+  if (str.startsWith("-")) {
+    negative = true;
+    str = str.slice(1);
+  }
+  const sign = negative ? -1 : 1;
+  const keyframeMatch = str.match(/^(\w+(?:-\w+)?)-\[([^\]]+)\]$/);
+  if (keyframeMatch) {
+    const propName = keyframeMatch[1];
+    const valuesStr = keyframeMatch[2];
+    const propKey = normalizePropertyName(propName);
+    if (propKey) {
+      const rawValues = valuesStr.split(",").reduce((acc, v) => {
+        const t = v.trim();
+        if (t) acc.push(t);
+        return acc;
+      }, []);
+      if (rawValues.length > 0) {
+        const scaleProps = /* @__PURE__ */ new Set([
+          "scale",
+          "scaleX",
+          "scaleY",
+          "scaleZ",
+          "opacity",
+          "brightness",
+          "contrast",
+          "saturate"
+        ]);
+        const parsed = [];
+        let valid = true;
+        for (const rv of rawValues) {
+          const unitVal = parseNumericWithUnit(rv, 1);
+          if (unitVal === null) {
+            valid = false;
+            break;
+          }
+          if (typeof unitVal === "number" && scaleProps.has(propKey)) {
+            parsed.push(unitVal / 100);
+          } else {
+            parsed.push(unitVal);
+          }
+        }
+        if (valid) {
+          return { key: propKey, value: parsed };
+        }
+      }
+    }
+  }
+  if (str.startsWith("scale-z-")) {
+    const n = Number(str.slice(8));
+    if (!isNaN(n)) return { key: "scaleZ", value: n / 100 * sign };
+  }
+  if (str.startsWith("scale-x-")) {
+    const n = Number(str.slice(8));
+    if (!isNaN(n)) return { key: "scaleX", value: n / 100 * sign };
+  }
+  if (str.startsWith("scale-y-")) {
+    const n = Number(str.slice(8));
+    if (!isNaN(n)) return { key: "scaleY", value: n / 100 * sign };
+  }
+  if (str.startsWith("scale-")) {
+    const n = Number(str.slice(6));
+    if (!isNaN(n)) return { key: "scale", value: n / 100 * sign };
+  }
+  if (str.startsWith("rotate-x-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n)) return { key: "rotateX", value: n * sign };
+  }
+  if (str.startsWith("rotate-y-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n)) return { key: "rotateY", value: n * sign };
+  }
+  if (str.startsWith("rotate-")) {
+    const n = Number(str.slice(7));
+    if (!isNaN(n)) return { key: "rotate", value: n * sign };
+  }
+  if (str.startsWith("skew-x-")) {
+    const n = Number(str.slice(7));
+    if (!isNaN(n)) return { key: "skewX", value: n * sign };
+  }
+  if (str.startsWith("skew-y-")) {
+    const n = Number(str.slice(7));
+    if (!isNaN(n)) return { key: "skewY", value: n * sign };
+  }
+  if (str.startsWith("skew-")) {
+    const n = Number(str.slice(5));
+    if (!isNaN(n)) return { key: "skew", value: n * sign };
+  }
+  if (str.startsWith("origin-x-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n)) return { key: "originX", value: n / 100 * sign };
+  }
+  if (str.startsWith("origin-y-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n)) return { key: "originY", value: n / 100 * sign };
+  }
+  if (str.startsWith("origin-z-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n)) return { key: "originZ", value: n * sign };
+  }
+  if (str.startsWith("perspective-")) {
+    const n = Number(str.slice(12));
+    if (!isNaN(n)) return { key: "perspective", value: n * sign };
+  }
+  if (str.startsWith("x-")) {
+    const val = parseNumericWithUnit(str.slice(2), sign);
+    if (val !== null) return { key: "x", value: val };
+  }
+  if (str.startsWith("y-")) {
+    const val = parseNumericWithUnit(str.slice(2), sign);
+    if (val !== null) return { key: "y", value: val };
+  }
+  if (str.startsWith("z-")) {
+    const suffix = str.slice(2);
+    if (suffix === "auto") return { key: "zIndex", value: "auto" };
+    const zn = Number(suffix);
+    if (!isNaN(zn) && [0, 10, 20, 30, 40, 50].includes(zn))
+      return { key: "zIndex", value: zn };
+  }
+  if (str.startsWith("z-")) {
+    const val = parseNumericWithUnit(str.slice(2), sign);
+    if (val !== null) return { key: "z", value: val };
+  }
+  if (str.startsWith("opacity-")) {
+    const n = Number(str.slice(8));
+    if (!isNaN(n)) return { key: "opacity", value: n / 100 * sign };
+  }
+  if (str.startsWith("blur-")) {
+    const n = Number(str.slice(5));
+    if (!isNaN(n))
+      return { key: "filter", value: `blur(${Math.max(0, n * sign)}px)` };
+  }
+  if (str.startsWith("brightness-")) {
+    const n = Number(str.slice(11));
+    if (!isNaN(n))
+      return {
+        key: "filter",
+        value: `brightness(${Math.max(0, n / 100 * sign)})`
+      };
+  }
+  if (str.startsWith("contrast-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n))
+      return {
+        key: "filter",
+        value: `contrast(${Math.max(0, n / 100 * sign)})`
+      };
+  }
+  if (str.startsWith("saturate-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n))
+      return {
+        key: "filter",
+        value: `saturate(${Math.max(0, n / 100 * sign)})`
+      };
+  }
+  if (str.startsWith("grayscale-")) {
+    const n = Number(str.slice(10));
+    if (!isNaN(n))
+      return {
+        key: "filter",
+        value: `grayscale(${Math.max(0, n / 100 * sign)})`
+      };
+  }
+  if (str.startsWith("sepia-")) {
+    const n = Number(str.slice(6));
+    if (!isNaN(n))
+      return {
+        key: "filter",
+        value: `sepia(${Math.max(0, n / 100 * sign)})`
+      };
+  }
+  if (str.startsWith("invert-")) {
+    const n = Number(str.slice(7));
+    if (!isNaN(n))
+      return {
+        key: "filter",
+        value: `invert(${Math.max(0, n / 100 * sign)})`
+      };
+  }
+  if (str.startsWith("hue-rotate-")) {
+    const n = Number(str.slice(11));
+    if (!isNaN(n))
+      return { key: "filter", value: `hue-rotate(${n * sign}deg)` };
+  }
+  if (str.startsWith("drop-shadow-")) {
+    const val = str.slice(12);
+    if (val.startsWith("[") && val.endsWith("]")) {
+      return {
+        key: "filter",
+        value: `drop-shadow(${val.slice(1, -1).replace(/_/g, " ")})`
+      };
+    }
+  }
+  if (str.startsWith("backdrop-blur-")) {
+    const n = Number(str.slice(14));
+    if (!isNaN(n))
+      return {
+        key: "backdropFilter",
+        value: `blur(${Math.max(0, n * sign)}px)`
+      };
+  }
+  if (str.startsWith("clip-")) {
+    const val = str.slice(5);
+    if (val.startsWith("[") && val.endsWith("]")) {
+      return { key: "clipPath", value: val.slice(1, -1) };
+    }
+  }
+  if (str.startsWith("rounded-tl-")) {
+    const n = Number(str.slice(11));
+    if (!isNaN(n)) return { key: "borderTopLeftRadius", value: n * sign };
+  }
+  if (str.startsWith("rounded-tr-")) {
+    const n = Number(str.slice(11));
+    if (!isNaN(n)) return { key: "borderTopRightRadius", value: n * sign };
+  }
+  if (str.startsWith("rounded-bl-")) {
+    const n = Number(str.slice(11));
+    if (!isNaN(n)) return { key: "borderBottomLeftRadius", value: n * sign };
+  }
+  if (str.startsWith("rounded-br-")) {
+    const n = Number(str.slice(11));
+    if (!isNaN(n)) return { key: "borderBottomRightRadius", value: n * sign };
+  }
+  if (str.startsWith("rounded-")) {
+    const n = Number(str.slice(8));
+    if (!isNaN(n)) return { key: "borderRadius", value: n * sign };
+  }
+  if (str.startsWith("w-")) {
+    const val = parseNumericWithUnit(str.slice(2), sign);
+    if (val !== null) return { key: "width", value: val };
+  }
+  if (str.startsWith("h-")) {
+    const val = parseNumericWithUnit(str.slice(2), sign);
+    if (val !== null) return { key: "height", value: val };
+  }
+  if (str.startsWith("top-")) {
+    const val = parseNumericWithUnit(str.slice(4), sign);
+    if (val !== null) return { key: "top", value: val };
+  }
+  if (str.startsWith("left-")) {
+    const val = parseNumericWithUnit(str.slice(5), sign);
+    if (val !== null) return { key: "left", value: val };
+  }
+  if (str.startsWith("right-")) {
+    const val = parseNumericWithUnit(str.slice(6), sign);
+    if (val !== null) return { key: "right", value: val };
+  }
+  if (str.startsWith("bottom-")) {
+    const val = parseNumericWithUnit(str.slice(7), sign);
+    if (val !== null) return { key: "bottom", value: val };
+  }
+  if (str.startsWith("p-")) {
+    const val = parseNumericWithUnit(str.slice(2), sign);
+    if (val !== null) return { key: "padding", value: val };
+  }
+  if (str.startsWith("m-")) {
+    const val = parseNumericWithUnit(str.slice(2), sign);
+    if (val !== null) return { key: "margin", value: val };
+  }
+  if (str.startsWith("gap-")) {
+    const val = parseNumericWithUnit(str.slice(4), sign);
+    if (val !== null) return { key: "gap", value: val };
+  }
+  if (str.startsWith("text-size-")) {
+    const val = parseNumericWithUnit(str.slice(10), sign);
+    if (val !== null) return { key: "fontSize", value: val };
+  }
+  if (str.startsWith("tracking-")) {
+    const val = parseNumericWithUnit(str.slice(9), sign);
+    if (val !== null) return { key: "letterSpacing", value: val };
+  }
+  if (str.startsWith("leading-")) {
+    const val = parseNumericWithUnit(str.slice(8), sign);
+    if (val !== null) return { key: "lineHeight", value: val };
+  }
+  if (str.startsWith("border-w-")) {
+    const n = Number(str.slice(9));
+    if (!isNaN(n)) return { key: "borderWidth", value: n * sign };
+  }
+  if (str.startsWith("path-length-")) {
+    const n = Number(str.slice(12));
+    if (!isNaN(n)) return { key: "pathLength", value: n * sign };
+  }
+  if (str.startsWith("path-offset-")) {
+    const n = Number(str.slice(12));
+    if (!isNaN(n)) return { key: "pathOffset", value: n * sign };
+  }
+  if (str.startsWith("path-spacing-")) {
+    const n = Number(str.slice(13));
+    if (!isNaN(n)) return { key: "pathSpacing", value: n * sign };
+  }
+  if (str.startsWith("bg-")) {
+    const color = str.slice(3);
+    if (isValidColor(color)) {
+      return { key: "backgroundColor", value: color };
+    }
+    return null;
+  }
+  if (str.startsWith("text-shadow-")) {
+    const val = str.slice(12);
+    if (val.startsWith("[") && val.endsWith("]")) {
+      return {
+        key: "textShadow",
+        value: val.slice(1, -1).replace(/_/g, " ")
+      };
+    }
+  }
+  if (str.startsWith("text-")) {
+    const color = str.slice(5);
+    if (isValidColor(color)) {
+      return { key: "color", value: color };
+    }
+    return null;
+  }
+  if (str.startsWith("border-")) {
+    const color = str.slice(7);
+    if (isValidColor(color)) {
+      return { key: "borderColor", value: color };
+    }
+    return null;
+  }
+  if (str.startsWith("shadow-")) {
+    const val = str.slice(7);
+    if (val.startsWith("[") && val.endsWith("]")) {
+      return { key: "boxShadow", value: val.slice(1, -1) };
+    }
+    return null;
+  }
+  return null;
+}
+var HEX_COLOR_RE = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var FUNC_COLOR_RE = /^(?:rgb|rgba|hsl|hsla)\(.+\)$/;
+function isValidColor(color) {
+  return HEX_COLOR_RE.test(color) || FUNC_COLOR_RE.test(color);
+}
+function normalizePropertyName(name) {
+  const map = {
+    scale: "scale",
+    "scale-x": "scaleX",
+    "scale-y": "scaleY",
+    "scale-z": "scaleZ",
+    rotate: "rotate",
+    "rotate-x": "rotateX",
+    "rotate-y": "rotateY",
+    x: "x",
+    y: "y",
+    z: "z",
+    opacity: "opacity",
+    "skew-x": "skewX",
+    "skew-y": "skewY",
+    skew: "skew",
+    w: "width",
+    h: "height",
+    rounded: "borderRadius",
+    "rounded-tl": "borderTopLeftRadius",
+    "rounded-tr": "borderTopRightRadius",
+    "rounded-bl": "borderBottomLeftRadius",
+    "rounded-br": "borderBottomRightRadius",
+    "origin-x": "originX",
+    "origin-y": "originY",
+    "origin-z": "originZ",
+    perspective: "perspective"
+  };
+  return map[name] ?? null;
+}
+function normalizeScrollProp(name) {
+  const n = name.toLowerCase().replace(/-/g, "");
+  const map = {
+    x: "x",
+    y: "y",
+    z: "z",
+    opacity: "opacity",
+    rotate: "rotate",
+    rotatex: "rotateX",
+    rotatey: "rotateY",
+    scale: "scale",
+    scalex: "scaleX",
+    scaley: "scaleY"
+  };
+  return map[n] ?? null;
+}
+function parseScrollValue(raw) {
+  const m = raw.match(/^([\w-]+?)-\[([^\]]+)\]$/);
+  if (!m) return null;
+  const key = normalizeScrollProp(m[1]);
+  if (!key) return null;
+  const parts = m[2].split(",").map((v) => Number(v.trim()));
+  if (parts.length < 2 || parts.some((n) => isNaN(n))) return null;
+  return { key, value: parts };
+}
+function classifyToken(token, gestures, transition, viewport, dragConfig, layoutConfig, scroll, variants, variantState) {
+  if (!token.startsWith("animate-")) return false;
+  const rest = token.slice(8);
+  const colonIdx = rest.indexOf(":");
+  if (colonIdx !== -1) {
+    const gesturePrefix = rest.slice(0, colonIdx);
+    const propValueStr = rest.slice(colonIdx + 1);
+    if (gesturePrefix === "scroll") {
+      const parsed = parseScrollValue(propValueStr);
+      if (parsed) {
+        scroll.values[parsed.key] = parsed.value;
+        return true;
+      }
+      return false;
+    }
+    if (gesturePrefix.startsWith("variant-")) {
+      const variantName = gesturePrefix.slice(8);
+      const parsed = parsePropertyValue(propValueStr);
+      if (variantName && parsed) {
+        if (!variants[variantName]) variants[variantName] = {};
+        const bucket = variants[variantName];
+        if ((parsed.key === "filter" || parsed.key === "backdropFilter") && typeof parsed.value === "string" && typeof bucket[parsed.key] === "string") {
+          bucket[parsed.key] += ` ${parsed.value}`;
+        } else {
+          bucket[parsed.key] = parsed.value;
+        }
+        return true;
+      }
+      return false;
+    }
+    if (GESTURE_KEYS.has(gesturePrefix)) {
+      const gestureKey = GESTURE_MAP[gesturePrefix];
+      const parsed = parsePropertyValue(propValueStr);
+      if (parsed) {
+        if (!gestures[gestureKey]) gestures[gestureKey] = {};
+        if ((parsed.key === "filter" || parsed.key === "backdropFilter") && typeof parsed.value === "string" && typeof gestures[gestureKey][parsed.key] === "string") {
+          gestures[gestureKey][parsed.key] += ` ${parsed.value}`;
+        } else {
+          if (process.env.NODE_ENV !== "production" && gestures[gestureKey][parsed.key] !== void 0) {
+            console.warn(
+              `[motionwind] Duplicate property "${parsed.key}" in "${gestureKey}" (class "${token}"). The last value will be used.`
+            );
+          }
+          gestures[gestureKey][parsed.key] = parsed.value;
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  if (rest.startsWith("duration-")) {
+    const ms = Number(rest.slice(9));
+    if (!isNaN(ms)) {
+      transition.duration = ms / 1e3;
+      return true;
+    }
+  }
+  if (rest.startsWith("delay-children-")) {
+    const ms = Number(rest.slice(15));
+    if (!isNaN(ms)) {
+      transition.delayChildren = ms / 1e3;
+      return true;
+    }
+  }
+  if (rest.startsWith("delay-")) {
+    const ms = Number(rest.slice(6));
+    if (!isNaN(ms)) {
+      transition.delay = ms / 1e3;
+      return true;
+    }
+  }
+  if (rest.startsWith("ease-[") && rest.endsWith("]")) {
+    const inner = rest.slice(6, -1);
+    const values = inner.split(",").map((v) => Number(v.trim()));
+    if (values.length === 4 && values.every((v) => !isNaN(v))) {
+      transition.ease = values;
+      return true;
+    }
+  }
+  if (rest.startsWith("ease-steps-")) {
+    const n = Number(rest.slice(11));
+    if (!isNaN(n) && n > 0) {
+      transition.ease = `steps(${n})`;
+      return true;
+    }
+  }
+  for (const [suffix, easeValue] of Object.entries(EASING_MAP)) {
+    if (rest === suffix) {
+      transition.ease = easeValue;
+      return true;
+    }
+  }
+  if (rest === "spring") {
+    transition.type = "spring";
+    return true;
+  }
+  if (rest.startsWith("stiffness-")) {
+    const n = Number(rest.slice(10));
+    if (!isNaN(n)) {
+      transition.stiffness = n;
+      return true;
+    }
+  }
+  if (rest.startsWith("damping-")) {
+    const n = Number(rest.slice(8));
+    if (!isNaN(n)) {
+      transition.damping = n;
+      return true;
+    }
+  }
+  if (rest.startsWith("bounce-")) {
+    const n = Number(rest.slice(7));
+    if (!isNaN(n)) {
+      transition.bounce = n / 100;
+      return true;
+    }
+  }
+  if (rest.startsWith("mass-")) {
+    const n = Number(rest.slice(5));
+    if (!isNaN(n)) {
+      transition.mass = n / 10;
+      return true;
+    }
+  }
+  if (rest === "repeat-infinite") {
+    transition.repeat = Infinity;
+    return true;
+  }
+  if (rest === "repeat-reverse") {
+    transition.repeatType = "reverse";
+    return true;
+  }
+  if (rest === "repeat-mirror") {
+    transition.repeatType = "mirror";
+    return true;
+  }
+  if (rest.startsWith("repeat-delay-")) {
+    const ms = Number(rest.slice(13));
+    if (!isNaN(ms)) {
+      transition.repeatDelay = ms / 1e3;
+      return true;
+    }
+  }
+  if (rest.startsWith("repeat-")) {
+    const n = Number(rest.slice(7));
+    if (!isNaN(n)) {
+      transition.repeat = n;
+      return true;
+    }
+  }
+  if (rest === "stagger-reverse") {
+    transition.staggerDirection = -1;
+    return true;
+  }
+  if (rest.startsWith("stagger-")) {
+    const ms = Number(rest.slice(8));
+    if (!isNaN(ms)) {
+      transition.staggerChildren = ms / 1e3;
+      return true;
+    }
+  }
+  if (rest === "when-before") {
+    transition.when = "beforeChildren";
+    return true;
+  }
+  if (rest === "when-after") {
+    transition.when = "afterChildren";
+    return true;
+  }
+  if (rest.startsWith("rest-speed-")) {
+    const n = Number(rest.slice(11));
+    if (!isNaN(n)) {
+      transition.restSpeed = n;
+      return true;
+    }
+  }
+  if (rest.startsWith("rest-delta-")) {
+    const n = Number(rest.slice(11));
+    if (!isNaN(n)) {
+      transition.restDelta = n;
+      return true;
+    }
+  }
+  if (rest.startsWith("times-[") && rest.endsWith("]")) {
+    const inner = rest.slice(7, -1);
+    const values = inner.split(",").map((v) => Number(v.trim()));
+    if (!values.some(isNaN)) {
+      transition.times = values;
+      return true;
+    }
+  }
+  if (rest === "once") {
+    viewport.once = true;
+    return true;
+  }
+  if (rest === "amount-all") {
+    viewport.amount = "all";
+    return true;
+  }
+  if (rest.startsWith("amount-")) {
+    const n = Number(rest.slice(7));
+    if (!isNaN(n)) {
+      viewport.amount = n / 100;
+      return true;
+    }
+  }
+  if (rest.startsWith("margin-")) {
+    const n = Number(rest.slice(7));
+    if (!isNaN(n)) {
+      viewport.margin = `${n}px`;
+      return true;
+    }
+  }
+  if (rest === "scroll-axis-x") {
+    scroll.axis = "x";
+    return true;
+  }
+  if (rest === "scroll-axis-y") {
+    scroll.axis = "y";
+    return true;
+  }
+  if (rest === "scroll-container") {
+    scroll.container = true;
+    return true;
+  }
+  if (rest.startsWith("scroll-offset-[") && rest.endsWith("]")) {
+    const inner = rest.slice(15, -1);
+    const parts = inner.split(",").map((p) => p.trim().replace(/_/g, " "));
+    if (parts.length === 2) {
+      scroll.offset = [parts[0], parts[1]];
+      return true;
+    }
+  }
+  if (rest.startsWith("from-")) {
+    const name = rest.slice(5);
+    if (name && !/\s/.test(name)) {
+      variantState.initial = name;
+      return true;
+    }
+  }
+  if (rest.startsWith("to-")) {
+    const name = rest.slice(3);
+    if (name && !/\s/.test(name)) {
+      variantState.animate = name;
+      return true;
+    }
+  }
+  if (rest.startsWith("exit-")) {
+    const name = rest.slice(5);
+    if (name && !/\s/.test(name)) {
+      variantState.exit = name;
+      return true;
+    }
+  }
+  if (rest === "drag-x") {
+    dragConfig.drag = "x";
+    return true;
+  }
+  if (rest === "drag-y") {
+    dragConfig.drag = "y";
+    return true;
+  }
+  if (rest === "drag-both") {
+    dragConfig.drag = true;
+    return true;
+  }
+  if (rest.startsWith("drag-elastic-")) {
+    const n = Number(rest.slice(13));
+    if (!isNaN(n)) {
+      dragConfig.dragElastic = n / 100;
+      return true;
+    }
+  }
+  if (rest === "drag-snap") {
+    dragConfig.dragSnapToOrigin = true;
+    return true;
+  }
+  if (rest === "drag-no-momentum") {
+    dragConfig.dragMomentum = false;
+    return true;
+  }
+  if (rest === "drag-lock") {
+    dragConfig.dragDirectionLock = true;
+    return true;
+  }
+  if (rest.startsWith("drag-constraint-")) {
+    const sub = rest.slice(16);
+    const sides = {
+      "t-": "top",
+      "l-": "left",
+      "r-": "right",
+      "b-": "bottom"
+    };
+    for (const [prefix, side] of Object.entries(sides)) {
+      if (sub.startsWith(prefix)) {
+        const n = Number(sub.slice(2));
+        if (!isNaN(n)) {
+          if (!dragConfig.dragConstraints) dragConfig.dragConstraints = {};
+          dragConfig.dragConstraints[side] = n;
+          return true;
+        }
+      }
+    }
+  }
+  if (rest === "layout") {
+    layoutConfig.layout = true;
+    return true;
+  }
+  if (rest === "layout-position") {
+    layoutConfig.layout = "position";
+    return true;
+  }
+  if (rest === "layout-size") {
+    layoutConfig.layout = "size";
+    return true;
+  }
+  if (rest === "layout-preserve") {
+    layoutConfig.layout = "preserve-aspect";
+    return true;
+  }
+  if (rest === "layout-scroll") {
+    layoutConfig.layoutScroll = true;
+    return true;
+  }
+  if (rest === "layout-root") {
+    layoutConfig.layoutRoot = true;
+    return true;
+  }
+  if (rest.startsWith("layout-id-")) {
+    const id = rest.slice(10);
+    if (id && !/\s/.test(id)) {
+      layoutConfig.layoutId = id;
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function parseMotionClasses(className, config) {
+  const cached = config ? void 0 : cache.get(className);
+  if (cached) return cached;
+  const diagnostics = [];
+  const tokens = expandConfiguredTokens(className, config, diagnostics);
+  const tailwind = [];
+  const gestures = {};
+  const transition = {};
+  const viewport = {};
+  const dragConfig = {};
+  const layoutConfig = {};
+  const scroll = { axis: "y", container: false, values: {} };
+  const variants = {};
+  const variantState = {};
+  let reducedMotionPolicy = void 0;
+  for (const token of tokens) {
+    let innerToken = token;
+    if (token.startsWith("motion-reduce:")) {
+      reducedMotionPolicy = "reduce";
+      innerToken = token.slice("motion-reduce:".length);
+    } else if (token.startsWith("motion-safe:")) {
+      reducedMotionPolicy = "safe";
+      innerToken = token.slice("motion-safe:".length);
+    }
+    if (!innerToken) continue;
+    let consumed = classifyToken(
+      innerToken,
+      gestures,
+      transition,
+      viewport,
+      dragConfig,
+      layoutConfig,
+      scroll,
+      variants,
+      variantState
+    );
+    if (!consumed) {
+      const easingName = innerToken.startsWith("animate-ease-") ? innerToken.slice("animate-ease-".length) : "";
+      const easing = easingName ? config?.tokens?.easings?.[easingName] : void 0;
+      if (typeof easing === "string") {
+        transition.ease = easing;
+        consumed = true;
+      }
+    }
+    if (!consumed) {
+      for (const plugin of config?.plugins ?? []) {
+        const patch = plugin.transformToken?.(innerToken, { config });
+        if (!patch) continue;
+        mergePatch(
+          patch,
+          gestures,
+          transition,
+          viewport,
+          dragConfig,
+          layoutConfig,
+          scroll,
+          variants,
+          variantState
+        );
+        consumed = true;
+        break;
+      }
+    }
+    if (!consumed) {
+      if (innerToken.startsWith("animate-") && !TAILWIND_ANIMATE_CLASSES.has(innerToken)) {
+        diagnostics.push({
+          code: "unknown-class",
+          message: `Unrecognized motionwind class "${innerToken}".`,
+          severity: config?.strict ? "error" : "warning",
+          token: innerToken
+        });
+      }
+      if (process.env.NODE_ENV !== "production" && innerToken.startsWith("animate-") && !TAILWIND_ANIMATE_CLASSES.has(innerToken)) {
+        console.warn(
+          `[motionwind] Unrecognized class "${innerToken}". It starts with "animate-" but doesn't match any known pattern.`
+        );
+      }
+      tailwind.push(innerToken);
+    }
+  }
+  const hasMotion = Object.keys(gestures).length > 0 || Object.keys(transition).length > 0 || Object.keys(viewport).length > 0 || Object.keys(dragConfig).length > 0 || Object.keys(layoutConfig).length > 0 || Object.keys(scroll.values).length > 0 || Object.keys(variants).length > 0 || Object.keys(variantState).length > 0;
+  const result = {
+    tailwindClasses: tailwind.join(" "),
+    gestures,
+    transition,
+    viewport,
+    dragConfig,
+    layoutConfig,
+    scroll,
+    variants,
+    variantState,
+    hasMotion,
+    ...reducedMotionPolicy !== void 0 && { reducedMotionPolicy },
+    diagnostics
+  };
+  for (const plugin of config?.plugins ?? []) {
+    const pluginDiagnostics = plugin.diagnose?.(className, result, { config }) ?? [];
+    diagnostics.push(
+      ...pluginDiagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        plugin: plugin.name
+      }))
+    );
+  }
+  if (!config) cacheSet(className, result);
+  return result;
+}
+function clearParserCache() {
+  cache.clear();
+}
+function freshAccumulators() {
+  return {
+    gestures: {},
+    transition: {},
+    viewport: {},
+    dragConfig: {},
+    layoutConfig: {},
+    scroll: { axis: "y", container: false, values: {} },
+    variants: {},
+    variantState: {}
+  };
+}
+function classifyMotionToken(token, config) {
+  if (token.startsWith("motion-reduce:") || token.startsWith("motion-safe:")) {
+    const inner = token.startsWith("motion-reduce:") ? token.slice("motion-reduce:".length) : token.slice("motion-safe:".length);
+    return inner ? classifyMotionToken(inner, config) : "tailwind";
+  }
+  if (!token.startsWith("animate-")) return "tailwind";
+  if (TAILWIND_ANIMATE_CLASSES.has(token)) return "tailwind";
+  if (config || token.startsWith("animate-preset-")) {
+    const parsed = parseMotionClasses(token, config);
+    if (!parsed.hasMotion) return "unknown";
+    if (Object.keys(parsed.variantState).length || Object.keys(parsed.variants).length)
+      return "variant";
+    if (Object.keys(parsed.gestures).length) return "gesture";
+    if (Object.keys(parsed.viewport).length) return "viewport";
+    if (Object.keys(parsed.scroll.values).length) return "scroll";
+    if (Object.keys(parsed.dragConfig).length) return "drag";
+    if (Object.keys(parsed.layoutConfig).length) return "layout";
+    return "transition";
+  }
+  const a = freshAccumulators();
+  const consumed = classifyToken(
+    token,
+    a.gestures,
+    a.transition,
+    a.viewport,
+    a.dragConfig,
+    a.layoutConfig,
+    a.scroll,
+    a.variants,
+    a.variantState
+  );
+  if (!consumed) return "unknown";
+  if (token.startsWith("animate-scroll")) return "scroll";
+  if (token.startsWith("animate-variant-")) return "variant";
+  if (Object.keys(a.variantState).length) return "variant";
+  if (Object.keys(a.gestures).length) return "gesture";
+  if (Object.keys(a.viewport).length) return "viewport";
+  if (Object.keys(a.dragConfig).length) return "drag";
+  if (Object.keys(a.layoutConfig).length) return "layout";
+  return "transition";
+}
+
+export { classifyMotionToken, clearParserCache, parseMotionClasses };
+//# sourceMappingURL=chunk-A7EAMXLY.js.map
+//# sourceMappingURL=chunk-A7EAMXLY.js.map