@syncedco/motion 0.1.0

package/dist/chunk-JET2MYEG.js

@@ -0,0 +1,2287 @@
+// src/core/state.js
+function setActiveState(elements, activeIndex, options = {}) {
+  const { attribute = "data-active", ariaCurrent = false } = options;
+  elements.forEach((element, index) => {
+    const active = index === activeIndex;
+    element.toggleAttribute(attribute, active);
+    if (ariaCurrent) {
+      if (active) element.setAttribute("aria-current", "true");
+      else element.removeAttribute("aria-current");
+    }
+  });
+}
+function getFocusable(container) {
+  return [...container.querySelectorAll(
+    'a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])'
+  )].filter((element) => !element.hidden && element.getAttribute("aria-hidden") !== "true");
+}
+
+// src/patterns/expand-panels.js
+function createExpandPanels({ root }) {
+  return [...root.querySelectorAll("[data-motion-expand-group]")].map((group) => {
+    const panels = [...group.querySelectorAll("[data-motion-expand-panel]")];
+    const requestedDefault = Number.parseInt(group.dataset.motionExpandDefault || "0", 10);
+    const defaultIndex = Math.min(panels.length - 1, Math.max(0, requestedDefault));
+    const cleanups = [];
+    const activate = (index) => {
+      setActiveState(panels, index);
+      group.style.setProperty("--motion-panel", String(index));
+      group.dispatchEvent(new CustomEvent("sfmotion:panel", { detail: { index } }));
+    };
+    panels.forEach((panel, index) => {
+      const enter = () => activate(index);
+      panel.addEventListener("pointerenter", enter);
+      panel.addEventListener("focusin", enter);
+      cleanups.push(() => {
+        panel.removeEventListener("pointerenter", enter);
+        panel.removeEventListener("focusin", enter);
+      });
+    });
+    activate(defaultIndex);
+    return () => cleanups.forEach((cleanup) => cleanup());
+  });
+}
+
+// src/core/options.js
+var defaults = Object.freeze({
+  debug: false,
+  smoothScroll: false,
+  revealStart: "top 84%",
+  reducedMotionQuery: "(prefers-reduced-motion: reduce)"
+});
+function mergeOptions(options = {}) {
+  return { ...defaults, ...options };
+}
+function numberAttribute(element, name, fallback) {
+  const value = Number.parseFloat(element.getAttribute(name) ?? "");
+  return Number.isFinite(value) ? value : fallback;
+}
+function clampIndex(progress, length) {
+  if (length <= 0) return -1;
+  const bounded = Math.min(1, Math.max(0, progress));
+  return Math.min(length - 1, Math.floor(bounded * length));
+}
+
+// src/patterns/founder-scene.js
+function createFounderScenes({ gsap, ScrollTrigger, SplitText, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-founder-scene]")].map((scene) => {
+    const content = scene.querySelector("[data-motion-founder-content]");
+    const heading = scene.querySelector("[data-motion-founder-heading]");
+    const statementBackground = scene.querySelector("[data-motion-founder-statement-bg]");
+    const metricsBackground = scene.querySelector("[data-motion-founder-metrics-bg]");
+    const metrics = scene.querySelector("[data-motion-founder-metrics]");
+    const stat = scene.querySelector("[data-motion-founder-stat]");
+    const statLabel = scene.querySelector("[data-motion-founder-stat-label]");
+    const details = [...scene.querySelectorAll("[data-motion-founder-detail]")];
+    if (!content || !heading || !statementBackground || !metricsBackground || !metrics || !stat || !statLabel) return null;
+    const split = new SplitText(heading, { type: "words", aria: "auto" });
+    const wordStagger = split.words.length > 1 ? 0.2 / (split.words.length - 1) : 0;
+    gsap.set(content, { autoAlpha: 0 });
+    gsap.set(split.words, { autoAlpha: 0, yPercent: 100 });
+    gsap.set(metricsBackground, { scale: 1.2 });
+    gsap.set(metrics, { autoAlpha: 0 });
+    gsap.set(stat, { autoAlpha: 0, scale: 0.5 });
+    gsap.set(statLabel, { autoAlpha: 0, scale: 0.8, yPercent: 100 });
+    gsap.set(details, { autoAlpha: 0, yPercent: 30 });
+    const timeline = gsap.timeline({
+      scrollTrigger: {
+        trigger: scene,
+        start: "clamp(top top)",
+        end: "clamp(bottom bottom)",
+        scrub: numberAttribute(scene, "data-motion-scrub", 0.8),
+        markers: debug
+      }
+    });
+    timeline.to(metricsBackground, { scale: 1, autoAlpha: 1, duration: 1.96, ease: "none" }, 0.09).to(content, { autoAlpha: 1, duration: 0.17, ease: "power2.in" }, 0.25).to(split.words, { autoAlpha: 1, yPercent: 0, duration: 0.16, ease: "none", stagger: wordStagger }, 0.25).to(content, { autoAlpha: 0, yPercent: 5, duration: 0.17, ease: "power2.in" }, 0.59).to(statementBackground, { autoAlpha: 0, duration: 1.2, ease: "none" }, 0.76).to(metrics, { autoAlpha: 1, duration: 0.1, ease: "none" }, 0.89).to(stat, { autoAlpha: 1, scale: 1, duration: 0.21, ease: "none" }, 0.89).to(statLabel, { autoAlpha: 1, scale: 1, yPercent: 0, duration: 0.21, ease: "none" }, 1.02).to(details, { autoAlpha: 1, yPercent: 0, duration: 0.5, ease: "none", stagger: 0.1 }, 1.1);
+    return () => {
+      timeline.scrollTrigger?.kill();
+      timeline.revert?.();
+      timeline.kill();
+      gsap.set([content, ...split.words, statementBackground, metricsBackground, metrics, stat, statLabel, ...details], {
+        clearProps: "transform,opacity,visibility"
+      });
+      split.revert();
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/hover-media.js
+function createHoverMedia({ root }) {
+  return [...root.querySelectorAll("[data-motion-hover-group]")].map((group) => {
+    const triggers = [...group.querySelectorAll("[data-motion-hover-key]")];
+    const media = [...group.querySelectorAll("[data-motion-hover-media]")];
+    const cleanups = [];
+    const activate = (key) => {
+      setActiveState(triggers, triggers.findIndex((item) => item.dataset.motionHoverKey === key));
+      setActiveState(media, media.findIndex((item) => item.dataset.motionHoverMedia === key));
+    };
+    triggers.forEach((trigger2) => {
+      const enter = () => activate(trigger2.dataset.motionHoverKey);
+      trigger2.addEventListener("pointerenter", enter);
+      trigger2.addEventListener("focus", enter);
+      cleanups.push(() => {
+        trigger2.removeEventListener("pointerenter", enter);
+        trigger2.removeEventListener("focus", enter);
+      });
+    });
+    if (triggers[0]) activate(triggers[0].dataset.motionHoverKey);
+    return () => cleanups.forEach((cleanup) => cleanup());
+  });
+}
+
+// src/patterns/hover-pointer.js
+function clearTween(gsap, target) {
+  gsap.set(target, { clearProps: "transform,opacity,visibility" });
+}
+function createHoverLifts({ gsap, root, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-hover-lift]")].map((item) => {
+    const enter = () => gsap.to(item, { y: "-0.5rem", scale: 1.01, duration: 0.25, ease: "power2.out", overwrite: "auto" });
+    const leave = () => gsap.to(item, { y: 0, scale: 1, duration: 0.3, ease: "power2.out", overwrite: "auto" });
+    item.addEventListener("pointerenter", enter);
+    item.addEventListener("pointerleave", leave);
+    item.addEventListener("focusin", enter);
+    item.addEventListener("focusout", leave);
+    return () => {
+      item.removeEventListener("pointerenter", enter);
+      item.removeEventListener("pointerleave", leave);
+      item.removeEventListener("focusin", enter);
+      item.removeEventListener("focusout", leave);
+      clearTween(gsap, item);
+    };
+  });
+}
+function createMagneticActions({ gsap, root, reduced }) {
+  const view = root.nodeType === 9 ? root.defaultView : root.ownerDocument?.defaultView;
+  if (reduced || !view?.matchMedia?.("(pointer: fine)").matches) return [];
+  return [...root.querySelectorAll("[data-motion-magnetic]")].map((scene) => {
+    const action = scene.querySelector("[data-motion-magnetic-action]") ?? scene;
+    const xTo = gsap.quickTo(action, "x", { duration: 0.35, ease: "power3.out" });
+    const yTo = gsap.quickTo(action, "y", { duration: 0.35, ease: "power3.out" });
+    const move = (event) => {
+      const rect = scene.getBoundingClientRect();
+      const strength = Number(scene.getAttribute("data-motion-magnetic-strength") || 0.2);
+      xTo((event.clientX - rect.left - rect.width / 2) * strength);
+      yTo((event.clientY - rect.top - rect.height / 2) * strength);
+    };
+    const reset = () => {
+      xTo(0);
+      yTo(0);
+    };
+    scene.addEventListener("pointermove", move);
+    scene.addEventListener("pointerleave", reset);
+    return () => {
+      scene.removeEventListener("pointermove", move);
+      scene.removeEventListener("pointerleave", reset);
+      xTo.tween?.kill?.();
+      yTo.tween?.kill?.();
+      clearTween(gsap, action);
+    };
+  });
+}
+function createPointerSpotlights({ gsap, root, reduced }) {
+  const view = root.nodeType === 9 ? root.defaultView : root.ownerDocument?.defaultView;
+  if (reduced || !view?.matchMedia?.("(pointer: fine)").matches) return [];
+  return [...root.querySelectorAll("[data-motion-pointer-spotlight]")].map((scene) => {
+    const spotlight = scene.querySelector("[data-motion-spotlight]");
+    if (!spotlight) return void 0;
+    const xTo = gsap.quickTo(spotlight, "x", { duration: 0.2, ease: "power2.out" });
+    const yTo = gsap.quickTo(spotlight, "y", { duration: 0.2, ease: "power2.out" });
+    const move = (event) => {
+      const rect = scene.getBoundingClientRect();
+      xTo(event.clientX - rect.left);
+      yTo(event.clientY - rect.top);
+    };
+    scene.addEventListener("pointermove", move);
+    return () => {
+      scene.removeEventListener("pointermove", move);
+      xTo.tween?.kill?.();
+      yTo.tween?.kill?.();
+      clearTween(gsap, spotlight);
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/horizontal.js
+function distance(track, viewport) {
+  return Math.max(0, track.scrollWidth - viewport.clientWidth);
+}
+function horizontalTween({ gsap, scene, track, viewport, pin, debug, snap, onUpdate }) {
+  return gsap.to(track, {
+    x: () => -distance(track, viewport),
+    ease: "none",
+    scrollTrigger: {
+      trigger: scene,
+      start: "top top",
+      end: () => `+=${Math.max(1, distance(track, viewport))}`,
+      pin,
+      scrub: 1,
+      invalidateOnRefresh: true,
+      markers: debug,
+      onUpdate,
+      ...snap ? { snap } : {}
+    }
+  });
+}
+function createHorizontalGalleries({ gsap, root, debug, reduced, selector, withSnap = false }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll(selector)].map((scene) => {
+    const viewport = scene.querySelector("[data-motion-horizontal-viewport]") ?? scene;
+    const pin = scene.querySelector("[data-motion-horizontal-pin]") ?? viewport;
+    const track = scene.querySelector("[data-motion-horizontal-track]");
+    const cards = [...scene.querySelectorAll("[data-motion-horizontal-card]")];
+    if (!track || !cards.length) return void 0;
+    const snap = withSnap && cards.length > 1 ? { snapTo: 1 / (cards.length - 1), duration: 0.25, ease: "power1.inOut" } : void 0;
+    return horizontalTween({ gsap, scene, track, viewport, pin, debug, snap });
+  }).filter(Boolean);
+}
+function createHorizontalGalleryScrubs(context) {
+  return createHorizontalGalleries({ ...context, selector: "[data-motion-horizontal-gallery]" });
+}
+function createHorizontalGallerySnaps(context) {
+  return createHorizontalGalleries({ ...context, selector: "[data-motion-horizontal-snap]", withSnap: true });
+}
+function createHorizontalFeatureRails({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-horizontal-feature-rail]")].map((scene) => {
+    const viewport = scene.querySelector("[data-motion-horizontal-viewport]") ?? scene;
+    const pin = scene.querySelector("[data-motion-horizontal-pin]") ?? viewport;
+    const track = scene.querySelector("[data-motion-horizontal-track]");
+    const cards = [...scene.querySelectorAll("[data-motion-horizontal-card]")];
+    const labels = [...scene.querySelectorAll("[data-motion-horizontal-label]")];
+    if (!track || !cards.length) return void 0;
+    return horizontalTween({
+      gsap,
+      scene,
+      track,
+      viewport,
+      pin,
+      debug,
+      onUpdate(self) {
+        const index = clampIndex(self.progress, cards.length);
+        setActiveState(cards, index);
+        if (labels.length) setActiveState(labels, Math.min(index, labels.length - 1), { ariaCurrent: true });
+      }
+    });
+  }).filter(Boolean);
+}
+function createHorizontalLogoReels({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-horizontal-logo-reel]")].map((scene) => {
+    const viewport = scene.querySelector("[data-motion-horizontal-viewport]") ?? scene;
+    const track = scene.querySelector("[data-motion-horizontal-track]");
+    if (!track) return void 0;
+    return gsap.to(track, {
+      x: () => -distance(track, viewport),
+      ease: "none",
+      scrollTrigger: { trigger: scene, start: "top bottom", end: "bottom top", scrub: 1, invalidateOnRefresh: true, markers: debug }
+    });
+  }).filter(Boolean);
+}
+function createHorizontalComparisonSliders({ root }) {
+  return [...root.querySelectorAll("[data-motion-comparison]")].map((scene) => {
+    const range = scene.querySelector("[data-motion-comparison-range]");
+    const after = scene.querySelector("[data-motion-comparison-after]");
+    if (!range || !after) return void 0;
+    const previous = after.style.clipPath;
+    const update = () => {
+      const value = Math.max(0, Math.min(100, Number(range.value)));
+      after.style.clipPath = `inset(0 ${100 - value}% 0 0)`;
+      scene.setAttribute("data-motion-comparison-value", String(value));
+    };
+    range.addEventListener("input", update);
+    update();
+    return () => {
+      range.removeEventListener("input", update);
+      after.style.clipPath = previous;
+      scene.removeAttribute("data-motion-comparison-value");
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/marquee.js
+function createMarquees({ gsap, root, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-marquee]")].map((marquee2) => {
+    const track = [...marquee2.children].find((child) => child.hasAttribute("data-motion-marquee-track"));
+    if (!track) return null;
+    const direction = marquee2.getAttribute("data-motion-marquee-direction") === "right" ? 1 : -1;
+    const duration = Math.max(0.1, numberAttribute(marquee2, "data-motion-marquee-duration", 28));
+    const start = direction === 1 ? -50 : 0;
+    const end = direction === 1 ? 0 : -50;
+    const tween = gsap.fromTo(
+      track,
+      { xPercent: start },
+      {
+        xPercent: end,
+        duration,
+        ease: "none",
+        repeat: -1
+      }
+    );
+    const IntersectionObserver = marquee2.ownerDocument.defaultView?.IntersectionObserver;
+    const observer = IntersectionObserver ? new IntersectionObserver(([entry]) => tween.paused(!entry.isIntersecting)) : null;
+    observer?.observe(marquee2);
+    return () => {
+      observer?.disconnect();
+      tween.revert();
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/ambient-effects.js
+function restoreText(element, value) {
+  if (element) element.textContent = value;
+}
+function createValueCounters({ gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-counter]")].map((scene) => {
+    const output = scene.querySelector("[data-motion-counter-value]") ?? scene;
+    const original = output.textContent;
+    const from = numberAttribute(scene, "data-motion-counter-from", 0);
+    const to = numberAttribute(scene, "data-motion-counter-to", Number.parseFloat(original) || 0);
+    const decimals = Math.max(0, Math.min(6, numberAttribute(scene, "data-motion-counter-decimals", 0)));
+    const format = (value) => Number(value).toFixed(decimals);
+    if (reduced) {
+      output.textContent = format(to);
+      return () => restoreText(output, original);
+    }
+    const state = { value: from };
+    output.textContent = format(from);
+    const tween = gsap.to(state, {
+      value: to,
+      duration: Math.max(0.1, numberAttribute(scene, "data-motion-counter-duration", 1.2)),
+      ease: "power2.out",
+      onUpdate: () => {
+        output.textContent = format(state.value);
+      },
+      scrollTrigger: { trigger: scene, start: "top 85%", once: true }
+    });
+    return () => {
+      tween.scrollTrigger?.kill?.();
+      tween.revert?.();
+      tween.kill?.();
+      restoreText(output, original);
+    };
+  });
+}
+function createProgressRings({ gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-progress-ring]")].map((scene) => {
+    const ring = scene.querySelector("[data-motion-progress-ring-value]");
+    const label = scene.querySelector("[data-motion-progress-ring-label]");
+    if (!ring) return void 0;
+    const progress = Math.max(0, Math.min(100, numberAttribute(scene, "data-motion-progress", 100)));
+    const originalLabel = label?.textContent;
+    if (label) label.textContent = `${Math.round(progress)}%`;
+    const tween = reduced ? gsap.set(ring, { drawSVG: `${progress}%` }) : gsap.fromTo(ring, { drawSVG: "0%" }, {
+      drawSVG: `${progress}%`,
+      duration: Math.max(0.1, numberAttribute(scene, "data-motion-progress-duration", 1)),
+      ease: "power2.out",
+      scrollTrigger: { trigger: scene, start: "top 85%", once: true }
+    });
+    return () => {
+      tween.scrollTrigger?.kill?.();
+      tween.revert?.();
+      tween.kill?.();
+      gsap.set(ring, { clearProps: "strokeDasharray,strokeDashoffset" });
+      restoreText(label, originalLabel);
+    };
+  }).filter(Boolean);
+}
+function createAmbientFloats({ gsap, ScrollTrigger, root, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-ambient-float]")].map((element) => {
+    const tween = gsap.to(element, {
+      y: element.getAttribute("data-motion-float-distance") || "-0.75rem",
+      duration: Math.max(0.5, numberAttribute(element, "data-motion-float-duration", 3)),
+      ease: "sine.inOut",
+      repeat: -1,
+      yoyo: true,
+      paused: true
+    });
+    const trigger2 = ScrollTrigger.create({
+      trigger: element,
+      start: "top bottom",
+      end: "bottom top",
+      onEnter: () => tween.play(),
+      onEnterBack: () => tween.play(),
+      onLeave: () => tween.pause(),
+      onLeaveBack: () => tween.pause()
+    });
+    return () => {
+      trigger2.kill();
+      tween.revert?.();
+      tween.kill?.();
+    };
+  });
+}
+function createLoopingLogoBelts({ gsap, root, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-logo-belt]")].map((scene) => {
+    const track = scene.querySelector("[data-motion-logo-belt-track]");
+    if (!track) return void 0;
+    const direction = scene.getAttribute("data-motion-logo-belt-direction") === "right" ? 1 : -1;
+    const tween = gsap.fromTo(track, { xPercent: direction > 0 ? -50 : 0 }, {
+      xPercent: direction > 0 ? 0 : -50,
+      duration: Math.max(1, numberAttribute(scene, "data-motion-logo-belt-duration", 24)),
+      ease: "none",
+      repeat: -1
+    });
+    const Observer = scene.ownerDocument.defaultView?.IntersectionObserver;
+    const observer = Observer ? new Observer(([entry]) => tween.paused(!entry.isIntersecting)) : void 0;
+    observer?.observe(scene);
+    return () => {
+      observer?.disconnect();
+      tween.revert?.();
+      tween.kill?.();
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/layout-transitions.js
+function animationCleanup(animations) {
+  return () => animations.splice(0).forEach((animation) => {
+    animation?.revert?.();
+    animation?.kill?.();
+  });
+}
+function flipFrom(Flip, state, reduced, animations, options = {}) {
+  if (!reduced) animations.push(Flip.from(state, { duration: 0.55, ease: "power2.inOut", absolute: true, ...options }));
+}
+function createFlipListReorders({ Flip, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-flip-list]")].map((list) => {
+    const animations = [];
+    const onReorder = (event) => {
+      if (typeof event.detail?.mutate !== "function") return;
+      const items = [...list.querySelectorAll("[data-motion-flip-item]")];
+      const state = Flip.getState(items);
+      event.detail.mutate(list, items);
+      flipFrom(Flip, state, reduced, animations, { stagger: 0.03 });
+    };
+    list.addEventListener("motion:reorder", onReorder);
+    return () => {
+      list.removeEventListener("motion:reorder", onReorder);
+      animationCleanup(animations)();
+    };
+  });
+}
+function createFlipCardDetails({ Flip, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-flip-card]")].map((card) => {
+    const trigger2 = card.querySelector("[data-motion-flip-card-trigger]");
+    const detail = card.querySelector("[data-motion-flip-card-detail]");
+    if (!trigger2 || !detail) return void 0;
+    const animations = [];
+    const initialExpanded = card.hasAttribute("data-expanded");
+    const toggle = () => {
+      const state = Flip.getState([card, detail]);
+      const expanded = !card.hasAttribute("data-expanded");
+      card.toggleAttribute("data-expanded", expanded);
+      trigger2.setAttribute("aria-expanded", String(expanded));
+      detail.toggleAttribute("hidden", !expanded);
+      flipFrom(Flip, state, reduced, animations);
+    };
+    trigger2.addEventListener("click", toggle);
+    trigger2.setAttribute("aria-expanded", String(initialExpanded));
+    detail.toggleAttribute("hidden", !initialExpanded);
+    return () => {
+      trigger2.removeEventListener("click", toggle);
+      animationCleanup(animations)();
+      card.toggleAttribute("data-expanded", initialExpanded);
+      trigger2.setAttribute("aria-expanded", String(initialExpanded));
+      detail.toggleAttribute("hidden", !initialExpanded);
+    };
+  }).filter(Boolean);
+}
+function createFlipFilterGrids({ Flip, gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-flip-filter]")].map((scene) => {
+    const controls = [...scene.querySelectorAll("[data-motion-filter-control]")];
+    const items = [...scene.querySelectorAll("[data-motion-filter-item]")];
+    if (!controls.length || !items.length) return void 0;
+    const animations = [];
+    const apply = (control) => {
+      const value = control.getAttribute("data-motion-filter-control") || "all";
+      const state = Flip.getState(items);
+      controls.forEach((entry) => entry.setAttribute("aria-pressed", String(entry === control)));
+      items.forEach((item) => {
+        const values = (item.getAttribute("data-motion-filter-item") || "").split(/\s+/);
+        item.toggleAttribute("hidden", value !== "all" && !values.includes(value));
+      });
+      flipFrom(Flip, state, reduced, animations, {
+        onEnter: (elements) => animations.push(gsap.fromTo(elements, { opacity: 0 }, { opacity: 1, duration: 0.3 }))
+      });
+    };
+    const listeners = controls.map((control) => {
+      const handler = () => apply(control);
+      control.addEventListener("click", handler);
+      return [control, handler];
+    });
+    return () => {
+      listeners.forEach(([control, handler]) => control.removeEventListener("click", handler));
+      animationCleanup(animations)();
+      controls.forEach((control) => control.removeAttribute("aria-pressed"));
+      items.forEach((item) => item.removeAttribute("hidden"));
+    };
+  }).filter(Boolean);
+}
+function createFlipNavIndicators({ Flip, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-flip-nav]")].map((nav) => {
+    const items = [...nav.querySelectorAll("[data-motion-flip-nav-item]")];
+    const indicator = nav.querySelector("[data-motion-flip-nav-indicator]");
+    if (!items.length || !indicator) return void 0;
+    const animations = [];
+    const originalParent = indicator.parentNode;
+    const originalNext = indicator.nextSibling;
+    const activate = (item) => {
+      const state = Flip.getState(indicator);
+      item.append(indicator);
+      items.forEach((entry) => entry.toggleAttribute("data-active", entry === item));
+      flipFrom(Flip, state, reduced, animations, { absolute: false });
+    };
+    const listeners = items.map((item) => {
+      const handler = () => activate(item);
+      item.addEventListener("click", handler);
+      item.addEventListener("focus", handler);
+      return [item, handler];
+    });
+    activate(items.find((item) => item.getAttribute("aria-current") === "page") ?? items[0]);
+    return () => {
+      listeners.forEach(([item, handler]) => {
+        item.removeEventListener("click", handler);
+        item.removeEventListener("focus", handler);
+        item.removeAttribute("data-active");
+      });
+      animationCleanup(animations)();
+      originalParent?.insertBefore(indicator, originalNext);
+    };
+  }).filter(Boolean);
+}
+function createLayoutAccordionGrids({ Flip, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-layout-accordion-grid]")].map((grid) => {
+    const items = [...grid.querySelectorAll("[data-motion-layout-item]")];
+    const animations = [];
+    const listeners = items.flatMap((item) => {
+      const trigger2 = item.querySelector("[data-motion-layout-trigger]");
+      if (!trigger2) return [];
+      const handler = () => {
+        const state = Flip.getState(items);
+        const expanded = !item.hasAttribute("data-expanded");
+        items.forEach((entry) => {
+          const active = entry === item && expanded;
+          entry.toggleAttribute("data-expanded", active);
+          entry.querySelector("[data-motion-layout-trigger]")?.setAttribute("aria-expanded", String(active));
+        });
+        flipFrom(Flip, state, reduced, animations, { stagger: 0.025 });
+      };
+      trigger2.addEventListener("click", handler);
+      return [[trigger2, handler]];
+    });
+    if (!listeners.length) return void 0;
+    return () => {
+      listeners.forEach(([trigger2, handler]) => trigger2.removeEventListener("click", handler));
+      animationCleanup(animations)();
+      items.forEach((item) => {
+        item.removeAttribute("data-expanded");
+        item.querySelector("[data-motion-layout-trigger]")?.setAttribute("aria-expanded", "false");
+      });
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/media-expand.js
+function createMediaExpansions({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-media-expand]")].map((scene) => {
+    const frame = scene.querySelector("[data-motion-media-expand-frame]");
+    const image = frame?.querySelector("img");
+    const prompt = scene.querySelector("[data-motion-media-expand-prompt]");
+    const caption = scene.querySelector("[data-motion-media-expand-caption]");
+    const startLabel = scene.querySelector('[data-motion-media-expand-label="start"]');
+    const endLabel = scene.querySelector('[data-motion-media-expand-label="end"]');
+    if (!frame || !image || !prompt || !caption || !startLabel || !endLabel) return null;
+    const view = scene.ownerDocument.defaultView;
+    const expansion = { progress: 0 };
+    const syncExpansion = () => {
+      const width = view.innerWidth;
+      const height = view.innerHeight;
+      const rem = Number.parseFloat(view.getComputedStyle(scene.ownerDocument.documentElement).fontSize) || 16;
+      const gap = rem * 0.75;
+      const horizontalInset = gsap.utils.interpolate(width * 0.466, rem, expansion.progress);
+      const verticalInset = gsap.utils.interpolate(height * 0.478, rem, expansion.progress);
+      const radius = gsap.utils.interpolate(rem * 0.7, rem, expansion.progress);
+      gsap.set(frame, { clipPath: `inset(${verticalInset}px ${horizontalInset}px round ${radius}px)` });
+      gsap.set(startLabel, { right: width - horizontalInset + gap, x: 0 });
+      gsap.set(endLabel, { left: width - horizontalInset + gap, x: 0 });
+    };
+    gsap.set(frame, { y: "9svh" });
+    gsap.set(image, { scale: 1.16 });
+    gsap.set(caption, { autoAlpha: 0, y: "1.5rem" });
+    gsap.set([startLabel, endLabel], { y: "9svh" });
+    syncExpansion();
+    const timeline = gsap.timeline({
+      scrollTrigger: {
+        trigger: scene,
+        start: "clamp(top top)",
+        end: "clamp(bottom bottom)",
+        scrub: numberAttribute(scene, "data-motion-scrub", 0.8),
+        invalidateOnRefresh: true,
+        markers: debug,
+        onRefresh: syncExpansion
+      }
+    });
+    timeline.to(prompt, { autoAlpha: 0, y: "-1.5rem", duration: 0.12, ease: "none" }, 0).to([startLabel, endLabel], { y: 0, duration: 0.18, ease: "power2.out" }, 0).to(frame, { y: 0, duration: 0.18, ease: "power2.out" }, 0).to(expansion, { progress: 1, duration: 0.72, ease: "none", onUpdate: syncExpansion }, 0.12).to(image, { scale: 1, duration: 0.72, ease: "none" }, 0.12).to(caption, { autoAlpha: 1, y: 0, duration: 0.16, ease: "none" }, 0.4).to([startLabel, endLabel], { autoAlpha: 0, duration: 0.12, ease: "none" }, 0.76);
+    return () => {
+      timeline.scrollTrigger?.kill();
+      timeline.revert?.();
+      timeline.kill();
+      gsap.set([frame, image, prompt, caption, startLabel, endLabel], {
+        clearProps: "transform,opacity,visibility,clipPath,left,right"
+      });
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/media-effects.js
+function createMediaClipReveals({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-media-clip]")].map((scene) => {
+    const frame = scene.querySelector("[data-motion-media-frame]") ?? scene;
+    return gsap.from(frame, {
+      clipPath: "inset(0 100% 0 0)",
+      duration: 0.9,
+      ease: "power3.inOut",
+      clearProps: "clipPath",
+      scrollTrigger: { trigger: scene, start: "top 85%", once: true, markers: debug }
+    });
+  });
+}
+function createMediaCurtainSplits({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-media-curtain]")].map((scene) => {
+    const start = scene.querySelector("[data-motion-curtain-start]");
+    const end = scene.querySelector("[data-motion-curtain-end]");
+    if (!start || !end) return void 0;
+    const timeline = gsap.timeline({ scrollTrigger: { trigger: scene, start: "top 85%", once: true, markers: debug } });
+    timeline.to(start, { scaleX: 0, transformOrigin: "left center", duration: 0.75, ease: "power3.inOut" }, 0).to(end, { scaleX: 0, transformOrigin: "right center", duration: 0.75, ease: "power3.inOut" }, 0);
+    return timeline;
+  }).filter(Boolean);
+}
+function createImageFocusPans({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-image-focus-pan]")].map((scene) => {
+    const image = scene.querySelector("img, [data-motion-focus-image]");
+    if (!image) return void 0;
+    return gsap.fromTo(image, { scale: 1.08, xPercent: -2, yPercent: -2 }, {
+      scale: 1,
+      xPercent: 2,
+      yPercent: 2,
+      ease: "none",
+      scrollTrigger: { trigger: scene, start: "top bottom", end: "bottom top", scrub: 1, markers: debug }
+    });
+  }).filter(Boolean);
+}
+function createVideoPosterPlayers({ gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-video-poster]")].map((scene) => {
+    const trigger2 = scene.querySelector("[data-motion-video-trigger]");
+    const poster = scene.querySelector("[data-motion-video-poster-image]");
+    const video = scene.querySelector("[data-motion-video-element], video");
+    if (!trigger2 || !video) return void 0;
+    const play = async () => {
+      trigger2.setAttribute("aria-pressed", "true");
+      video.controls = true;
+      try {
+        await video.play();
+      } catch {
+        trigger2.setAttribute("aria-pressed", "false");
+        return;
+      }
+      if (poster) reduced ? gsap.set(poster, { autoAlpha: 0 }) : gsap.to(poster, { autoAlpha: 0, duration: 0.25 });
+    };
+    trigger2.addEventListener("click", play);
+    return () => {
+      trigger2.removeEventListener("click", play);
+      video.pause();
+      trigger2.setAttribute("aria-pressed", "false");
+      if (poster) gsap.set(poster, { clearProps: "opacity,visibility" });
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/menu.js
+function createMenus({ gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-menu]")].map((menu) => {
+    const ownerDocument = menu.ownerDocument;
+    const trigger2 = menu.querySelector("[data-motion-menu-trigger]");
+    const panel = menu.querySelector("[data-motion-menu-panel]");
+    const items = [...menu.querySelectorAll("[data-motion-menu-item]")];
+    const closeControls = [...menu.querySelectorAll("[data-motion-menu-close]")];
+    if (!trigger2 || !panel) return () => {
+    };
+    const authored = {
+      hidden: panel.hidden,
+      ariaHidden: panel.getAttribute("aria-hidden"),
+      ariaExpanded: trigger2.getAttribute("aria-expanded"),
+      state: menu.dataset.state
+    };
+    let open = false;
+    const timeline = gsap.timeline({ paused: true }).fromTo(panel, { autoAlpha: 0, yPercent: -4 }, {
+      autoAlpha: 1,
+      yPercent: 0,
+      duration: reduced ? 0 : 0.45,
+      ease: "power3.out"
+    }).from(items, {
+      autoAlpha: 0,
+      y: "1.25rem",
+      stagger: reduced ? 0 : 0.06,
+      duration: reduced ? 0 : 0.4,
+      ease: "power3.out"
+    }, reduced ? 0 : "-=0.2");
+    const setOpen = (next, options = {}) => {
+      if (next === open) return;
+      const { restoreFocus = true } = options;
+      open = next;
+      trigger2.setAttribute("aria-expanded", String(open));
+      panel.setAttribute("aria-hidden", String(!open));
+      ownerDocument.documentElement.toggleAttribute("data-motion-scroll-locked", open);
+      if (open) {
+        panel.hidden = false;
+        menu.dataset.state = "open";
+        timeline.eventCallback("onComplete", () => {
+          if (!open) return;
+          getFocusable(panel)[0]?.focus({ preventScroll: true });
+        });
+        timeline.play(0);
+      } else {
+        menu.dataset.state = "closing";
+        timeline.eventCallback("onReverseComplete", () => {
+          panel.hidden = true;
+          menu.dataset.state = "closed";
+        });
+        timeline.reverse();
+        if (restoreFocus && panel.contains(ownerDocument.activeElement)) {
+          trigger2.focus({ preventScroll: true });
+        }
+      }
+    };
+    const onClick = () => setOpen(!open);
+    const onClose = () => setOpen(false);
+    const onPointerDown = (event) => {
+      if (!open || menu.contains(event.target)) return;
+      setOpen(false, { restoreFocus: false });
+    };
+    const onKeydown = (event) => {
+      if (event.key === "Escape" && open) setOpen(false);
+      if (event.key !== "Tab" || !open) return;
+      const focusable2 = getFocusable(panel);
+      const first = focusable2[0];
+      const last = focusable2.at(-1);
+      if (event.shiftKey && ownerDocument.activeElement === first) {
+        event.preventDefault();
+        last?.focus();
+      } else if (!event.shiftKey && ownerDocument.activeElement === last) {
+        event.preventDefault();
+        first?.focus();
+      }
+    };
+    trigger2.addEventListener("click", onClick);
+    closeControls.forEach((control) => control.addEventListener("click", onClose));
+    ownerDocument.addEventListener("keydown", onKeydown);
+    ownerDocument.addEventListener("pointerdown", onPointerDown);
+    menu.dataset.state = "closed";
+    panel.hidden = true;
+    trigger2.setAttribute("aria-expanded", "false");
+    panel.setAttribute("aria-hidden", "true");
+    return () => {
+      trigger2.removeEventListener("click", onClick);
+      closeControls.forEach((control) => control.removeEventListener("click", onClose));
+      ownerDocument.removeEventListener("keydown", onKeydown);
+      ownerDocument.removeEventListener("pointerdown", onPointerDown);
+      ownerDocument.documentElement.removeAttribute("data-motion-scroll-locked");
+      timeline.revert?.();
+      timeline.kill();
+      if (authored.state === void 0) delete menu.dataset.state;
+      else menu.dataset.state = authored.state;
+      panel.hidden = authored.hidden;
+      if (authored.ariaHidden === null) panel.removeAttribute("aria-hidden");
+      else panel.setAttribute("aria-hidden", authored.ariaHidden);
+      if (authored.ariaExpanded === null) trigger2.removeAttribute("aria-expanded");
+      else trigger2.setAttribute("aria-expanded", authored.ariaExpanded);
+    };
+  });
+}
+
+// src/patterns/overlay-effects.js
+function focusable(dialog) {
+  return dialog.querySelector('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+}
+function createDialogControllers({ gsap, root, reduced, selector, shortcut = false }) {
+  return [...root.querySelectorAll(selector)].map((scene) => {
+    const trigger2 = scene.querySelector("[data-motion-overlay-trigger]");
+    const dialog = scene.querySelector("dialog, [data-motion-overlay-dialog]");
+    const closeControls = [...scene.querySelectorAll("[data-motion-overlay-close]")];
+    if (!dialog) return void 0;
+    const ownerDocument = scene.ownerDocument;
+    const initialOpen = dialog.hasAttribute("open");
+    const initialExpanded = trigger2?.getAttribute("aria-expanded");
+    const initialFocus = ownerDocument.activeElement;
+    let opener;
+    const open = () => {
+      opener = ownerDocument.activeElement === ownerDocument.body ? trigger2 : ownerDocument.activeElement;
+      if (typeof dialog.showModal === "function") dialog.showModal();
+      else dialog.setAttribute("open", "");
+      trigger2?.setAttribute("aria-expanded", "true");
+      if (!reduced) gsap.fromTo(dialog, { autoAlpha: 0, y: "1rem" }, { autoAlpha: 1, y: 0, duration: 0.25, ease: "power2.out" });
+      focusable(dialog)?.focus();
+    };
+    const close = () => {
+      if (typeof dialog.close === "function" && dialog.open) dialog.close();
+      else dialog.removeAttribute("open");
+      trigger2?.setAttribute("aria-expanded", "false");
+      opener?.focus?.();
+    };
+    const syncClosed = () => {
+      trigger2?.setAttribute("aria-expanded", "false");
+      opener?.focus?.();
+    };
+    const keydown = (event) => {
+      if (shortcut && (event.metaKey || event.ctrlKey) && event.key.toLowerCase() === "k") {
+        event.preventDefault();
+        dialog.hasAttribute("open") ? close() : open();
+      }
+    };
+    trigger2?.addEventListener("click", open);
+    closeControls.forEach((control) => control.addEventListener("click", close));
+    dialog.addEventListener("close", syncClosed);
+    ownerDocument.addEventListener("keydown", keydown);
+    return () => {
+      trigger2?.removeEventListener("click", open);
+      closeControls.forEach((control) => control.removeEventListener("click", close));
+      ownerDocument.removeEventListener("keydown", keydown);
+      if (!initialOpen && dialog.hasAttribute("open")) close();
+      dialog.removeEventListener("close", syncClosed);
+      dialog.toggleAttribute("open", initialOpen);
+      if (trigger2) {
+        if (initialExpanded === null) trigger2.removeAttribute("aria-expanded");
+        else trigger2.setAttribute("aria-expanded", initialExpanded);
+      }
+      const focusTarget = opener?.isConnected ? opener : initialFocus?.isConnected ? initialFocus : void 0;
+      if (dialog.contains(ownerDocument.activeElement) || !initialOpen) focusTarget?.focus?.();
+      gsap.set(dialog, { clearProps: "transform,opacity,visibility" });
+    };
+  }).filter(Boolean);
+}
+function createDialogOverlays(context) {
+  return createDialogControllers({ ...context, selector: "[data-motion-dialog-overlay]" });
+}
+function createCommandPalettes(context) {
+  return createDialogControllers({ ...context, selector: "[data-motion-command-palette]", shortcut: true });
+}
+function createNavActiveIndicators({ gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-nav-indicator]")].map((nav) => {
+    const items = [...nav.querySelectorAll("[data-motion-nav-item]")];
+    const indicator = nav.querySelector("[data-motion-nav-active-indicator]");
+    if (!items.length || !indicator) return void 0;
+    const activate = (item) => {
+      items.forEach((entry) => entry.toggleAttribute("data-active", entry === item));
+      const navRect = nav.getBoundingClientRect();
+      const itemRect = item.getBoundingClientRect();
+      const vars = { x: itemRect.left - navRect.left, scaleX: itemRect.width / Math.max(1, indicator.getBoundingClientRect().width), transformOrigin: "left center" };
+      reduced ? gsap.set(indicator, vars) : gsap.to(indicator, { ...vars, duration: 0.3, ease: "power2.out", overwrite: "auto" });
+    };
+    const listeners = items.map((item) => {
+      const handler = () => activate(item);
+      item.addEventListener("focus", handler);
+      item.addEventListener("pointerenter", handler);
+      item.addEventListener("click", handler);
+      return [item, handler];
+    });
+    activate(items.find((item) => item.getAttribute("aria-current") === "page") ?? items[0]);
+    return () => {
+      listeners.forEach(([item, handler]) => {
+        item.removeEventListener("focus", handler);
+        item.removeEventListener("pointerenter", handler);
+        item.removeEventListener("click", handler);
+        item.removeAttribute("data-active");
+      });
+      gsap.set(indicator, { clearProps: "transform" });
+    };
+  }).filter(Boolean);
+}
+function createAccordionDisclosures({ gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-accordion-motion]")].map((disclosure) => {
+    const panel = disclosure.querySelector("[data-motion-accordion-panel]");
+    if (!panel) return void 0;
+    const toggle = () => {
+      const open = disclosure.hasAttribute("open") || disclosure.getAttribute("aria-expanded") === "true";
+      if (open && !reduced) gsap.fromTo(panel, { autoAlpha: 0, y: "-0.5rem" }, { autoAlpha: 1, y: 0, duration: 0.25, ease: "power2.out" });
+    };
+    disclosure.addEventListener("toggle", toggle);
+    return () => {
+      disclosure.removeEventListener("toggle", toggle);
+      gsap.set(panel, { clearProps: "transform,opacity,visibility" });
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/parallax.js
+function createParallax({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-parallax]")].map((element) => {
+    const distance2 = numberAttribute(element, "data-motion-parallax", 12);
+    return gsap.fromTo(
+      element,
+      { yPercent: -distance2 },
+      {
+        yPercent: distance2,
+        ease: "none",
+        scrollTrigger: {
+          trigger: element.closest("[data-motion-parallax-scene]") || element,
+          start: "top bottom",
+          end: "bottom top",
+          scrub: numberAttribute(element, "data-motion-scrub", 0.6),
+          markers: debug
+        }
+      }
+    );
+  });
+}
+
+// src/patterns/pinned-sequence.js
+function createPinnedSequences({ ScrollTrigger, root, debug, reduced, selector, itemSelector, visualSelector }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll(selector)].map((scene) => {
+    const pin = scene.querySelector("[data-motion-pin-target]");
+    const items = [...scene.querySelectorAll(itemSelector)];
+    const visuals = [...scene.querySelectorAll(visualSelector)];
+    if (!pin || !items.length) return void 0;
+    const activate = (index) => {
+      setActiveState(items, index, { ariaCurrent: true });
+      if (visuals.length) setActiveState(visuals, Math.min(index, visuals.length - 1));
+    };
+    activate(0);
+    const instance = ScrollTrigger.create({
+      trigger: scene,
+      start: "top top",
+      end: scene.getAttribute("data-motion-end") || "bottom bottom",
+      pin,
+      markers: debug,
+      onUpdate(self) {
+        activate(clampIndex(self.progress, items.length));
+      }
+    });
+    return () => {
+      instance.kill();
+      items.forEach((item) => {
+        item.removeAttribute("data-active");
+        item.removeAttribute("aria-current");
+      });
+      visuals.forEach((visual) => visual.removeAttribute("data-active"));
+    };
+  }).filter(Boolean);
+}
+function createPinnedChapterCrossfades(context) {
+  return createPinnedSequences({
+    ...context,
+    selector: "[data-motion-pinned-chapters]",
+    itemSelector: "[data-motion-pinned-chapter]",
+    visualSelector: "[data-motion-pinned-visual]"
+  });
+}
+function createPinnedProductExplainers(context) {
+  return createPinnedSequences({
+    ...context,
+    selector: "[data-motion-product-explainer]",
+    itemSelector: "[data-motion-product-step]",
+    visualSelector: "[data-motion-product-media]"
+  });
+}
+
+// src/patterns/reveal.js
+var presets = {
+  fade: { autoAlpha: 0 },
+  up: { autoAlpha: 0, y: "2rem" },
+  down: { autoAlpha: 0, y: "-2rem" },
+  left: { autoAlpha: 0, x: "2rem" },
+  right: { autoAlpha: 0, x: "-2rem" },
+  scale: { autoAlpha: 0, scale: 0.94 }
+};
+function createReveals({ gsap, root, debug, reduced, revealStart }) {
+  return [...root.querySelectorAll("[data-motion-reveal]")].map((element) => {
+    if (reduced) {
+      gsap.set(element, { clearProps: "all", autoAlpha: 1 });
+      return null;
+    }
+    const preset = presets[element.dataset.motionReveal] ?? presets.up;
+    const duration = numberAttribute(element, "data-motion-duration", 0.8);
+    const delay = numberAttribute(element, "data-motion-delay", 0);
+    return gsap.from(element, {
+      ...preset,
+      duration,
+      delay,
+      ease: element.dataset.motionEase || "power3.out",
+      scrollTrigger: {
+        trigger: element,
+        start: element.dataset.motionStart || revealStart,
+        once: element.dataset.motionOnce !== "false",
+        markers: debug
+      }
+    });
+  }).filter(Boolean);
+}
+
+// src/patterns/reveal-effects.js
+var directions = {
+  left: { xPercent: -8, yPercent: 0 },
+  right: { xPercent: 8, yPercent: 0 },
+  down: { xPercent: 0, yPercent: -12 },
+  up: { xPercent: 0, yPercent: 12 }
+};
+function viewportConfig(element, debug) {
+  return {
+    trigger: element,
+    start: element.getAttribute("data-motion-start") || "top 85%",
+    once: true,
+    markers: debug
+  };
+}
+function createDirectionalReveals({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-reveal-directional]")].map((element) => {
+    const direction = directions[element.getAttribute("data-motion-reveal-directional")] ?? directions.up;
+    return gsap.from(element, {
+      autoAlpha: 0,
+      ...direction,
+      duration: numberAttribute(element, "data-motion-duration", 0.7),
+      ease: "power2.out",
+      clearProps: "transform,opacity,visibility",
+      scrollTrigger: viewportConfig(element, debug)
+    });
+  });
+}
+function createScaleReveals({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-reveal-scale]")].map((element) => gsap.from(element, {
+    autoAlpha: 0,
+    scale: numberAttribute(element, "data-motion-reveal-scale", 0.94),
+    transformOrigin: element.getAttribute("data-motion-origin") || "50% 50%",
+    duration: numberAttribute(element, "data-motion-duration", 0.75),
+    ease: "power2.out",
+    clearProps: "transform,opacity,visibility",
+    scrollTrigger: viewportConfig(element, debug)
+  }));
+}
+function createClipWipeReveals({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-reveal-clip]")].map((scene) => {
+    const content = scene.querySelector("[data-motion-reveal-clip-content]") ?? scene;
+    const direction = scene.getAttribute("data-motion-reveal-clip") || "start";
+    const clipPath = direction === "end" ? "inset(0 0 0 100%)" : "inset(0 100% 0 0)";
+    return gsap.from(content, {
+      clipPath,
+      duration: numberAttribute(scene, "data-motion-duration", 0.9),
+      ease: "power3.inOut",
+      clearProps: "clipPath",
+      scrollTrigger: viewportConfig(scene, debug)
+    });
+  });
+}
+
+// src/patterns/scroll-drift.js
+function createScrollDrifts({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-scroll-drift]")].map((scene) => {
+    const layer = scene.querySelector("[data-motion-drift-layer]");
+    if (!layer) return null;
+    return gsap.fromTo(
+      layer,
+      { autoAlpha: 0, xPercent: numberAttribute(scene, "data-motion-drift-from", 10) },
+      {
+        autoAlpha: numberAttribute(scene, "data-motion-drift-opacity", 0.1),
+        xPercent: 0,
+        duration: 0.5,
+        ease: "none",
+        scrollTrigger: {
+          trigger: scene,
+          start: "clamp(top bottom)",
+          end: "clamp(bottom top)",
+          scrub: numberAttribute(scene, "data-motion-scrub", 0.8),
+          markers: debug
+        }
+      }
+    );
+  }).filter(Boolean);
+}
+
+// src/patterns/scroll-exit.js
+function createScrollExits({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-scroll-exit]")].map((element) => {
+    const direction = element.dataset.motionScrollExit || "down";
+    const distance2 = element.dataset.motionExitDistance || "8rem";
+    const movement = direction === "up" ? `-${distance2}` : distance2;
+    const scene = element.closest("[data-motion-scroll-exit-scene]") || element;
+    return gsap.to(element, {
+      autoAlpha: 0,
+      y: movement,
+      ease: "none",
+      scrollTrigger: {
+        trigger: scene,
+        start: element.dataset.motionExitStart || "top top",
+        end: element.dataset.motionExitEnd || "bottom 35%",
+        scrub: Number.parseFloat(element.dataset.motionScrub || "0.45"),
+        markers: debug
+      }
+    });
+  });
+}
+
+// src/patterns/scroll-statement.js
+function createScrollStatements({ gsap, ScrollTrigger, root, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-scroll-statement]")].map((scene) => {
+    const pin = scene.querySelector("[data-motion-statement-pin]");
+    const heading = scene.querySelector("[data-motion-statement-heading]");
+    const lead = scene.querySelector("[data-motion-statement-lead]");
+    const heroAccent = scene.querySelector("[data-motion-statement-hero-accent]");
+    const inlineAccent = scene.querySelector("[data-motion-statement-inline-accent]");
+    const details = scene.querySelector("[data-motion-statement-details]");
+    const detailItems = [...scene.querySelectorAll("[data-motion-statement-detail]")];
+    const label = scene.querySelector("[data-motion-statement-label]");
+    if (!pin || !heading || !lead || !heroAccent || !inlineAccent || !details) return null;
+    gsap.set(heroAccent, { autoAlpha: 1, scale: 9 });
+    gsap.set(heading, { xPercent: -50 });
+    gsap.set(lead, { opacity: 0 });
+    gsap.set(inlineAccent, { opacity: 0, xPercent: 50 });
+    gsap.set(details, { height: 0 });
+    gsap.set(detailItems, { autoAlpha: 0, yPercent: 50 });
+    gsap.set(label, { autoAlpha: 0 });
+    const timeline = gsap.timeline({
+      scrollTrigger: {
+        trigger: scene,
+        start: "clamp(top top)",
+        end: "clamp(bottom bottom)",
+        scrub: numberAttribute(scene, "data-motion-scrub", 0.8),
+        invalidateOnRefresh: true
+      }
+    });
+    timeline.to(heroAccent, { scale: 1, duration: 0.2, ease: "none" }, 0).to(inlineAccent, { opacity: 1, duration: 0.07, ease: "none" }, 0.18).to(heroAccent, { autoAlpha: 0, duration: 0.05, ease: "none" }, 0.2).to(heading, { xPercent: 0, duration: 0.08, ease: "none" }, 0.26).to(inlineAccent, { xPercent: 0, duration: 0.08, ease: "none" }, 0.26).to(lead, { opacity: 1, duration: 0.06, ease: "none" }, 0.28).to(details, { height: "auto", duration: 0.1, ease: "none" }, 0.34).to(detailItems, { autoAlpha: 1, yPercent: 0, duration: 0.1, ease: "none", stagger: 0.1 }, 0.4).to(label, { autoAlpha: 1, duration: 0.31, ease: "none" }, 0.5);
+    return () => {
+      timeline.scrollTrigger?.kill();
+      timeline.revert?.();
+      timeline.kill();
+      gsap.set([heroAccent, heading, lead, inlineAccent, details, ...detailItems, label].filter(Boolean), {
+        clearProps: "transform,opacity,visibility,height"
+      });
+    };
+  }).filter(Boolean);
+}
+
+// src/patterns/scroll-steps.js
+function createScrollSteps({ ScrollTrigger, root, debug, reduced }) {
+  return [...root.querySelectorAll("[data-motion-scroll-steps]")].map((scene) => {
+    const links = [...scene.querySelectorAll("[data-motion-step-link]")];
+    const panels = [...scene.querySelectorAll("[data-motion-step-panel]")];
+    const pin = scene.querySelector("[data-motion-pin-target]");
+    const activate = (index) => {
+      setActiveState(links, index, { ariaCurrent: true });
+      setActiveState(panels, index);
+      scene.style.setProperty("--motion-step", String(index));
+      scene.dispatchEvent(new CustomEvent("sfmotion:step", { detail: { index } }));
+    };
+    activate(0);
+    if (reduced) return { kill() {
+    } };
+    return ScrollTrigger.create({
+      trigger: scene,
+      start: scene.dataset.motionStart || "top top",
+      end: scene.dataset.motionEnd || "bottom bottom",
+      pin: pin || false,
+      pinSpacing: scene.dataset.motionPinSpacing !== "false",
+      scrub: true,
+      markers: debug,
+      onUpdate(self) {
+        activate(clampIndex(self.progress, Math.max(links.length, panels.length)));
+      }
+    });
+  });
+}
+
+// src/patterns/scroll-progress.js
+function createScrollProgressMeters({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-scroll-progress]")].map((scene) => {
+    const meter = scene.querySelector("[data-motion-scroll-progress-meter]");
+    const label = scene.querySelector("[data-motion-scroll-progress-label]");
+    if (!meter) return void 0;
+    return gsap.fromTo(meter, { scaleX: 0 }, {
+      scaleX: 1,
+      transformOrigin: "left center",
+      ease: "none",
+      scrollTrigger: {
+        trigger: scene,
+        start: scene.getAttribute("data-motion-start") || "top bottom",
+        end: scene.getAttribute("data-motion-end") || "bottom top",
+        scrub: true,
+        markers: debug,
+        onUpdate(self) {
+          if (label) label.textContent = `${Math.round(self.progress * 100)}%`;
+        }
+      }
+    });
+  }).filter(Boolean);
+}
+function createScrollDepthStacks({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-scroll-depth-stack]")].map((scene) => {
+    const cards = [...scene.querySelectorAll("[data-motion-depth-card]")];
+    if (!cards.length) return void 0;
+    return gsap.from(cards, {
+      autoAlpha: 0,
+      yPercent: 12,
+      scale: 0.96,
+      stagger: 0.08,
+      duration: 0.7,
+      ease: "power2.out",
+      scrollTrigger: { trigger: scene, start: "top 85%", once: true, markers: debug }
+    });
+  }).filter(Boolean);
+}
+
+// src/patterns/split-text.js
+function createSplitText({ gsap, SplitText, root, debug, reduced, revealStart }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-split]")].map((element) => {
+    const type = element.dataset.motionSplit || "lines";
+    const targetKey = type.includes("chars") ? "chars" : type.includes("words") ? "words" : "lines";
+    const accessibleText = element.getAttribute("aria-label") || element.textContent.trim();
+    return SplitText.create(element, {
+      type,
+      autoSplit: type.includes("lines"),
+      mask: element.dataset.motionSplitMask === "true" ? targetKey : void 0,
+      aria: "auto",
+      onSplit(instance) {
+        if (accessibleText) element.setAttribute("aria-label", accessibleText);
+        return gsap.from(instance[targetKey], {
+          autoAlpha: 0,
+          yPercent: targetKey === "chars" ? 55 : 105,
+          rotationX: targetKey === "chars" ? -22 : 0,
+          transformOrigin: "50% 100%",
+          duration: Number.parseFloat(element.dataset.motionDuration || "0.9"),
+          stagger: Number.parseFloat(element.dataset.motionStagger || (targetKey === "chars" ? "0.018" : "0.08")),
+          ease: element.dataset.motionEase || "power3.out",
+          scrollTrigger: {
+            trigger: element,
+            start: element.dataset.motionStart || revealStart,
+            once: element.dataset.motionOnce !== "false",
+            markers: debug
+          }
+        });
+      }
+    });
+  });
+}
+
+// src/patterns/stagger.js
+function createStaggers({ gsap, root, debug, reduced, revealStart }) {
+  return [...root.querySelectorAll("[data-motion-stagger]")].map((container) => {
+    const selector = container.dataset.motionStaggerTarget || ":scope > *";
+    const targets = [...container.querySelectorAll(selector)];
+    if (targets.length === 0) return null;
+    if (reduced) {
+      gsap.set(targets, { clearProps: "all", autoAlpha: 1 });
+      return null;
+    }
+    return gsap.from(targets, {
+      autoAlpha: 0,
+      y: container.dataset.motionDistance || "1.5rem",
+      duration: numberAttribute(container, "data-motion-duration", 0.7),
+      stagger: numberAttribute(container, "data-motion-stagger", 0.09),
+      ease: container.dataset.motionEase || "power3.out",
+      scrollTrigger: {
+        trigger: container,
+        start: container.dataset.motionStart || revealStart,
+        once: container.dataset.motionOnce !== "false",
+        markers: debug
+      }
+    });
+  }).filter(Boolean);
+}
+
+// src/patterns/page-transitions.js
+function disposeAll(animations) {
+  animations.splice(0).forEach((animation) => {
+    animation?.scrollTrigger?.kill?.();
+    animation?.revert?.();
+    animation?.kill?.();
+  });
+}
+function createPageLoadHeroes({ gsap, root, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-page-load-hero]")].map((scene) => {
+    const items = [...scene.querySelectorAll("[data-motion-page-load-item]")];
+    if (!items.length) return void 0;
+    return gsap.from(items, { autoAlpha: 0, y: "1.5rem", duration: 0.7, stagger: 0.09, ease: "power3.out", clearProps: "transform,opacity,visibility" });
+  }).filter(Boolean);
+}
+function createPageLoadBrandMarks({ gsap, root, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-page-load-brand]")].map((scene) => {
+    const mark = scene.querySelector("[data-motion-brand-mark]") ?? scene;
+    return gsap.from(mark, { autoAlpha: 0, scale: 0.92, rotate: -4, transformOrigin: "center", duration: 0.8, ease: "power3.out", clearProps: "transform,opacity,visibility" });
+  });
+}
+function createRouteFades({ gsap, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-route-fade]")].map((scene) => {
+    const animations = [];
+    const transition = (event) => {
+      const outgoing = event.detail?.outgoing ?? scene.querySelector("[data-motion-route-outgoing]");
+      const incoming = event.detail?.incoming ?? scene.querySelector("[data-motion-route-incoming]");
+      const complete = typeof event.detail?.complete === "function" ? event.detail.complete : () => {
+      };
+      if (reduced) {
+        complete();
+        return;
+      }
+      const timeline = gsap.timeline({ onComplete: complete });
+      if (outgoing) timeline.to(outgoing, { autoAlpha: 0, duration: 0.2 });
+      if (incoming) timeline.fromTo(incoming, { autoAlpha: 0 }, { autoAlpha: 1, duration: 0.3 });
+      animations.push(timeline);
+    };
+    scene.addEventListener("motion:route", transition);
+    return () => {
+      scene.removeEventListener("motion:route", transition);
+      disposeAll(animations);
+    };
+  });
+}
+function createRouteSharedMedia({ Flip, root, reduced }) {
+  return [...root.querySelectorAll("[data-motion-route-shared-media]")].map((scene) => {
+    const animations = [];
+    const transition = (event) => {
+      const media = [...scene.querySelectorAll("[data-motion-shared-media]")];
+      if (!media.length || typeof event.detail?.mutate !== "function") return;
+      const state = Flip.getState(media);
+      event.detail.mutate(scene, media);
+      if (!reduced) animations.push(Flip.from(state, { duration: 0.65, ease: "power2.inOut", absolute: true }));
+    };
+    scene.addEventListener("motion:route-shared", transition);
+    return () => {
+      scene.removeEventListener("motion:route-shared", transition);
+      disposeAll(animations);
+    };
+  });
+}
+function createRouteScrollRestores({ ScrollTrigger, root }) {
+  return [...root.querySelectorAll("[data-motion-route-scroll-restore]")].map((scene) => {
+    const view = scene.ownerDocument.defaultView;
+    const restore = (event) => {
+      const top = Number.isFinite(event.detail?.top) ? event.detail.top : 0;
+      view?.scrollTo?.({ top, left: 0, behavior: "auto" });
+      ScrollTrigger.refresh();
+    };
+    scene.addEventListener("motion:route-complete", restore);
+    return () => scene.removeEventListener("motion:route-complete", restore);
+  });
+}
+
+// src/patterns/svg-effects.js
+function dispose(animation) {
+  animation?.scrollTrigger?.kill?.();
+  animation?.revert?.();
+  animation?.kill?.();
+}
+function createSvgLineDraws({ gsap, root, reduced, debug }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-svg-line-draw]")].map((scene) => {
+    const paths = [...scene.querySelectorAll("[data-motion-svg-path], path, line, polyline")];
+    if (!paths.length) return void 0;
+    return gsap.from(paths, {
+      drawSVG: "0%",
+      duration: 1,
+      stagger: 0.08,
+      ease: "power2.inOut",
+      scrollTrigger: { trigger: scene, start: "top 85%", once: true, markers: debug }
+    });
+  }).filter(Boolean);
+}
+function createMorphControllers({ gsap, root, reduced, selector, sourceSelector, targetSelector }) {
+  return [...root.querySelectorAll(selector)].map((scene) => {
+    const source = scene.querySelector(sourceSelector);
+    const target = scene.querySelector(targetSelector);
+    const trigger2 = scene.querySelector("[data-motion-svg-trigger]") ?? scene.querySelector("button");
+    if (!source || !target || !trigger2) return void 0;
+    const original = source.getAttribute("d");
+    let active = false;
+    let tween;
+    const toggle = () => {
+      active = !active;
+      trigger2.setAttribute("aria-pressed", String(active));
+      const destination = active ? target : original;
+      if (reduced) source.setAttribute("d", active ? target.getAttribute("d") : original);
+      else tween = gsap.to(source, { morphSVG: destination, duration: 0.55, ease: "power2.inOut", overwrite: true });
+    };
+    trigger2.addEventListener("click", toggle);
+    return () => {
+      trigger2.removeEventListener("click", toggle);
+      trigger2.setAttribute("aria-pressed", "false");
+      dispose(tween);
+      if (original === null) source.removeAttribute("d");
+      else source.setAttribute("d", original);
+    };
+  }).filter(Boolean);
+}
+function createSvgPathMorphs(context) {
+  return createMorphControllers({
+    ...context,
+    selector: "[data-motion-svg-morph]",
+    sourceSelector: "[data-motion-svg-morph-source]",
+    targetSelector: "[data-motion-svg-morph-target]"
+  });
+}
+function createSvgIconStates(context) {
+  return createMorphControllers({
+    ...context,
+    selector: "[data-motion-svg-icon-state]",
+    sourceSelector: "[data-motion-svg-icon-source]",
+    targetSelector: "[data-motion-svg-icon-target]"
+  });
+}
+function createSvgOrbits({ gsap, root, reduced, debug }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-svg-orbit]")].map((scene) => {
+    const subject = scene.querySelector("[data-motion-svg-orbit-subject]");
+    const path = scene.querySelector("[data-motion-svg-orbit-path]");
+    if (!subject || !path) return void 0;
+    return gsap.to(subject, {
+      motionPath: { path, align: path, alignOrigin: [0.5, 0.5], autoRotate: true },
+      ease: "none",
+      scrollTrigger: { trigger: scene, start: "top bottom", end: "bottom top", scrub: 1, markers: debug }
+    });
+  }).filter(Boolean);
+}
+function createSvgSignatureReveals({ gsap, root, reduced, debug }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-svg-signature]")].map((scene) => {
+    const paths = [...scene.querySelectorAll("path")];
+    if (!paths.length) return void 0;
+    return gsap.from(paths, {
+      drawSVG: "0%",
+      duration: 0.8,
+      stagger: 0.12,
+      ease: "power1.inOut",
+      scrollTrigger: { trigger: scene, start: "top 85%", once: true, markers: debug }
+    });
+  }).filter(Boolean);
+}
+
+// src/patterns/text-effects.js
+function trigger(element, debug) {
+  return {
+    trigger: element,
+    start: element.getAttribute("data-motion-start") || "top 85%",
+    once: true,
+    markers: debug
+  };
+}
+function splitCleanup(split, tween) {
+  return () => {
+    tween?.scrollTrigger?.kill();
+    tween?.revert?.();
+    tween?.kill?.();
+    split.revert();
+  };
+}
+function createCharacterShimmers({ gsap, SplitText, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-chars-shimmer]")].map((element) => {
+    const accessibleText = element.getAttribute("aria-label") || element.textContent.trim();
+    const split = SplitText.create(element, { type: "chars", aria: "auto" });
+    if (accessibleText) element.setAttribute("aria-label", accessibleText);
+    const tween = gsap.from(split.chars, {
+      autoAlpha: 0,
+      yPercent: 35,
+      duration: numberAttribute(element, "data-motion-duration", 0.55),
+      stagger: { amount: numberAttribute(element, "data-motion-stagger-amount", 0.45), from: "start" },
+      ease: "power2.out",
+      scrollTrigger: trigger(element, debug)
+    });
+    return splitCleanup(split, tween);
+  });
+}
+function createTypewriterAnnouncements({ gsap, SplitText, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-typewriter]")].map((element) => {
+    const accessibleText = element.getAttribute("aria-label") || element.textContent.trim();
+    const split = SplitText.create(element, { type: "chars", aria: "auto" });
+    if (accessibleText) element.setAttribute("aria-label", accessibleText);
+    const tween = gsap.from(split.chars, {
+      autoAlpha: 0,
+      duration: 0.01,
+      stagger: numberAttribute(element, "data-motion-typewriter-speed", 0.035),
+      ease: "none",
+      scrollTrigger: element.hasAttribute("data-motion-typewriter-load") ? void 0 : trigger(element, debug)
+    });
+    return splitCleanup(split, tween);
+  });
+}
+function createTextHighlightSweeps({ gsap, root, debug, reduced }) {
+  if (reduced) return [];
+  return [...root.querySelectorAll("[data-motion-text-highlight]")].map((scene) => {
+    const mark = scene.querySelector("[data-motion-text-highlight-mark]");
+    if (!mark) return void 0;
+    return gsap.from(mark, {
+      scaleX: 0,
+      transformOrigin: scene.getAttribute("data-motion-text-highlight") === "end" ? "right center" : "left center",
+      duration: numberAttribute(scene, "data-motion-duration", 0.7),
+      ease: "power2.inOut",
+      clearProps: "transform",
+      scrollTrigger: trigger(scene, debug)
+    });
+  }).filter(Boolean);
+}
+
+// src/recipes/specs.js
+function withScopedElement(root, callback) {
+  const ownDescriptor = Object.getOwnPropertyDescriptor(root, "querySelectorAll");
+  const queryDescendants = root.querySelectorAll.bind(root);
+  Object.defineProperty(root, "querySelectorAll", {
+    configurable: true,
+    value(selector) {
+      const descendants = [...queryDescendants(selector)];
+      return root.matches(selector) ? [root, ...descendants] : descendants;
+    }
+  });
+  try {
+    return callback(root);
+  } finally {
+    if (ownDescriptor) Object.defineProperty(root, "querySelectorAll", ownDescriptor);
+    else delete root.querySelectorAll;
+  }
+}
+function disposeResults(results) {
+  for (const result of Array.isArray(results) ? results : [results]) {
+    if (typeof result === "function") result();
+    else if (typeof result?.destroy === "function") result.destroy();
+    else {
+      result?.scrollTrigger?.kill?.();
+      result?.revert?.();
+      result?.kill?.();
+    }
+  }
+}
+function setupFactory(factory, extend = (context) => context) {
+  return (context) => {
+    const results = withScopedElement(context.root, (root) => factory({ ...extend(context), root }));
+    const activeResults = (Array.isArray(results) ? results : [results]).filter(Boolean);
+    if (!activeResults.length && !context.reduced) return false;
+    return () => disposeResults(activeResults);
+  };
+}
+var SHARED_REDUCED_MOTION = /* @__PURE__ */ Object.freeze({
+  strategy: "final",
+  behavior: "Preserve the authored readable final state."
+});
+function spec({
+  id,
+  selector,
+  slots = [],
+  parameters = {},
+  triggers,
+  performance = "medium",
+  dependencies = ["gsap"],
+  setup
+}) {
+  return Object.freeze({
+    schemaVersion: "1",
+    id,
+    version: "1.0.0",
+    root: { selector },
+    slots: [{ name: "root" }, ...slots],
+    parameters,
+    triggers,
+    reducedMotion: SHARED_REDUCED_MOTION,
+    performance: { class: performance },
+    dependencies,
+    setup
+  });
+}
+var revealRise = /* @__PURE__ */ spec({
+  id: "reveal-rise",
+  selector: "[data-motion-reveal]",
+  parameters: { start: { type: "string", default: "top 85%" } },
+  triggers: [{ type: "viewport", start: "top 85%" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createReveals, (context) => ({ ...context, revealStart: context.parameters.start }))
+});
+var revealStaggerCascade = /* @__PURE__ */ spec({
+  id: "reveal-stagger-cascade",
+  selector: "[data-motion-stagger]",
+  slots: [{ name: "items", selector: "[data-motion-stagger-item]", required: false, multiple: true }],
+  parameters: { start: { type: "string", default: "top 85%" } },
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createStaggers, (context) => ({ ...context, revealStart: context.parameters.start }))
+});
+var revealDirectional = /* @__PURE__ */ spec({
+  id: "reveal-directional",
+  selector: "[data-motion-reveal-directional]",
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createDirectionalReveals)
+});
+var revealScaleIn = /* @__PURE__ */ spec({
+  id: "reveal-scale-in",
+  selector: "[data-motion-reveal-scale]",
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createScaleReveals)
+});
+var revealClipWipe = /* @__PURE__ */ spec({
+  id: "reveal-clip-wipe",
+  selector: "[data-motion-reveal-clip]",
+  slots: [{ name: "content", selector: "[data-motion-reveal-clip-content]", required: false }],
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createClipWipeReveals)
+});
+var splitLinesRise = /* @__PURE__ */ spec({
+  id: "split-lines-rise",
+  selector: '[data-motion-split="lines"]',
+  parameters: { start: { type: "string", default: "top 85%" } },
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "SplitText", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createSplitText, (context) => ({ ...context, revealStart: context.parameters.start }))
+});
+var splitWordsCascade = /* @__PURE__ */ spec({
+  id: "split-words-cascade",
+  selector: '[data-motion-split="words"]',
+  parameters: { start: { type: "string", default: "top 85%" } },
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "SplitText", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createSplitText, (context) => ({ ...context, revealStart: context.parameters.start }))
+});
+var splitCharsShimmer = /* @__PURE__ */ spec({
+  id: "split-chars-shimmer",
+  selector: "[data-motion-chars-shimmer]",
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "SplitText", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createCharacterShimmers)
+});
+var typewriterAnnounce = /* @__PURE__ */ spec({
+  id: "typewriter-announce",
+  selector: "[data-motion-typewriter]",
+  triggers: [{ type: "viewport" }, { type: "load" }],
+  dependencies: ["gsap", "SplitText", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createTypewriterAnnouncements)
+});
+var textHighlightSweep = /* @__PURE__ */ spec({
+  id: "text-highlight-sweep",
+  selector: "[data-motion-text-highlight]",
+  slots: [{ name: "mark", selector: "[data-motion-text-highlight-mark]" }],
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createTextHighlightSweeps)
+});
+var scrollParallax = /* @__PURE__ */ spec({
+  id: "scroll-parallax",
+  selector: "[data-motion-parallax]",
+  triggers: [{ type: "scroll" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createParallax)
+});
+var scrollExit = /* @__PURE__ */ spec({
+  id: "scroll-exit",
+  selector: "[data-motion-scroll-exit]",
+  triggers: [{ type: "scroll" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createScrollExits)
+});
+var scrollDrift = /* @__PURE__ */ spec({
+  id: "scroll-drift",
+  selector: "[data-motion-scroll-drift]",
+  slots: [{ name: "layer", selector: "[data-motion-drift-layer]" }],
+  triggers: [{ type: "scroll" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createScrollDrifts)
+});
+var scrollProgressMeter = /* @__PURE__ */ spec({
+  id: "scroll-progress-meter",
+  selector: "[data-motion-scroll-progress]",
+  slots: [{ name: "meter", selector: "[data-motion-scroll-progress-meter]" }, { name: "label", selector: "[data-motion-scroll-progress-label]", required: false }],
+  triggers: [{ type: "scroll" }],
+  performance: "low",
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createScrollProgressMeters)
+});
+var scrollDepthStack = /* @__PURE__ */ spec({
+  id: "scroll-depth-stack",
+  selector: "[data-motion-scroll-depth-stack]",
+  slots: [{ name: "cards", selector: "[data-motion-depth-card]", multiple: true }],
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createScrollDepthStacks)
+});
+var pinnedSteps = /* @__PURE__ */ spec({
+  id: "pinned-steps",
+  selector: "[data-motion-scroll-steps]",
+  slots: [{ name: "pin", selector: "[data-motion-pin-target]" }, { name: "links", selector: "[data-motion-step-link]", multiple: true }, { name: "panels", selector: "[data-motion-step-panel]", multiple: true }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createScrollSteps)
+});
+var pinnedStatement = /* @__PURE__ */ spec({
+  id: "pinned-statement",
+  selector: "[data-motion-scroll-statement]",
+  slots: [{ name: "pin", selector: "[data-motion-statement-pin]" }, { name: "heading", selector: "[data-motion-statement-heading]" }, { name: "details", selector: "[data-motion-statement-details]" }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createScrollStatements)
+});
+var pinnedFounderStory = /* @__PURE__ */ spec({
+  id: "pinned-founder-story",
+  selector: "[data-motion-founder-scene]",
+  slots: [{ name: "content", selector: "[data-motion-founder-content]" }, { name: "heading", selector: "[data-motion-founder-heading]" }, { name: "metrics", selector: "[data-motion-founder-metrics]" }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["gsap", "SplitText", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createFounderScenes)
+});
+var pinnedChapterCrossfade = /* @__PURE__ */ spec({
+  id: "pinned-chapter-crossfade",
+  selector: "[data-motion-pinned-chapters]",
+  slots: [{ name: "pin", selector: "[data-motion-pin-target]" }, { name: "chapters", selector: "[data-motion-pinned-chapter]", multiple: true }, { name: "visuals", selector: "[data-motion-pinned-visual]", multiple: true }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createPinnedChapterCrossfades)
+});
+var pinnedProductExplainer = /* @__PURE__ */ spec({
+  id: "pinned-product-explainer",
+  selector: "[data-motion-product-explainer]",
+  slots: [{ name: "pin", selector: "[data-motion-pin-target]" }, { name: "steps", selector: "[data-motion-product-step]", multiple: true }, { name: "media", selector: "[data-motion-product-media]", multiple: true }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createPinnedProductExplainers)
+});
+var horizontalGalleryScrub = /* @__PURE__ */ spec({
+  id: "horizontal-gallery-scrub",
+  selector: "[data-motion-horizontal-gallery]",
+  slots: [{ name: "track", selector: "[data-motion-horizontal-track]" }, { name: "cards", selector: "[data-motion-horizontal-card]", multiple: true }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createHorizontalGalleryScrubs)
+});
+var horizontalGallerySnap = /* @__PURE__ */ spec({
+  id: "horizontal-gallery-snap",
+  selector: "[data-motion-horizontal-snap]",
+  slots: [{ name: "track", selector: "[data-motion-horizontal-track]" }, { name: "cards", selector: "[data-motion-horizontal-card]", multiple: true }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createHorizontalGallerySnaps)
+});
+var horizontalFeatureRail = /* @__PURE__ */ spec({
+  id: "horizontal-feature-rail",
+  selector: "[data-motion-horizontal-feature-rail]",
+  slots: [{ name: "track", selector: "[data-motion-horizontal-track]" }, { name: "cards", selector: "[data-motion-horizontal-card]", multiple: true }, { name: "labels", selector: "[data-motion-horizontal-label]", required: false, multiple: true }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createHorizontalFeatureRails)
+});
+var horizontalLogoReel = /* @__PURE__ */ spec({
+  id: "horizontal-logo-reel",
+  selector: "[data-motion-horizontal-logo-reel]",
+  slots: [{ name: "track", selector: "[data-motion-horizontal-track]" }],
+  triggers: [{ type: "scroll" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createHorizontalLogoReels)
+});
+var horizontalComparisonSlider = /* @__PURE__ */ spec({
+  id: "horizontal-comparison-slider",
+  selector: "[data-motion-comparison]",
+  slots: [{ name: "after", selector: "[data-motion-comparison-after]" }, { name: "range", selector: "[data-motion-comparison-range]" }],
+  triggers: [{ type: "pointer" }, { type: "focus" }],
+  dependencies: [],
+  setup: /* @__PURE__ */ setupFactory(createHorizontalComparisonSliders)
+});
+var mediaExpand = /* @__PURE__ */ spec({
+  id: "media-expand",
+  selector: "[data-motion-media-expand]",
+  slots: [{ name: "frame", selector: "[data-motion-media-expand-frame]" }, { name: "caption", selector: "[data-motion-media-expand-caption]", required: false }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createMediaExpansions)
+});
+var mediaClipReveal = /* @__PURE__ */ spec({
+  id: "media-clip-reveal",
+  selector: "[data-motion-media-clip]",
+  slots: [{ name: "frame", selector: "[data-motion-media-frame]", required: false }],
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createMediaClipReveals)
+});
+var mediaCurtainSplit = /* @__PURE__ */ spec({
+  id: "media-curtain-split",
+  selector: "[data-motion-media-curtain]",
+  slots: [{ name: "start", selector: "[data-motion-curtain-start]" }, { name: "end", selector: "[data-motion-curtain-end]" }],
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createMediaCurtainSplits)
+});
+var imageFocusPan = /* @__PURE__ */ spec({
+  id: "image-focus-pan",
+  selector: "[data-motion-image-focus-pan]",
+  slots: [{ name: "image", selector: "[data-motion-focus-image]", required: false }],
+  triggers: [{ type: "scroll" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createImageFocusPans)
+});
+var videoPosterPlay = /* @__PURE__ */ spec({
+  id: "video-poster-play",
+  selector: "[data-motion-video-poster]",
+  slots: [{ name: "trigger", selector: "[data-motion-video-trigger]" }, { name: "video", selector: "[data-motion-video-element]" }],
+  triggers: [{ type: "click" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createVideoPosterPlayers)
+});
+var hoverMediaSwitch = /* @__PURE__ */ spec({
+  id: "hover-media-switch",
+  selector: "[data-motion-hover-group]",
+  slots: [{ name: "triggers", selector: "[data-motion-hover-key]", multiple: true }, { name: "media", selector: "[data-motion-hover-media]", multiple: true }],
+  triggers: [{ type: "hover" }, { type: "focus" }],
+  performance: "low",
+  dependencies: [],
+  setup: /* @__PURE__ */ setupFactory(createHoverMedia)
+});
+var expandPanels = /* @__PURE__ */ spec({
+  id: "expand-panels",
+  selector: "[data-motion-expand-group]",
+  slots: [{ name: "panels", selector: "[data-motion-expand-panel]", multiple: true }],
+  triggers: [{ type: "hover" }, { type: "focus" }],
+  performance: "low",
+  dependencies: [],
+  setup: /* @__PURE__ */ setupFactory(createExpandPanels)
+});
+var hoverLift = /* @__PURE__ */ spec({
+  id: "hover-lift",
+  selector: "[data-motion-hover-lift]",
+  triggers: [{ type: "hover" }, { type: "focus" }],
+  performance: "low",
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createHoverLifts)
+});
+var magneticAction = /* @__PURE__ */ spec({
+  id: "magnetic-action",
+  selector: "[data-motion-magnetic]",
+  slots: [{ name: "action", selector: "[data-motion-magnetic-action]", required: false }],
+  triggers: [{ type: "pointer" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createMagneticActions)
+});
+var pointerSpotlight = /* @__PURE__ */ spec({
+  id: "pointer-spotlight",
+  selector: "[data-motion-pointer-spotlight]",
+  slots: [{ name: "spotlight", selector: "[data-motion-spotlight]" }],
+  triggers: [{ type: "pointer" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createPointerSpotlights)
+});
+var accessibleMenu = /* @__PURE__ */ spec({
+  id: "accessible-menu",
+  selector: "[data-motion-menu]",
+  slots: [{ name: "trigger", selector: "[data-motion-menu-trigger]" }, { name: "panel", selector: "[data-motion-menu-panel]" }, { name: "items", selector: "[data-motion-menu-item]", multiple: true }],
+  triggers: [{ type: "click" }, { type: "focus" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createMenus)
+});
+var dialogOverlay = /* @__PURE__ */ spec({
+  id: "dialog-overlay",
+  selector: "[data-motion-dialog-overlay]",
+  slots: [{ name: "trigger", selector: "[data-motion-overlay-trigger]", required: false }, { name: "dialog", selector: "[data-motion-overlay-dialog]" }],
+  triggers: [{ type: "click" }, { type: "focus" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createDialogOverlays)
+});
+var navActiveIndicator = /* @__PURE__ */ spec({
+  id: "nav-active-indicator",
+  selector: "[data-motion-nav-indicator]",
+  slots: [{ name: "items", selector: "[data-motion-nav-item]", multiple: true }, { name: "indicator", selector: "[data-motion-nav-active-indicator]" }],
+  triggers: [{ type: "focus" }, { type: "pointer" }, { type: "click" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createNavActiveIndicators)
+});
+var accordionDisclosure = /* @__PURE__ */ spec({
+  id: "accordion-disclosure",
+  selector: "[data-motion-accordion-motion]",
+  slots: [{ name: "panel", selector: "[data-motion-accordion-panel]" }],
+  triggers: [{ type: "click" }],
+  performance: "low",
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createAccordionDisclosures)
+});
+var commandPalette = /* @__PURE__ */ spec({
+  id: "command-palette",
+  selector: "[data-motion-command-palette]",
+  slots: [{ name: "dialog", selector: "[data-motion-overlay-dialog]" }, { name: "input", selector: "[data-motion-command-input]" }],
+  triggers: [{ type: "click" }, { type: "focus" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createCommandPalettes)
+});
+var marquee = /* @__PURE__ */ spec({
+  id: "marquee",
+  selector: "[data-motion-marquee]",
+  slots: [{ name: "track", selector: "[data-motion-marquee-track]" }],
+  triggers: [{ type: "load" }, { type: "viewport" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createMarquees)
+});
+var counterValue = /* @__PURE__ */ spec({
+  id: "counter-value",
+  selector: "[data-motion-counter]",
+  slots: [{ name: "value", selector: "[data-motion-counter-value]", required: false }],
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createValueCounters)
+});
+var progressRing = /* @__PURE__ */ spec({
+  id: "progress-ring",
+  selector: "[data-motion-progress-ring]",
+  slots: [{ name: "ring", selector: "[data-motion-progress-ring-value]" }, { name: "label", selector: "[data-motion-progress-ring-label]", required: false }],
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "DrawSVGPlugin", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createProgressRings)
+});
+var ambientFloat = /* @__PURE__ */ spec({
+  id: "ambient-float",
+  selector: "[data-motion-ambient-float]",
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createAmbientFloats)
+});
+var loopingLogoBelt = /* @__PURE__ */ spec({
+  id: "looping-logo-belt",
+  selector: "[data-motion-logo-belt]",
+  slots: [{ name: "track", selector: "[data-motion-logo-belt-track]" }],
+  triggers: [{ type: "load" }, { type: "viewport" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createLoopingLogoBelts)
+});
+var flipListReorder = /* @__PURE__ */ spec({
+  id: "flip-list-reorder",
+  selector: "[data-motion-flip-list]",
+  slots: [{ name: "items", selector: "[data-motion-flip-item]", multiple: true }],
+  triggers: [{ type: "state" }],
+  performance: "high",
+  dependencies: ["gsap", "Flip"],
+  setup: /* @__PURE__ */ setupFactory(createFlipListReorders)
+});
+var flipCardToDetail = /* @__PURE__ */ spec({
+  id: "flip-card-to-detail",
+  selector: "[data-motion-flip-card]",
+  slots: [{ name: "trigger", selector: "[data-motion-flip-card-trigger]" }, { name: "detail", selector: "[data-motion-flip-card-detail]" }],
+  triggers: [{ type: "click" }],
+  performance: "high",
+  dependencies: ["gsap", "Flip"],
+  setup: /* @__PURE__ */ setupFactory(createFlipCardDetails)
+});
+var flipFilterGrid = /* @__PURE__ */ spec({
+  id: "flip-filter-grid",
+  selector: "[data-motion-flip-filter]",
+  slots: [{ name: "controls", selector: "[data-motion-filter-control]", multiple: true }, { name: "items", selector: "[data-motion-filter-item]", multiple: true }],
+  triggers: [{ type: "click" }],
+  performance: "high",
+  dependencies: ["gsap", "Flip"],
+  setup: /* @__PURE__ */ setupFactory(createFlipFilterGrids)
+});
+var flipNavIndicator = /* @__PURE__ */ spec({
+  id: "flip-nav-indicator",
+  selector: "[data-motion-flip-nav]",
+  slots: [{ name: "items", selector: "[data-motion-flip-nav-item]", multiple: true }, { name: "indicator", selector: "[data-motion-flip-nav-indicator]" }],
+  triggers: [{ type: "focus" }, { type: "click" }],
+  dependencies: ["gsap", "Flip"],
+  setup: /* @__PURE__ */ setupFactory(createFlipNavIndicators)
+});
+var layoutAccordionGrid = /* @__PURE__ */ spec({
+  id: "layout-accordion-grid",
+  selector: "[data-motion-layout-accordion-grid]",
+  slots: [{ name: "items", selector: "[data-motion-layout-item]", multiple: true }, { name: "triggers", selector: "[data-motion-layout-trigger]", multiple: true }],
+  triggers: [{ type: "click" }],
+  performance: "high",
+  dependencies: ["gsap", "Flip"],
+  setup: /* @__PURE__ */ setupFactory(createLayoutAccordionGrids)
+});
+var svgLineDraw = /* @__PURE__ */ spec({
+  id: "svg-line-draw",
+  selector: "[data-motion-svg-line-draw]",
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "DrawSVGPlugin", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createSvgLineDraws)
+});
+var svgPathMorph = /* @__PURE__ */ spec({
+  id: "svg-path-morph",
+  selector: "[data-motion-svg-morph]",
+  slots: [{ name: "source", selector: "[data-motion-svg-morph-source]" }, { name: "target", selector: "[data-motion-svg-morph-target]" }, { name: "trigger", selector: "[data-motion-svg-trigger]" }],
+  triggers: [{ type: "click" }],
+  dependencies: ["gsap", "MorphSVGPlugin"],
+  setup: /* @__PURE__ */ setupFactory(createSvgPathMorphs)
+});
+var svgIconState = /* @__PURE__ */ spec({
+  id: "svg-icon-state",
+  selector: "[data-motion-svg-icon-state]",
+  slots: [{ name: "source", selector: "[data-motion-svg-icon-source]" }, { name: "target", selector: "[data-motion-svg-icon-target]" }, { name: "trigger", selector: "[data-motion-svg-trigger]" }],
+  triggers: [{ type: "click" }],
+  dependencies: ["gsap", "MorphSVGPlugin"],
+  setup: /* @__PURE__ */ setupFactory(createSvgIconStates)
+});
+var svgOrbit = /* @__PURE__ */ spec({
+  id: "svg-orbit",
+  selector: "[data-motion-svg-orbit]",
+  slots: [{ name: "subject", selector: "[data-motion-svg-orbit-subject]" }, { name: "path", selector: "[data-motion-svg-orbit-path]" }],
+  triggers: [{ type: "scroll" }],
+  performance: "high",
+  dependencies: ["gsap", "MotionPathPlugin", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createSvgOrbits)
+});
+var svgSignatureReveal = /* @__PURE__ */ spec({
+  id: "svg-signature-reveal",
+  selector: "[data-motion-svg-signature]",
+  triggers: [{ type: "viewport" }],
+  dependencies: ["gsap", "DrawSVGPlugin", "ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createSvgSignatureReveals)
+});
+var pageLoadHero = /* @__PURE__ */ spec({
+  id: "page-load-hero",
+  selector: "[data-motion-page-load-hero]",
+  slots: [{ name: "items", selector: "[data-motion-page-load-item]", multiple: true }],
+  triggers: [{ type: "load" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createPageLoadHeroes)
+});
+var pageLoadBrandMark = /* @__PURE__ */ spec({
+  id: "page-load-brand-mark",
+  selector: "[data-motion-page-load-brand]",
+  slots: [{ name: "mark", selector: "[data-motion-brand-mark]", required: false }],
+  triggers: [{ type: "load" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createPageLoadBrandMarks)
+});
+var routeFade = /* @__PURE__ */ spec({
+  id: "route-fade",
+  selector: "[data-motion-route-fade]",
+  slots: [{ name: "outgoing", selector: "[data-motion-route-outgoing]", required: false }, { name: "incoming", selector: "[data-motion-route-incoming]", required: false }],
+  triggers: [{ type: "route" }],
+  dependencies: ["gsap"],
+  setup: /* @__PURE__ */ setupFactory(createRouteFades)
+});
+var routeSharedMedia = /* @__PURE__ */ spec({
+  id: "route-shared-media",
+  selector: "[data-motion-route-shared-media]",
+  slots: [{ name: "media", selector: "[data-motion-shared-media]", multiple: true }],
+  triggers: [{ type: "route" }],
+  performance: "high",
+  dependencies: ["gsap", "Flip"],
+  setup: /* @__PURE__ */ setupFactory(createRouteSharedMedia)
+});
+var routeScrollRestore = /* @__PURE__ */ spec({
+  id: "route-scroll-restore",
+  selector: "[data-motion-route-scroll-restore]",
+  triggers: [{ type: "route" }],
+  dependencies: ["ScrollTrigger"],
+  setup: /* @__PURE__ */ setupFactory(createRouteScrollRestores)
+});
+var builtinMotionSpecs = /* @__PURE__ */ Object.freeze([
+  revealRise,
+  revealStaggerCascade,
+  revealDirectional,
+  revealScaleIn,
+  revealClipWipe,
+  splitLinesRise,
+  splitWordsCascade,
+  splitCharsShimmer,
+  typewriterAnnounce,
+  textHighlightSweep,
+  scrollParallax,
+  scrollExit,
+  scrollDrift,
+  scrollProgressMeter,
+  scrollDepthStack,
+  pinnedSteps,
+  pinnedStatement,
+  pinnedFounderStory,
+  pinnedChapterCrossfade,
+  pinnedProductExplainer,
+  horizontalGalleryScrub,
+  horizontalGallerySnap,
+  horizontalFeatureRail,
+  horizontalLogoReel,
+  horizontalComparisonSlider,
+  mediaExpand,
+  mediaClipReveal,
+  mediaCurtainSplit,
+  imageFocusPan,
+  videoPosterPlay,
+  hoverMediaSwitch,
+  expandPanels,
+  hoverLift,
+  magneticAction,
+  pointerSpotlight,
+  accessibleMenu,
+  dialogOverlay,
+  navActiveIndicator,
+  accordionDisclosure,
+  commandPalette,
+  marquee,
+  counterValue,
+  progressRing,
+  ambientFloat,
+  loopingLogoBelt,
+  flipListReorder,
+  flipCardToDetail,
+  flipFilterGrid,
+  flipNavIndicator,
+  layoutAccordionGrid,
+  svgLineDraw,
+  svgPathMorph,
+  svgIconState,
+  svgOrbit,
+  svgSignatureReveal,
+  pageLoadHero,
+  pageLoadBrandMark,
+  routeFade,
+  routeSharedMedia,
+  routeScrollRestore
+]);
+
+export {
+  defaults,
+  mergeOptions,
+  clampIndex,
+  setActiveState,
+  createExpandPanels,
+  createFounderScenes,
+  createHoverMedia,
+  createHoverLifts,
+  createMagneticActions,
+  createPointerSpotlights,
+  createHorizontalGalleryScrubs,
+  createHorizontalGallerySnaps,
+  createHorizontalFeatureRails,
+  createHorizontalLogoReels,
+  createHorizontalComparisonSliders,
+  createMarquees,
+  createValueCounters,
+  createProgressRings,
+  createAmbientFloats,
+  createLoopingLogoBelts,
+  createFlipListReorders,
+  createFlipCardDetails,
+  createFlipFilterGrids,
+  createFlipNavIndicators,
+  createLayoutAccordionGrids,
+  createMediaExpansions,
+  createMediaClipReveals,
+  createMediaCurtainSplits,
+  createImageFocusPans,
+  createVideoPosterPlayers,
+  createMenus,
+  createDialogOverlays,
+  createCommandPalettes,
+  createNavActiveIndicators,
+  createAccordionDisclosures,
+  createParallax,
+  createPinnedChapterCrossfades,
+  createPinnedProductExplainers,
+  createReveals,
+  createDirectionalReveals,
+  createScaleReveals,
+  createClipWipeReveals,
+  createScrollDrifts,
+  createScrollExits,
+  createScrollStatements,
+  createScrollSteps,
+  createScrollProgressMeters,
+  createScrollDepthStacks,
+  createSplitText,
+  createStaggers,
+  createPageLoadHeroes,
+  createPageLoadBrandMarks,
+  createRouteFades,
+  createRouteSharedMedia,
+  createRouteScrollRestores,
+  createSvgLineDraws,
+  createSvgPathMorphs,
+  createSvgIconStates,
+  createSvgOrbits,
+  createSvgSignatureReveals,
+  createCharacterShimmers,
+  createTypewriterAnnouncements,
+  createTextHighlightSweeps,
+  SHARED_REDUCED_MOTION,
+  revealRise,
+  revealStaggerCascade,
+  revealDirectional,
+  revealScaleIn,
+  revealClipWipe,
+  splitLinesRise,
+  splitWordsCascade,
+  splitCharsShimmer,
+  typewriterAnnounce,
+  textHighlightSweep,
+  scrollParallax,
+  scrollExit,
+  scrollDrift,
+  scrollProgressMeter,
+  scrollDepthStack,
+  pinnedSteps,
+  pinnedStatement,
+  pinnedFounderStory,
+  pinnedChapterCrossfade,
+  pinnedProductExplainer,
+  horizontalGalleryScrub,
+  horizontalGallerySnap,
+  horizontalFeatureRail,
+  horizontalLogoReel,
+  horizontalComparisonSlider,
+  mediaExpand,
+  mediaClipReveal,
+  mediaCurtainSplit,
+  imageFocusPan,
+  videoPosterPlay,
+  hoverMediaSwitch,
+  expandPanels,
+  hoverLift,
+  magneticAction,
+  pointerSpotlight,
+  accessibleMenu,
+  dialogOverlay,
+  navActiveIndicator,
+  accordionDisclosure,
+  commandPalette,
+  marquee,
+  counterValue,
+  progressRing,
+  ambientFloat,
+  loopingLogoBelt,
+  flipListReorder,
+  flipCardToDetail,
+  flipFilterGrid,
+  flipNavIndicator,
+  layoutAccordionGrid,
+  svgLineDraw,
+  svgPathMorph,
+  svgIconState,
+  svgOrbit,
+  svgSignatureReveal,
+  pageLoadHero,
+  pageLoadBrandMark,
+  routeFade,
+  routeSharedMedia,
+  routeScrollRestore,
+  builtinMotionSpecs
+};
+//# sourceMappingURL=chunk-JET2MYEG.js.map