@brandocms/jupiter 5.0.0-beta.1 → 5.0.0-beta.10

package/src/modules/Looper/index.js

@@ -77,9 +77,7 @@ function horizontalLoop(app, items, config) {
   let originalItemsWidth = 0 // Width of ONLY original items (for wrapping)
   let pixelsPerSecond = (config.speed || 1) * 100
   let animation = null
-  let position = motionValue(0) // Source of truth for position
-  let boundedPos = motionValue(0) // Bounded position (0 to originalItemsWidth)
-  let lastBoundedValue = 0 // Track last value to detect wraps
+  let position = motionValue(0) // Source of truth for position (raw, unbounded)
   let originalItemCount = 0 // Track count of ORIGINAL items (before clones)
   let maxScrollPosition = 0 // For non-looping: max scroll where last item is at right edge
 
@@ -96,6 +94,7 @@ function horizontalLoop(app, items, config) {
 
   // Drag state and cleanup handlers
   let dragState = {}
+  let isDragging = false  // Track if user is actively dragging (for wrap detection guard)
   let speedRampAnimation = null // Track speed ramp animation
   let inertiaAnimation = null // Track inertia animation
   let snapAnimation = null // Track snap animation
@@ -103,6 +102,10 @@ function horizontalLoop(app, items, config) {
   let positionUnsubscribe = null // Track position listener for cleanup
   let renderUnsubscribe = null // Track frame.render loop for cleanup
 
+  // Scroll direction tracking for wrap logic
+  let scrollDirection = 0 // -1 = backward, 0 = neutral, 1 = forward
+  let lastPositionForDirection = 0
+
   // Display elements for index/count
   let indexElements = []
   let countElements = []
@@ -163,24 +166,28 @@ function horizontalLoop(app, items, config) {
     // This prevents items from visibly moving to the back before they're off-screen
     const minRequiredWidth = containerWidth * 2.5 + maxItemWidth
 
-    // Only replicate if needed
-    if (totalWidth >= minRequiredWidth) {
-      return
-    }
-
     // Store original count to prevent exponential growth
     const originalItemCount = items.length
     const maxReplications = 10
     let count = 0
     let previousTotalWidth = totalWidth
 
-    while (totalWidth < minRequiredWidth && count < maxReplications) {
+    // Always create at least TWO sets of clones - needed for starting at first clone position
+    // Then continue until we have enough width for seamless looping
+    while ((count < 2 || totalWidth < minRequiredWidth) && count < maxReplications) {
       // Clone ONLY original items
       for (let i = 0; i < originalItemCount; i++) {
         const clone = items[i].cloneNode(true)
         clone.setAttribute('data-looper-clone', 'true')
         container.appendChild(clone)
         items.push(clone)
+
+        // Force-load cloned lazyload elements without revealing them
+        // Sources are swapped immediately (no flash on wrap), but data-ll-loaded
+        // is not set — the reveal happens after the wrapper fade-in animation
+        if (app?.lazyload?.forceLoad) {
+          app.lazyload.forceLoad(clone, { reveal: false })
+        }
       }
 
       // Force layout recalculation
@@ -332,83 +339,48 @@ function horizontalLoop(app, items, config) {
 
   /**
    * Check item positions and wrap when needed
-   * Container is animated DIRECTLY (not updated here!)
-   * This function only reads position to determine wrapping
-   * @param {number} pos - Current position value (can grow infinitely)
+   * Container uses RAW position - items wrap individually when far off-screen
+   * @param {number} rawPos - Current raw position value (unbounded)
    */
-  function updateItemPositions(pos) {
-    const containerElement = items[0].parentElement
-
-    if (!shouldLoop) {
-      // Non-looping: we'll handle this with direct animation
-      return
-    }
-
-    // Calculate bounded position for checking item wrap points
-    // Use same wrapping formula as frame.render to handle negative positions (reversed mode)
-    const boundedPos = ((pos % originalItemsWidth) + originalItemsWidth) % originalItemsWidth
+  function updateItemPositions(rawPos) {
+    if (!shouldLoop) return
 
     // Initialize wrap offsets cache if needed
     if (itemWrapOffsets.length === 0) {
       itemWrapOffsets = new Array(items.length).fill(0)
     }
 
-    // TICKER PATTERN: ONLY move ORIGINAL items to the back, NEVER touch clones!
-    // This massively reduces DOM manipulation and style recalculation
-    items.forEach((item, i) => {
-      // Skip clones - they stay in natural flow! (use cached value for performance)
-      if (isCloneCache[i]) {
-        return
-      }
+    // Items wrap by the full cycle distance (totalWidth) to maintain relative positions
+    // This keeps all items within viewing distance as position grows/shrinks
+    const cycleDistance = totalWidth
 
-      // Calculate where this ORIGINAL item is on screen (relative to bounded container)
-      const itemLeft = offsetLefts[i] - boundedPos
-
-      // Original items only ever have -totalWidth, 0, or +totalWidth offset
-      // This positions them AFTER all clones (not just after wrapping area)
-      let newOffset = 0
-
-      // Ticker boundary pattern: Check if item should be at the END or at the START
-      // When container cycles (boundedPos wraps from ~originalItemsWidth to ~0),
-      // items with large offsets get reset back to 0
-
-      // Wrap distance includes the trailing gap for seamless cycling
-      const wrapOffset = totalWidth + gap
-
-      // Check if we're in the "reset zone" near wrap boundaries
-      const nearForwardWrap = boundedPos > originalItemsWidth - gap
-      const nearReverseWrap = boundedPos < gap
-
-      // RESET: When in reset zone, reset items and SKIP wrap checks to avoid fighting
-      if (nearForwardWrap && itemWrapOffsets[i] === wrapOffset) {
-        // Container about to wrap (forward), reset items at END back to START
-        newOffset = 0
-      } else if (nearReverseWrap && itemWrapOffsets[i] === -wrapOffset) {
-        // Container about to wrap (reverse), reset items at START back to END
-        newOffset = 0
-      } else if (nearForwardWrap || nearReverseWrap) {
-        // In reset zone but item doesn't need reset → keep current offset
-        newOffset = itemWrapOffsets[i]
-      } else if (itemLeft < -(widths[i] + containerWidth * 0.5)) {
-        // Item exited LEFT edge
-        // Forward drag (low boundedPos): wrap to END
-        // Backward drag (high boundedPos): don't wrap, clones fill in from right
-        newOffset = boundedPos < originalItemsWidth / 2 ? wrapOffset : 0
-      } else if (itemLeft > containerWidth + containerWidth * 0.5) {
-        // Item exited RIGHT edge
-        // This shouldn't happen much, but handle it
-        newOffset = 0
-      } else {
-        // Keep current offset
-        newOffset = itemWrapOffsets[i]
+    // Wrap threshold: when an item is more than half a cycle from view, wrap it
+    const wrapThreshold = cycleDistance / 2
+
+    for (let i = 0; i < items.length; i++) {
+      // Calculate this item's effective position (DOM position + wrap offset)
+      const effectivePos = offsetLefts[i] + itemWrapOffsets[i]
+
+      // Distance from current view position
+      // Positive = item is ahead (to the right), Negative = item is behind (to the left)
+      const distanceFromView = effectivePos - rawPos
+
+      let newOffset = itemWrapOffsets[i]
+
+      if (distanceFromView < -wrapThreshold) {
+        // Item is too far left (behind), wrap it forward (to the right)
+        newOffset = itemWrapOffsets[i] + cycleDistance
+      } else if (distanceFromView > wrapThreshold + containerWidth) {
+        // Item is too far right (ahead), wrap it backward (to the left)
+        newOffset = itemWrapOffsets[i] - cycleDistance
       }
 
-      // ONLY update transform if the offset has changed!
+      // Only update DOM if offset changed
       if (newOffset !== itemWrapOffsets[i]) {
-        item.style.transform = newOffset !== 0 ? `translateX(${newOffset}px)` : 'none'
+        items[i].style.transform = newOffset !== 0 ? `translateX(${newOffset}px)` : 'none'
         itemWrapOffsets[i] = newOffset
       }
-    })
+    }
   }
 
   /**
@@ -416,32 +388,58 @@ function horizontalLoop(app, items, config) {
    * @param {boolean} deep - Whether to rebuild animation (on resize)
    */
   function refresh(deep = false) {
-    // Save progress to preserve position
-    const progress = animation ? animation.time / animation.duration : 0
-    const currentPos = position.get()
-
     // Pause animation if running
     const wasPlaying = animation && animation.speed !== 0
     if (animation) {
       animation.pause()
     }
 
+    if (deep && shouldLoop) {
+      // DEEP REFRESH: Reset everything for new dimensions
+      // Clear all item wrap offsets and transforms
+      for (let i = 0; i < items.length; i++) {
+        items[i].style.transform = 'none'
+        if (itemWrapOffsets[i] !== undefined) {
+          itemWrapOffsets[i] = 0
+        }
+      }
+      itemWrapOffsets = []
+    }
+
     // Remeasure everything
     populateWidths()
 
     if (deep) {
       // Check if we need to replicate more items
-      const containerWidth = container.offsetWidth
+      const currentContainerWidth = container.offsetWidth
       const currentTotalWidth = getTotalWidthOfItems()
 
       // Use same 2.5x buffer as replication logic
-      if (shouldLoop && currentTotalWidth < containerWidth * 2.5) {
+      if (shouldLoop && currentTotalWidth < currentContainerWidth * 2.5) {
         replicateItemsIfNeeded()
+        // Re-cache clone status for any new items
+        isCloneCache = items.map((item, i) => i >= originalItemCount)
         populateWidths()
       }
 
       populateSnapTimes()
 
+      // Reset position to start at first clone (like initial state)
+      if (shouldLoop && !config.centerSlide) {
+        position.set(originalItemsWidth)
+        lastPositionForDirection = originalItemsWidth
+        items[0].parentElement.style.transform = `translateX(${-originalItemsWidth}px)`
+      } else if (shouldLoop && config.centerSlide) {
+        // For center mode, go to middle slide
+        const middleIndex = Math.floor(originalItemCount / 2)
+        const targetTime = times[middleIndex]
+        const initialPos = targetTime * pixelsPerSecond
+        position.set(initialPos)
+        lastPositionForDirection = initialPos
+        items[0].parentElement.style.transform = `translateX(${-initialPos}px)`
+        curIndex = middleIndex
+      }
+
       // Recreate animation with new measurements
       if (shouldLoop && config.crawl) {
         // Stop old animation
@@ -449,7 +447,7 @@ function horizontalLoop(app, items, config) {
           animation.stop()
         }
 
-        // Use startLoopAnimation for bounded position (no repeat: Infinity!)
+        // Recreate loop animation with new measurements
         animation = startLoopAnimation()
 
         // Restore playback state
@@ -472,19 +470,20 @@ function horizontalLoop(app, items, config) {
         })
 
         if (wasPlaying) {
-          animation.time = progress * animation.duration
           animation.play()
         } else {
           animation.pause()
         }
       }
+
+      // Update index display
+      updateIndexDisplay()
     } else {
       // Light refresh - just update measurements
       populateSnapTimes()
+      // Update positions based on current scroll
+      updateItemPositions(position.get())
     }
-
-    // Update positions based on current scroll
-    updateItemPositions(currentPos)
   }
 
   /**
@@ -499,6 +498,46 @@ function horizontalLoop(app, items, config) {
     })
   }
 
+  /**
+   * Create and start the crawl animation loop
+   * Animates the position motionValue (frame.render loop applies to DOM)
+   */
+  function startLoopAnimation() {
+    if (!shouldLoop || !config.crawl) return null
+
+    const duration = originalItemsWidth / pixelsPerSecond
+    const currentPos = position.get()
+    // Reversed: crawl backwards (right-to-left), Normal: crawl forward (left-to-right)
+    const target = config.reversed
+      ? currentPos - originalItemsWidth
+      : currentPos + originalItemsWidth
+
+    // Animate the position motionValue
+    // frame.render loop will apply raw position to container and wrap items
+    animation = animate(position, target, {
+      duration,
+      repeat: Infinity,
+      ease: 'linear',
+    })
+
+    return animation
+  }
+
+  /**
+   * Stop the frame.render loop and cleanup listeners
+   * Called from init() and destroy()
+   */
+  function stopRenderLoop() {
+    if (renderUnsubscribe) {
+      // Unsubscribe from motionValue listener
+      if (renderUnsubscribe.positionUnsubscribe) {
+        renderUnsubscribe.positionUnsubscribe()
+      }
+      cancelFrame(renderUnsubscribe)
+      renderUnsubscribe = null
+    }
+  }
+
   /**
    * Initialize the loop animation
    */
@@ -519,89 +558,45 @@ function horizontalLoop(app, items, config) {
     // Set initial container position
     const containerElement = items[0].parentElement
     containerElement.style.willChange = 'transform'
-    containerElement.style.transform = 'translateX(0px)'
 
-    // Set up RAF loop to check item positions for wrapping
-    // Frame.render loop to apply bounded position to DOM
+    // For looping (non-center mode): start viewing first CLONE, not originals
+    // This positions originals OFF-SCREEN LEFT so backward scroll reveals them smoothly
+    if (shouldLoop && !config.centerSlide) {
+      position.set(originalItemsWidth)
+      lastPositionForDirection = originalItemsWidth
+      containerElement.style.transform = `translateX(${-originalItemsWidth}px)`
+    } else {
+      containerElement.style.transform = 'translateX(0px)'
+    }
+
+    // Set up RAF loop to update container position and wrap items
+    // Uses RAW position (no modulo) for container transform
     // This is Motion's optimized render loop - prevents layout thrashing
     function startRenderLoop() {
       if (renderUnsubscribe) return // Already running
 
       const containerElement = items[0].parentElement
 
-      // Set up boundedPos motionValue to automatically sync with position
-      // This calculates the bounded position (0 to originalItemsWidth)
+      // Track scroll direction for wrap logic
       const positionUnsubscribe = position.on('change', latest => {
-        const bounded = ((latest % originalItemsWidth) + originalItemsWidth) % originalItemsWidth
-        boundedPos.set(bounded)
-      })
-
-      // Detect when boundedPos wraps (makes large jump) and reset all items
-      // This prevents stuck items during fast drags in either direction
-      const boundedPosUnsubscribe = boundedPos.on('change', latest => {
-        const delta = Math.abs(latest - lastBoundedValue)
-
-        // If boundedPos jumped by more than 40% of the width, it wrapped
-        // Using 40% instead of 50% to catch edge cases
-        const didWrap = delta > originalItemsWidth * 0.4
-
-        if (didWrap) {
-          const direction =
-            latest > lastBoundedValue ? 'backward (drag right)' : 'forward (drag left)'
-
-          // Count how many items have non-zero offset before reset
-          const itemsWithOffset = items.filter(
-            (item, i) => !isCloneCache[i] && itemWrapOffsets[i] !== 0
-          ).length
-
-          // Reset ALL original items to 0 (both positive and negative offsets)
-          items.forEach((item, i) => {
-            if (!isCloneCache[i] && itemWrapOffsets[i] !== 0) {
-              item.style.transform = 'none'
-              itemWrapOffsets[i] = 0
-            }
-          })
-
-          // CRITICAL: Sync unbounded position with bounded position to prevent
-          // inertia calculation bugs when dragging RIGHT across boundaries
-          // BUT only do this when NOT animating snap or nav, otherwise it interferes
-          if (!snapAnimation && !navAnimation) {
-            position.set(latest)
-          } else {
-          }
+        const delta = latest - lastPositionForDirection
+        if (Math.abs(delta) > 1) {
+          scrollDirection = delta > 0 ? 1 : -1
         }
-
-        lastBoundedValue = latest
+        lastPositionForDirection = latest
       })
 
       renderUnsubscribe = frame.render(() => {
-        // Read bounded position from motionValue
-        const currentBoundedPos = boundedPos.get()
-
-        // Apply bounded transform to container
-        containerElement.style.transform = `translateX(${-currentBoundedPos}px)`
+        // Use RAW position (no bounded) for container
+        const currentPos = position.get()
+        containerElement.style.transform = `translateX(${-currentPos}px)`
 
-        // Wrap items based on bounded position
-        updateItemPositions(currentBoundedPos)
+        // Wrap items based on raw position
+        updateItemPositions(currentPos)
       }, true) // true = keep alive
 
-      // Store unsubscribe functions for cleanup
+      // Store unsubscribe function for cleanup
       renderUnsubscribe.positionUnsubscribe = positionUnsubscribe
-      renderUnsubscribe.boundedPosUnsubscribe = boundedPosUnsubscribe
-    }
-
-    function stopRenderLoop() {
-      if (renderUnsubscribe) {
-        // Unsubscribe from motionValue listeners
-        if (renderUnsubscribe.positionUnsubscribe) {
-          renderUnsubscribe.positionUnsubscribe()
-        }
-        if (renderUnsubscribe.boundedPosUnsubscribe) {
-          renderUnsubscribe.boundedPosUnsubscribe()
-        }
-        cancelFrame(renderUnsubscribe)
-        renderUnsubscribe = null
-      }
     }
 
     // Start the frame.render loop
@@ -615,29 +610,6 @@ function horizontalLoop(app, items, config) {
       })
     }
 
-    // Function to create and start the animation loop
-    // Animates the position motionValue (frame.render loop applies to DOM)
-    function startLoopAnimation() {
-      if (!shouldLoop || !config.crawl) return null
-
-      const duration = originalItemsWidth / pixelsPerSecond
-      const currentPos = position.get()
-      // Reversed: crawl backwards (right-to-left), Normal: crawl forward (left-to-right)
-      const target = config.reversed
-        ? currentPos - originalItemsWidth
-        : currentPos + originalItemsWidth
-
-      // Animate the position motionValue
-      // frame.render loop will apply bounded position to DOM
-      animation = animate(position, target, {
-        duration,
-        repeat: Infinity,
-        ease: 'linear',
-      })
-
-      return animation
-    }
-
     // Create animation by animating the position motionValue
     if (shouldLoop && config.crawl) {
       const duration = totalWidth / pixelsPerSecond
@@ -712,7 +684,7 @@ function horizontalLoop(app, items, config) {
         // Update display in real-time as position changes
         let lastDisplayedIndex = -1
         const updateIndexOnChange = () => {
-          // Find closest slide to current bounded position
+          // Find closest slide to current position
           const closest = closestIndex(false)
 
           // Only update DOM if index changed (avoid thrashing)
@@ -725,12 +697,8 @@ function horizontalLoop(app, items, config) {
           }
         }
 
-        // For looping, use boundedPos; for non-looping, use position directly
-        if (shouldLoop) {
-          boundedPos.on('change', updateIndexOnChange)
-        } else {
-          position.on('change', updateIndexOnChange)
-        }
+        // Update index display whenever position changes (closestIndex normalizes internally)
+        position.on('change', updateIndexOnChange)
       }
     }
 
@@ -774,7 +742,7 @@ function horizontalLoop(app, items, config) {
    * Replaces GSAP Draggable with optimized pointer events
    */
   function setupDrag() {
-    let isDragging = false
+    // isDragging is now module-level so wrap detection can see it
     let startX = 0
     let startPosition = 0
     let velocityTracker = [] // Track recent movements for velocity calculation
@@ -900,9 +868,9 @@ function horizontalLoop(app, items, config) {
       const newPosition = startPosition + deltaX
 
       // Update position motionValue
-      // frame.render loop will apply bounded transform to DOM
+      // frame.render loop applies raw position to container
       if (shouldLoop) {
-        // For looping, allow unbounded position (frame.render will bound it)
+        // For looping, position grows freely - items wrap as groups
         position.set(newPosition)
       } else {
         // For non-looping, clamp position to maxScrollPosition (last item at right edge)
@@ -1136,7 +1104,7 @@ function horizontalLoop(app, items, config) {
           snapAnimation = null
           // Update display to reflect landed position
           updateIndexDisplay()
-          if (config.crawl && animation) {
+          if (config.crawl) {
             resumeCrawl()
           }
         })
@@ -1165,7 +1133,8 @@ function horizontalLoop(app, items, config) {
       const currentPos = position.get()
 
       // Calculate position within current cycle (using originalItemsWidth)
-      const cyclePos = currentPos % originalItemsWidth
+      // Use proper modulo for negative positions (dragging right/backward)
+      const cyclePos = ((currentPos % originalItemsWidth) + originalItemsWidth) % originalItemsWidth
       const remainingDist = originalItemsWidth - cyclePos
       const remainingDuration = remainingDist / pixelsPerSecond
 
@@ -1490,13 +1459,18 @@ function horizontalLoop(app, items, config) {
       closestIndex(true)
       let nextIndex = curIndex + 1
 
-      // Non-looping: reset to start when reaching the end
+      // Non-looping: clamp at boundaries
       if (!shouldLoop) {
         const currentPos = position.get()
         const atEnd = currentPos >= maxScrollPosition - 1
 
         if (nextIndex >= originalItemCount || atEnd) {
-          nextIndex = 0
+          // Autoplay resets to start, user navigation clamps
+          if (options.autoplay) {
+            nextIndex = 0
+          } else {
+            return // Clamp - do nothing at boundary
+          }
         }
       }
 
@@ -1512,9 +1486,14 @@ function horizontalLoop(app, items, config) {
       closestIndex(true)
       let prevIndex = curIndex - 1
 
-      // Non-looping: reset to end when at the start
+      // Non-looping: clamp at boundaries
       if (!shouldLoop && prevIndex < 0) {
-        prevIndex = originalItemCount - 1
+        // Autoplay resets to end, user navigation clamps
+        if (options.autoplay) {
+          prevIndex = originalItemCount - 1
+        } else {
+          return // Clamp - do nothing at boundary
+        }
       }
 
       return toIndex(prevIndex, vars)
@@ -1717,8 +1696,29 @@ export default class Looper {
         })
       }
 
-      // Fade in the WRAPPER (not the outer element!)
-      if (wrapper) {
+      // Reveal lazyload images: immediately reveal off-screen items (no visible transition),
+      // defer reveal of viewport items until after wrapper fade-in for a nice per-image fade
+      if (this.app?.lazyload && wrapper) {
+        const wrapperRect = wrapper.getBoundingClientRect()
+        const pictures = Dom.all(wrapper, '[data-ll-srcset]')
+        const viewportPictures = []
+
+        pictures.forEach(picture => {
+          const rect = picture.getBoundingClientRect()
+          const inViewport = rect.right > wrapperRect.left && rect.left < wrapperRect.right
+          if (inViewport) {
+            viewportPictures.push(picture)
+          } else {
+            this.app.lazyload.revealPicture(picture)
+          }
+        })
+
+        // Fade in the WRAPPER (not the outer element!)
+        animate(wrapper, { opacity: 1 }, { duration: 0.5, delay: 0.5, ease: 'easeOut' })
+          .then(() => {
+            viewportPictures.forEach(picture => this.app.lazyload.revealPicture(picture))
+          })
+      } else if (wrapper) {
         animate(wrapper, { opacity: 1 }, { duration: 0.5, delay: 0.5, ease: 'easeOut' })
       }
 

package/src/modules/StickyHeader/index.js

@@ -81,7 +81,7 @@ import { set } from '../../utils/motion-helpers'
 const DEFAULT_EVENTS = {
   onPin: (h) => {
     animate(h.el, {
-      yPercent: '0'
+      y: '0%'
     }, {
       duration: 0.35,
       ease: 'easeOut'
@@ -91,7 +91,7 @@ const DEFAULT_EVENTS = {
   onUnpin: (h) => {
     h._hiding = true
     animate(h.el, {
-      yPercent: '-100'
+      y: '-100%'
     }, {
       duration: 0.25,
       ease: 'easeIn'
@@ -158,14 +158,14 @@ const DEFAULT_OPTIONS = {
     canvas: window,
     intersects: null,
     beforeEnter: (h) => {
-      set(h.el, { yPercent: -100 })
+      set(h.el, { y: '-100%' })
       set(h.lis, { opacity: 0 })
     },
 
     enter: (h) => {
       // Header slides down
       animate(h.el, {
-        yPercent: 0
+        y: '0%'
       }, {
         duration: 1,
         delay: h.opts.enterDelay,

package/src/utils/motion-helpers.js

@@ -33,6 +33,8 @@ export function set(target, values) {
         transformProps.push(`translateX(${typeof value === 'number' ? value + 'px' : value})`)
       } else if (key === 'y') {
         transformProps.push(`translateY(${typeof value === 'number' ? value + 'px' : value})`)
+      } else if (key === 'yPercent') {
+        transformProps.push(`translateY(${value}%)`)
       } else if (key === 'scale') {
         transformProps.push(`scale(${value})`)
       } else if (key === 'scaleX') {

package/types/index.d.ts

@@ -3,4 +3,4 @@ import imagesAreLoaded from './utils/imagesAreLoaded';
 import loadScript from './utils/loadScript';
 import prefersReducedMotion from './utils/prefersReducedMotion';
 import rafCallback from './utils/rafCallback';
-export { Application, Breakpoints, Cookies, CoverOverlay, Dataloader, Dom, DoubleHeader, Draggable, Dropdown, EqualHeightElements, EqualHeightImages, Events, FixedHeader, FooterReveal, Parallax, HeroSlider, HeroVideo, Lazyload, Lightbox, Links, Looper, Marquee, MobileMenu, Moonwalk, Popover, Popup, ScrollSpy, StackedBoxes, StickyHeader, Toggler, Typography, imageIsLoaded, imagesAreLoaded, loadScript, prefersReducedMotion, rafCallback, _defaultsDeep, gsap, CSSPlugin, ScrollToPlugin, ScrollTrigger, SplitText, InertiaPlugin };
+export { Application, Breakpoints, Cookies, CoverOverlay, Dataloader, Dom, DoubleHeader, Dropdown, EqualHeightElements, EqualHeightImages, Events, FixedHeader, FooterReveal, Parallax, HeroSlider, HeroVideo, Lazyload, Lightbox, Links, Looper, Marquee, MobileMenu, Moonwalk, Popover, Popup, ScrollSpy, StackedBoxes, StickyHeader, Toggler, Typography, imageIsLoaded, imagesAreLoaded, loadScript, prefersReducedMotion, rafCallback, _defaultsDeep, animate, scroll, stagger, motionValue };