motionwind-core 2.1.0

package/dist/parser.cjs

@@ -0,0 +1,1690 @@
+'use strict';
+
+// src/registry.ts
+var ALL = ["react", "vue", "vanilla", "react-native"];
+var WEB = ["react", "vue", "vanilla"];
+var gesture = (id, motionKey, description) => ({
+  id: `gesture.${id}`,
+  category: "gesture",
+  label: `animate-${id}:`,
+  snippet: `animate-${id}:`,
+  description,
+  motionKey,
+  platforms: ALL
+});
+var GESTURE_DEFINITIONS = [
+  gesture("hover", "whileHover", "Animate while an element is hovered."),
+  gesture("tap", "whileTap", "Animate while an element is pressed."),
+  gesture("focus", "whileFocus", "Animate while an element has focus."),
+  gesture("inview", "whileInView", "Animate while an element is in view."),
+  gesture("drag", "whileDrag", "Animate while an element is dragged."),
+  gesture("initial", "initial", "Set the state before an animation begins."),
+  gesture("enter", "animate", "Animate to a state when an element enters."),
+  gesture("exit", "exit", "Animate to a state when an element exits.")
+];
+var property = (label, snippet, motionKey, description, platforms = ALL) => ({
+  id: `property.${label.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "")}`,
+  category: "property",
+  label,
+  snippet,
+  motionKey,
+  description,
+  platforms
+});
+[
+  property(
+    "scale-",
+    "scale-${1:110}",
+    "scale",
+    "Scale (100 is the resting value)."
+  ),
+  property("scale-x-", "scale-x-${1:110}", "scaleX", "Scale on the x axis."),
+  property("scale-y-", "scale-y-${1:110}", "scaleY", "Scale on the y axis."),
+  property(
+    "scale-z-",
+    "scale-z-${1:110}",
+    "scaleZ",
+    "Scale on the z axis.",
+    WEB
+  ),
+  property("rotate-", "rotate-${1:45}", "rotate", "Rotate in degrees."),
+  property(
+    "rotate-x-",
+    "rotate-x-${1:45}",
+    "rotateX",
+    "Rotate around the x axis."
+  ),
+  property(
+    "rotate-y-",
+    "rotate-y-${1:45}",
+    "rotateY",
+    "Rotate around the y axis."
+  ),
+  property("x-", "x-${1:20}", "x", "Translate on the x axis."),
+  property("y-", "y-${1:20}", "y", "Translate on the y axis."),
+  property("z-", "z-${1:20}", "z", "Translate on the z axis.", WEB),
+  // z-{0,10,20,30,40,50,auto} maps to zIndex (Tailwind-standard values)
+  {
+    id: "property.z-zIndex",
+    category: "property",
+    label: "z-",
+    snippet: "z-${1|0,10,20,30,40,50,auto|}",
+    motionKey: "zIndex",
+    description: "Animate z-index (Tailwind values: 0, 10, 20, 30, 40, 50, auto). Non-standard values translate on the z axis instead.",
+    platforms: WEB
+  },
+  property("skew-x-", "skew-x-${1:12}", "skewX", "Skew on the x axis."),
+  property("skew-y-", "skew-y-${1:12}", "skewY", "Skew on the y axis."),
+  property(
+    "origin-x-",
+    "origin-x-${1:50}",
+    "originX",
+    "Set the x transform origin.",
+    WEB
+  ),
+  property(
+    "origin-y-",
+    "origin-y-${1:50}",
+    "originY",
+    "Set the y transform origin.",
+    WEB
+  ),
+  property(
+    "perspective-",
+    "perspective-${1:800}",
+    "perspective",
+    "Set 3D perspective.",
+    WEB
+  ),
+  property("opacity-", "opacity-${1:0}", "opacity", "Animate opacity (0\u2013100)."),
+  property("blur-", "blur-${1:10}", "filter", "Animate CSS blur.", WEB),
+  property(
+    "brightness-",
+    "brightness-${1:120}",
+    "filter",
+    "Animate CSS brightness.",
+    WEB
+  ),
+  property(
+    "contrast-",
+    "contrast-${1:120}",
+    "filter",
+    "Animate CSS contrast.",
+    WEB
+  ),
+  property(
+    "saturate-",
+    "saturate-${1:120}",
+    "filter",
+    "Animate CSS saturation.",
+    WEB
+  ),
+  property(
+    "grayscale-",
+    "grayscale-${1:100}",
+    "filter",
+    "Animate CSS grayscale.",
+    WEB
+  ),
+  property(
+    "backdrop-blur-",
+    "backdrop-blur-${1:10}",
+    "backdropFilter",
+    "Animate backdrop blur.",
+    WEB
+  ),
+  property("w-", "w-${1:100}", "width", "Animate width."),
+  property("h-", "h-${1:100}", "height", "Animate height."),
+  property(
+    "rounded-",
+    "rounded-${1:12}",
+    "borderRadius",
+    "Animate border radius."
+  ),
+  property(
+    "rounded-tl-",
+    "rounded-tl-${1:12}",
+    "borderTopLeftRadius",
+    "Animate top-left border radius."
+  ),
+  property(
+    "rounded-tr-",
+    "rounded-tr-${1:12}",
+    "borderTopRightRadius",
+    "Animate top-right border radius."
+  ),
+  property(
+    "rounded-bl-",
+    "rounded-bl-${1:12}",
+    "borderBottomLeftRadius",
+    "Animate bottom-left border radius."
+  ),
+  property(
+    "rounded-br-",
+    "rounded-br-${1:12}",
+    "borderBottomRightRadius",
+    "Animate bottom-right border radius."
+  ),
+  property("top-", "top-${1:0}", "top", "Animate top position."),
+  property("left-", "left-${1:0}", "left", "Animate left position."),
+  property("right-", "right-${1:0}", "right", "Animate right position."),
+  property("bottom-", "bottom-${1:0}", "bottom", "Animate bottom position."),
+  property("p-", "p-${1:16}", "padding", "Animate padding."),
+  property("m-", "m-${1:16}", "margin", "Animate margin."),
+  property("gap-", "gap-${1:8}", "gap", "Animate gap."),
+  property("text-size-", "text-size-${1:16}", "fontSize", "Animate font size."),
+  property(
+    "tracking-",
+    "tracking-${1:1}",
+    "letterSpacing",
+    "Animate letter spacing."
+  ),
+  property("leading-", "leading-${1:24}", "lineHeight", "Animate line height."),
+  property(
+    "border-w-",
+    "border-w-${1:2}",
+    "borderWidth",
+    "Animate border width."
+  ),
+  property(
+    "bg-#",
+    "bg-#${1:c8ff2e}",
+    "backgroundColor",
+    "Animate background color."
+  ),
+  property("text-#", "text-#${1:ffffff}", "color", "Animate text color."),
+  property(
+    "border-#",
+    "border-#${1:c8ff2e}",
+    "borderColor",
+    "Animate border color."
+  ),
+  property(
+    "path-length-",
+    "path-length-${1:1}",
+    "pathLength",
+    "Animate SVG path length.",
+    WEB
+  ),
+  property(
+    "text-shadow-[",
+    "text-shadow-[${1:value}]",
+    "textShadow",
+    "Animate text shadow (arbitrary value; underscores become spaces).",
+    WEB
+  ),
+  property(
+    "[=]",
+    "[${1:property}=${2:value}]",
+    "arbitrary",
+    "Animate an allow-listed arbitrary value.",
+    WEB
+  )
+];
+var GESTURE_MAP = Object.fromEntries(
+  GESTURE_DEFINITIONS.map((definition) => [
+    definition.label.slice("animate-".length, -1),
+    definition.motionKey
+  ])
+);
+var GESTURE_KEYS = new Set(Object.keys(GESTURE_MAP));
+var EASING_MAP = {
+  "ease-in": "easeIn",
+  "ease-out": "easeOut",
+  "ease-in-out": "easeInOut",
+  "ease-linear": "linear",
+  "ease-circ-in": "circIn",
+  "ease-circ-out": "circOut",
+  "ease-circ-in-out": "circInOut",
+  "ease-back-in": "backIn",
+  "ease-back-out": "backOut",
+  "ease-back-in-out": "backInOut",
+  "ease-anticipate": "anticipate"
+};
+
+// src/config.ts
+function definePreset(preset) {
+  return preset;
+}
+
+// src/recipes.ts
+var COMMUNITY_METADATA = {
+  maintainer: "motionwind/core",
+  version: "1.0.0",
+  compatibleCore: ">=2.0.0 <3",
+  bundleImpact: "Preset only; no runtime code added."
+};
+var source = (id) => `https://github.com/piyushzingade/motionwind/tree/main/registry/recipes/${id}.json`;
+var MOTIONWIND_RECIPES = [
+  {
+    id: "button-press",
+    name: "Button press",
+    description: "A compact spring response for primary actions.",
+    category: "interaction",
+    classes: "animate-hover:scale-105 animate-tap:scale-95 animate-spring animate-stiffness-420 animate-damping-24",
+    accessibility: "Preserves keyboard focus and does not communicate state through motion alone.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("button-press")
+  },
+  {
+    id: "dialog-enter",
+    name: "Dialog entrance",
+    description: "Fade and lift a dialog into place without excessive travel.",
+    category: "entrance",
+    classes: "animate-initial:opacity-0 animate-initial:y-12 animate-enter:opacity-100 animate-enter:y-0 animate-duration-240 animate-ease-out",
+    accessibility: "Pair with a focus trap and disable transform movement for reduced-motion users.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("dialog-enter")
+  },
+  {
+    id: "list-stagger",
+    name: "List stagger",
+    description: "A restrained stagger for newly revealed collections.",
+    category: "entrance",
+    classes: "animate-stagger-55 animate-delay-children-40 animate-when-before",
+    accessibility: "Keep the list readable before and after animation; avoid repeated autoplay.",
+    adapters: ["react", "vue"],
+    ...COMMUNITY_METADATA,
+    source: source("list-stagger")
+  },
+  {
+    id: "page-reveal",
+    name: "Page reveal",
+    description: "A single-run opacity and vertical reveal for page sections.",
+    category: "scroll",
+    classes: "animate-initial:opacity-0 animate-initial:y-24 animate-inview:opacity-100 animate-inview:y-0 animate-once animate-duration-480 animate-ease-out",
+    accessibility: "Content remains in document order and visible when reduced motion is requested.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("page-reveal")
+  },
+  {
+    id: "loading-orbit",
+    name: "Loading orbit",
+    description: "A continuous linear rotation for non-blocking progress indicators.",
+    category: "loading",
+    classes: "animate-enter:rotate-360 animate-repeat-infinite animate-duration-900 animate-ease-linear",
+    accessibility: "Add an accessible status label and stop the loop when loading completes.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("loading-orbit")
+  },
+  {
+    id: "menu-pop",
+    name: "Menu pop",
+    description: "A fast scale-and-fade entrance for contextual menus.",
+    category: "entrance",
+    classes: "animate-initial:opacity-0 animate-initial:scale-95 animate-enter:opacity-100 animate-enter:scale-100 animate-duration-160 animate-ease-out",
+    accessibility: "Move focus into the menu, return it on close, and preserve arrow-key navigation.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("menu-pop")
+  },
+  {
+    id: "accordion-reveal",
+    name: "Accordion reveal",
+    description: "A layout-aware reveal for expandable disclosure content.",
+    category: "layout",
+    classes: "animate-layout-size animate-initial:opacity-0 animate-enter:opacity-100 animate-duration-220 animate-ease-out",
+    accessibility: "Use a native button with aria-expanded and keep content reachable without animation.",
+    adapters: ["react", "vue"],
+    ...COMMUNITY_METADATA,
+    source: source("accordion-reveal")
+  },
+  {
+    id: "tab-indicator",
+    name: "Tab indicator",
+    description: "A shared-layout spring for an active tab indicator.",
+    category: "layout",
+    classes: "animate-layout-id-active-tab animate-spring animate-stiffness-440 animate-damping-34",
+    accessibility: "Pair with tablist semantics, roving focus, and an independent selected-state cue.",
+    adapters: ["react", "vue"],
+    ...COMMUNITY_METADATA,
+    source: source("tab-indicator")
+  },
+  {
+    id: "toast-enter",
+    name: "Toast entrance",
+    description: "A short horizontal slide for non-blocking notifications.",
+    category: "entrance",
+    classes: "animate-initial:opacity-0 animate-initial:x-24 animate-enter:opacity-100 animate-enter:x-0 animate-duration-240 animate-ease-out",
+    accessibility: "Use an appropriate live region and provide enough time to read or dismiss the toast.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("toast-enter")
+  },
+  {
+    id: "sortable-item",
+    name: "Sortable item",
+    description: "Layout animation and vertical drag feedback for reorderable lists.",
+    category: "interaction",
+    classes: "animate-layout-position animate-drag-y animate-drag-snap animate-drag:scale-103 animate-spring animate-stiffness-360 animate-damping-28",
+    accessibility: "Provide keyboard reordering controls and announce the new item position.",
+    adapters: ["react", "vue"],
+    ...COMMUNITY_METADATA,
+    source: source("sortable-item")
+  },
+  {
+    id: "svg-line-loader",
+    name: "SVG line loader",
+    description: "Draw and repeat an SVG path for compact progress feedback.",
+    category: "loading",
+    classes: "animate-initial:path-length-0 animate-enter:path-length-1 animate-duration-900 animate-ease-in-out animate-repeat-infinite animate-repeat-reverse",
+    accessibility: "Give the SVG a status label and stop repeating when the operation completes.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("svg-line-loader")
+  },
+  {
+    id: "scroll-progress",
+    name: "Scroll progress",
+    description: "Map page scroll progress to a horizontal scale indicator.",
+    category: "scroll",
+    classes: "animate-scroll:scaleX-[0,1] animate-scroll-container",
+    accessibility: "Treat the indicator as supplemental; expose document progress in text when it matters.",
+    adapters: ["react", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("scroll-progress")
+  },
+  {
+    id: "flip-card",
+    name: "Flip card",
+    description: "A 3-D card that rotates 180 degrees around the Y axis on hover.",
+    category: "interaction",
+    classes: "animate-hover:rotate-y-180 animate-duration-480 animate-ease-in-out",
+    accessibility: "Pair with a separate back face and keep both sides keyboard-accessible.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("flip-card")
+  },
+  {
+    id: "marquee",
+    name: "Marquee",
+    description: "A continuously looping horizontal scroll for text or image strips.",
+    category: "entrance",
+    classes: "animate-initial:x-100pct animate-enter:-x-100pct animate-repeat-infinite animate-ease-linear animate-duration-4000",
+    accessibility: "Pause the marquee on focus or hover; do not convey critical information through motion alone.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("marquee")
+  },
+  {
+    id: "magnetic-button",
+    name: "Magnetic button",
+    description: "A subtle spring scale that draws attention on hover without moving the element.",
+    category: "interaction",
+    classes: "animate-hover:scale-103 animate-spring animate-stiffness-280 animate-damping-22",
+    accessibility: "Do not use scale change as the only indicator of an interactive element.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("magnetic-button")
+  },
+  {
+    id: "drawer",
+    name: "Drawer",
+    description: "A side panel that slides in from the edge and returns on exit.",
+    category: "entrance",
+    classes: "animate-initial:x-100pct animate-enter:x-0 animate-exit:x-100pct animate-duration-320 animate-ease-out",
+    accessibility: "Trap focus inside the drawer, return focus on close, and support Escape to dismiss.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("drawer")
+  },
+  {
+    id: "tooltip-pop",
+    name: "Tooltip pop",
+    description: "A small scale-and-fade entrance for contextual tooltips.",
+    category: "entrance",
+    classes: "animate-initial:opacity-0 animate-initial:scale-75 animate-enter:opacity-100 animate-enter:scale-100 animate-duration-160 animate-ease-back-out",
+    accessibility: "Use role='tooltip', aria-describedby, and ensure the tooltip is dismissible without a mouse.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("tooltip-pop")
+  },
+  {
+    id: "skeleton-pulse",
+    name: "Skeleton pulse",
+    description: "A pulsing opacity loop for placeholder content while data loads.",
+    category: "loading",
+    classes: "animate-initial:opacity-100 animate-enter:opacity-40 animate-repeat-infinite animate-repeat-reverse animate-duration-800 animate-ease-in-out",
+    accessibility: "Announce loading state with aria-busy; remove skeleton when content arrives.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("skeleton-pulse")
+  },
+  {
+    id: "shimmer-load",
+    name: "Shimmer load",
+    description: "A left-to-right gradient shimmer applied to a loading overlay.",
+    category: "loading",
+    classes: "animate-initial:-x-100pct animate-enter:x-100pct animate-repeat-infinite animate-duration-1200 animate-ease-in-out",
+    accessibility: "Place the shimmer on a decorative overlay; expose loading status through accessible text.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("shimmer-load")
+  },
+  {
+    id: "card-hover",
+    name: "Card hover",
+    description: "A spring lift and upward nudge for interactive cards on hover.",
+    category: "interaction",
+    classes: "animate-hover:scale-103 animate-hover:y--4 animate-spring animate-stiffness-380 animate-damping-26",
+    accessibility: "Ensure focus styles are visible and the hover state is not the only interactive cue.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("card-hover")
+  },
+  {
+    id: "number-counter",
+    name: "Number counter",
+    description: "A fade and rise entrance for statistic values triggered when they scroll into view.",
+    category: "scroll",
+    classes: "animate-initial:opacity-0 animate-initial:y-12 animate-inview:opacity-100 animate-inview:y-0 animate-once animate-duration-400 animate-ease-out",
+    accessibility: "Present the final value in document order and avoid conveying meaning through counting motion.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("number-counter")
+  },
+  {
+    id: "progress-bar",
+    name: "Progress bar",
+    description: "An animated width fill for a progress bar triggered on scroll into view.",
+    category: "scroll",
+    classes: "animate-initial:w-0 animate-inview:w-100pct animate-once animate-duration-800 animate-ease-out",
+    accessibility: "Use a native progress element or role='progressbar' with aria-valuenow to expose state.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("progress-bar")
+  },
+  {
+    id: "ripple",
+    name: "Ripple",
+    description: "A radial scale-and-fade burst that emanates from a tap point.",
+    category: "interaction",
+    classes: "animate-initial:scale-0 animate-initial:opacity-100 animate-enter:scale-400 animate-enter:opacity-0 animate-duration-500 animate-ease-out",
+    accessibility: "Use the ripple as a purely decorative effect and do not rely on it to communicate state.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("ripple")
+  },
+  {
+    id: "blob-morph",
+    name: "Blob morph",
+    description: "An organic border-radius keyframe loop for fluid decorative shapes.",
+    category: "loading",
+    classes: "animate-enter:rounded-[0,30,60,30,0] animate-repeat-infinite animate-duration-3000 animate-ease-in-out animate-repeat-reverse",
+    accessibility: "Use only for decorative elements; apply aria-hidden to prevent interference with screen readers.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("blob-morph")
+  },
+  {
+    id: "ticker",
+    name: "Ticker",
+    description: "A stock- or news-style ticker where items enter from the right and exit to the left.",
+    category: "entrance",
+    classes: "animate-initial:x-100pct animate-enter:x-0 animate-exit:-x-100pct animate-duration-500 animate-ease-out animate-stagger-150",
+    accessibility: "Provide a way to pause the ticker and make all content available in a static list.",
+    adapters: ["react", "vue", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("ticker")
+  },
+  {
+    id: "popover-reveal",
+    name: "Popover reveal",
+    description: "A short downward fade-in for anchored popovers and dropdowns.",
+    category: "entrance",
+    classes: "animate-initial:opacity-0 animate-initial:y--8 animate-enter:opacity-100 animate-enter:y-0 animate-duration-180 animate-ease-out",
+    accessibility: "Move focus into the popover on open and return it to the trigger on close.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("popover-reveal")
+  },
+  {
+    id: "stepper",
+    name: "Stepper",
+    description: "Sequential staggered entrances for step-indicator items.",
+    category: "entrance",
+    classes: "animate-initial:opacity-0 animate-initial:scale-80 animate-enter:opacity-100 animate-enter:scale-100 animate-stagger-80 animate-delay-children-100 animate-duration-200 animate-ease-back-out",
+    accessibility: "Announce the current step and total steps; keep step content readable without animation.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("stepper")
+  },
+  {
+    id: "notification-stack",
+    name: "Notification stack",
+    description: "Staggered upward entrances for stacked notification cards.",
+    category: "entrance",
+    classes: "animate-initial:opacity-0 animate-initial:y--20 animate-enter:opacity-100 animate-enter:y-0 animate-stagger-80 animate-duration-260 animate-ease-back-out",
+    accessibility: "Use a live region with aria-live='polite' and provide enough time to read each notification.",
+    adapters: ["react", "vue", "vanilla", "react-native"],
+    ...COMMUNITY_METADATA,
+    source: source("notification-stack")
+  },
+  {
+    id: "drag-reorder",
+    name: "Drag reorder",
+    description: "Vertical drag with layout animation for reorderable list items.",
+    category: "interaction",
+    classes: "animate-drag-y animate-layout-position animate-drag:scale-102 animate-spring animate-stiffness-320 animate-damping-30",
+    accessibility: "Provide keyboard controls for reordering and announce the new position after a drop.",
+    adapters: ["react", "vue"],
+    ...COMMUNITY_METADATA,
+    source: source("drag-reorder")
+  },
+  {
+    id: "parallax-scroll",
+    name: "Parallax scroll",
+    description: "Map scroll progress to a Y translation so a layer moves at a different speed.",
+    category: "scroll",
+    classes: "animate-scroll:y-[-50,50] animate-scroll-container",
+    accessibility: "Respect prefers-reduced-motion; parallax depth cues must not convey meaning exclusively.",
+    adapters: ["react", "vanilla"],
+    ...COMMUNITY_METADATA,
+    source: source("parallax-scroll")
+  }
+];
+var BUILT_IN_PRESETS = Object.fromEntries(
+  MOTIONWIND_RECIPES.map((recipe) => [recipe.id, definePreset(recipe.classes)])
+);
+
+// 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(config2) {
+  const pluginPresets = Object.assign(
+    {},
+    ...(config2?.plugins ?? []).map((plugin) => plugin.presets ?? {})
+  );
+  return { ...BUILT_IN_PRESETS, ...pluginPresets, ...config2?.presets ?? {} };
+}
+function expandConfiguredTokens(className, config2, diagnostics) {
+  const presets = availablePresets(config2);
+  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 ? config2?.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 ? config2?.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 ? config2?.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: config2?.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, config2) {
+  const cached = config2 ? void 0 : cache.get(className);
+  if (cached) return cached;
+  const diagnostics = [];
+  const tokens = expandConfiguredTokens(className, config2, 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 ? config2?.tokens?.easings?.[easingName] : void 0;
+      if (typeof easing === "string") {
+        transition.ease = easing;
+        consumed = true;
+      }
+    }
+    if (!consumed) {
+      for (const plugin of config2?.plugins ?? []) {
+        const patch = plugin.transformToken?.(innerToken, { config: config2 });
+        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: config2?.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 config2?.plugins ?? []) {
+    const pluginDiagnostics = plugin.diagnose?.(className, result, { config: config2 }) ?? [];
+    diagnostics.push(
+      ...pluginDiagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        plugin: plugin.name
+      }))
+    );
+  }
+  if (!config2) 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, config2) {
+  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, config2) : "tailwind";
+  }
+  if (!token.startsWith("animate-")) return "tailwind";
+  if (TAILWIND_ANIMATE_CLASSES.has(token)) return "tailwind";
+  if (config2 || token.startsWith("animate-preset-")) {
+    const parsed = parseMotionClasses(token, config2);
+    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";
+}
+
+exports.classifyMotionToken = classifyMotionToken;
+exports.clearParserCache = clearParserCache;
+exports.parseMotionClasses = parseMotionClasses;
+//# sourceMappingURL=parser.cjs.map
+//# sourceMappingURL=parser.cjs.map