lenis 1.3.19 → 1.3.20-dev.0

package/dist/lenis.js

@@ -1,1132 +1,1030 @@
-// package.json
-var version = "1.3.19";
+(function() {
 
-// packages/core/src/maths.ts
-function clamp(min, input, max) {
-  return Math.max(min, Math.min(input, max));
-}
-function lerp(x, y, t) {
-  return (1 - t) * x + t * y;
-}
-function damp(x, y, lambda, deltaTime) {
-  return lerp(x, y, 1 - Math.exp(-lambda * deltaTime));
-}
-function modulo(n, d) {
-  return (n % d + d) % d;
-}
 
-// packages/core/src/animate.ts
-var Animate = class {
-  isRunning = false;
-  value = 0;
-  from = 0;
-  to = 0;
-  currentTime = 0;
-  // These are instanciated in the fromTo method
-  lerp;
-  duration;
-  easing;
-  onUpdate;
-  /**
-   * Advance the animation by the given delta time
-   *
-   * @param deltaTime - The time in seconds to advance the animation
-   */
-  advance(deltaTime) {
-    if (!this.isRunning) return;
-    let completed = false;
-    if (this.duration && this.easing) {
-      this.currentTime += deltaTime;
-      const linearProgress = clamp(0, this.currentTime / this.duration, 1);
-      completed = linearProgress >= 1;
-      const easedProgress = completed ? 1 : this.easing(linearProgress);
-      this.value = this.from + (this.to - this.from) * easedProgress;
-    } else if (this.lerp) {
-      this.value = damp(this.value, this.to, this.lerp * 60, deltaTime);
-      if (Math.round(this.value) === this.to) {
-        this.value = this.to;
-        completed = true;
-      }
-    } else {
-      this.value = this.to;
-      completed = true;
-    }
-    if (completed) {
-      this.stop();
-    }
-    this.onUpdate?.(this.value, completed);
-  }
-  /** Stop the animation */
-  stop() {
-    this.isRunning = false;
-  }
-  /**
-   * Set up the animation from a starting value to an ending value
-   * with optional parameters for lerping, duration, easing, and onUpdate callback
-   *
-   * @param from - The starting value
-   * @param to - The ending value
-   * @param options - Options for the animation
-   */
-  fromTo(from, to, { lerp: lerp2, duration, easing, onStart, onUpdate }) {
-    this.from = this.value = from;
-    this.to = to;
-    this.lerp = lerp2;
-    this.duration = duration;
-    this.easing = easing;
-    this.currentTime = 0;
-    this.isRunning = true;
-    onStart?.();
-    this.onUpdate = onUpdate;
-  }
-};
+//#region package.json
+	var version = "1.3.20-dev.0";
 
-// packages/core/src/debounce.ts
-function debounce(callback, delay) {
-  let timer;
-  return function(...args) {
-    clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = void 0;
-      callback.apply(this, args);
-    }, delay);
-  };
-}
+//#endregion
+//#region packages/core/src/maths.ts
+/**
+	* Clamp a value between a minimum and maximum value
+	*
+	* @param min Minimum value
+	* @param input Value to clamp
+	* @param max Maximum value
+	* @returns Clamped value
+	*/
+	function clamp(min, input, max) {
+		return Math.max(min, Math.min(input, max));
+	}
+	/**
+	*  Linearly interpolate between two values using an amount (0 <= t <= 1)
+	*
+	* @param x First value
+	* @param y Second value
+	* @param t Amount to interpolate (0 <= t <= 1)
+	* @returns Interpolated value
+	*/
+	function lerp(x, y, t) {
+		return (1 - t) * x + t * y;
+	}
+	/**
+	* Damp a value over time using a damping factor
+	* {@link http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/}
+	*
+	* @param x Initial value
+	* @param y Target value
+	* @param lambda Damping factor
+	* @param dt Time elapsed since the last update
+	* @returns Damped value
+	*/
+	function damp(x, y, lambda, deltaTime) {
+		return lerp(x, y, 1 - Math.exp(-lambda * deltaTime));
+	}
+	/**
+	* Calculate the modulo of the dividend and divisor while keeping the result within the same sign as the divisor
+	* {@link https://anguscroll.com/just/just-modulo}
+	*
+	* @param n Dividend
+	* @param d Divisor
+	* @returns Modulo
+	*/
+	function modulo(n, d) {
+		return (n % d + d) % d;
+	}
 
-// packages/core/src/dimensions.ts
-var Dimensions = class {
-  constructor(wrapper, content, { autoResize = true, debounce: debounceValue = 250 } = {}) {
-    this.wrapper = wrapper;
-    this.content = content;
-    if (autoResize) {
-      this.debouncedResize = debounce(this.resize, debounceValue);
-      if (this.wrapper instanceof Window) {
-        window.addEventListener("resize", this.debouncedResize);
-      } else {
-        this.wrapperResizeObserver = new ResizeObserver(this.debouncedResize);
-        this.wrapperResizeObserver.observe(this.wrapper);
-      }
-      this.contentResizeObserver = new ResizeObserver(this.debouncedResize);
-      this.contentResizeObserver.observe(this.content);
-    }
-    this.resize();
-  }
-  width = 0;
-  height = 0;
-  scrollHeight = 0;
-  scrollWidth = 0;
-  // These are instanciated in the constructor as they need information from the options
-  debouncedResize;
-  wrapperResizeObserver;
-  contentResizeObserver;
-  destroy() {
-    this.wrapperResizeObserver?.disconnect();
-    this.contentResizeObserver?.disconnect();
-    if (this.wrapper === window && this.debouncedResize) {
-      window.removeEventListener("resize", this.debouncedResize);
-    }
-  }
-  resize = () => {
-    this.onWrapperResize();
-    this.onContentResize();
-  };
-  onWrapperResize = () => {
-    if (this.wrapper instanceof Window) {
-      this.width = window.innerWidth;
-      this.height = window.innerHeight;
-    } else {
-      this.width = this.wrapper.clientWidth;
-      this.height = this.wrapper.clientHeight;
-    }
-  };
-  onContentResize = () => {
-    if (this.wrapper instanceof Window) {
-      this.scrollHeight = this.content.scrollHeight;
-      this.scrollWidth = this.content.scrollWidth;
-    } else {
-      this.scrollHeight = this.wrapper.scrollHeight;
-      this.scrollWidth = this.wrapper.scrollWidth;
-    }
-  };
-  get limit() {
-    return {
-      x: this.scrollWidth - this.width,
-      y: this.scrollHeight - this.height
-    };
-  }
-};
+//#endregion
+//#region packages/core/src/animate.ts
+/**
+	* Animate class to handle value animations with lerping or easing
+	*
+	* @example
+	* const animate = new Animate()
+	* animate.fromTo(0, 100, { duration: 1, easing: (t) => t })
+	* animate.advance(0.5) // 50
+	*/
+	var Animate = class {
+		isRunning = false;
+		value = 0;
+		from = 0;
+		to = 0;
+		currentTime = 0;
+		lerp;
+		duration;
+		easing;
+		onUpdate;
+		/**
+		* Advance the animation by the given delta time
+		*
+		* @param deltaTime - The time in seconds to advance the animation
+		*/
+		advance(deltaTime) {
+			if (!this.isRunning) return;
+			let completed = false;
+			if (this.duration && this.easing) {
+				this.currentTime += deltaTime;
+				const linearProgress = clamp(0, this.currentTime / this.duration, 1);
+				completed = linearProgress >= 1;
+				const easedProgress = completed ? 1 : this.easing(linearProgress);
+				this.value = this.from + (this.to - this.from) * easedProgress;
+			} else if (this.lerp) {
+				this.value = damp(this.value, this.to, this.lerp * 60, deltaTime);
+				if (Math.round(this.value) === this.to) {
+					this.value = this.to;
+					completed = true;
+				}
+			} else {
+				this.value = this.to;
+				completed = true;
+			}
+			if (completed) this.stop();
+			this.onUpdate?.(this.value, completed);
+		}
+		/** Stop the animation */
+		stop() {
+			this.isRunning = false;
+		}
+		/**
+		* Set up the animation from a starting value to an ending value
+		* with optional parameters for lerping, duration, easing, and onUpdate callback
+		*
+		* @param from - The starting value
+		* @param to - The ending value
+		* @param options - Options for the animation
+		*/
+		fromTo(from, to, { lerp, duration, easing, onStart, onUpdate }) {
+			this.from = this.value = from;
+			this.to = to;
+			this.lerp = lerp;
+			this.duration = duration;
+			this.easing = easing;
+			this.currentTime = 0;
+			this.isRunning = true;
+			onStart?.();
+			this.onUpdate = onUpdate;
+		}
+	};
 
-// packages/core/src/emitter.ts
-var Emitter = class {
-  events = {};
-  /**
-   * Emit an event with the given data
-   * @param event Event name
-   * @param args Data to pass to the event handlers
-   */
-  emit(event, ...args) {
-    const callbacks = this.events[event] || [];
-    for (let i = 0, length = callbacks.length; i < length; i++) {
-      callbacks[i]?.(...args);
-    }
-  }
-  /**
-   * Add a callback to the event
-   * @param event Event name
-   * @param cb Callback function
-   * @returns Unsubscribe function
-   */
-  on(event, cb) {
-    if (this.events[event]) {
-      this.events[event].push(cb);
-    } else {
-      this.events[event] = [cb];
-    }
-    return () => {
-      this.events[event] = this.events[event]?.filter((i) => cb !== i);
-    };
-  }
-  /**
-   * Remove a callback from the event
-   * @param event Event name
-   * @param callback Callback function
-   */
-  off(event, callback) {
-    this.events[event] = this.events[event]?.filter((i) => callback !== i);
-  }
-  /**
-   * Remove all event listeners and clean up
-   */
-  destroy() {
-    this.events = {};
-  }
-};
+//#endregion
+//#region packages/core/src/debounce.ts
+	function debounce(callback, delay) {
+		let timer;
+		return function(...args) {
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				timer = void 0;
+				callback.apply(this, args);
+			}, delay);
+		};
+	}
 
-// packages/core/src/virtual-scroll.ts
-var LINE_HEIGHT = 100 / 6;
-var listenerOptions = { passive: false };
-function getDeltaMultiplier(deltaMode, size) {
-  if (deltaMode === 1) return LINE_HEIGHT;
-  if (deltaMode === 2) return size;
-  return 1;
-}
-var VirtualScroll = class {
-  constructor(element, options = { wheelMultiplier: 1, touchMultiplier: 1 }) {
-    this.element = element;
-    this.options = options;
-    window.addEventListener("resize", this.onWindowResize);
-    this.onWindowResize();
-    this.element.addEventListener("wheel", this.onWheel, listenerOptions);
-    this.element.addEventListener(
-      "touchstart",
-      this.onTouchStart,
-      listenerOptions
-    );
-    this.element.addEventListener(
-      "touchmove",
-      this.onTouchMove,
-      listenerOptions
-    );
-    this.element.addEventListener("touchend", this.onTouchEnd, listenerOptions);
-  }
-  touchStart = {
-    x: 0,
-    y: 0
-  };
-  lastDelta = {
-    x: 0,
-    y: 0
-  };
-  window = {
-    width: 0,
-    height: 0
-  };
-  emitter = new Emitter();
-  /**
-   * Add an event listener for the given event and callback
-   *
-   * @param event Event name
-   * @param callback Callback function
-   */
-  on(event, callback) {
-    return this.emitter.on(event, callback);
-  }
-  /** Remove all event listeners and clean up */
-  destroy() {
-    this.emitter.destroy();
-    window.removeEventListener("resize", this.onWindowResize);
-    this.element.removeEventListener("wheel", this.onWheel, listenerOptions);
-    this.element.removeEventListener(
-      "touchstart",
-      this.onTouchStart,
-      listenerOptions
-    );
-    this.element.removeEventListener(
-      "touchmove",
-      this.onTouchMove,
-      listenerOptions
-    );
-    this.element.removeEventListener(
-      "touchend",
-      this.onTouchEnd,
-      listenerOptions
-    );
-  }
-  /**
-   * Event handler for 'touchstart' event
-   *
-   * @param event Touch event
-   */
-  onTouchStart = (event) => {
-    const { clientX, clientY } = event.targetTouches ? event.targetTouches[0] : event;
-    this.touchStart.x = clientX;
-    this.touchStart.y = clientY;
-    this.lastDelta = {
-      x: 0,
-      y: 0
-    };
-    this.emitter.emit("scroll", {
-      deltaX: 0,
-      deltaY: 0,
-      event
-    });
-  };
-  /** Event handler for 'touchmove' event */
-  onTouchMove = (event) => {
-    const { clientX, clientY } = event.targetTouches ? event.targetTouches[0] : event;
-    const deltaX = -(clientX - this.touchStart.x) * this.options.touchMultiplier;
-    const deltaY = -(clientY - this.touchStart.y) * this.options.touchMultiplier;
-    this.touchStart.x = clientX;
-    this.touchStart.y = clientY;
-    this.lastDelta = {
-      x: deltaX,
-      y: deltaY
-    };
-    this.emitter.emit("scroll", {
-      deltaX,
-      deltaY,
-      event
-    });
-  };
-  onTouchEnd = (event) => {
-    this.emitter.emit("scroll", {
-      deltaX: this.lastDelta.x,
-      deltaY: this.lastDelta.y,
-      event
-    });
-  };
-  /** Event handler for 'wheel' event */
-  onWheel = (event) => {
-    let { deltaX, deltaY, deltaMode } = event;
-    const multiplierX = getDeltaMultiplier(deltaMode, this.window.width);
-    const multiplierY = getDeltaMultiplier(deltaMode, this.window.height);
-    deltaX *= multiplierX;
-    deltaY *= multiplierY;
-    deltaX *= this.options.wheelMultiplier;
-    deltaY *= this.options.wheelMultiplier;
-    this.emitter.emit("scroll", { deltaX, deltaY, event });
-  };
-  onWindowResize = () => {
-    this.window = {
-      width: window.innerWidth,
-      height: window.innerHeight
-    };
-  };
-};
+//#endregion
+//#region packages/core/src/dimensions.ts
+/**
+	* Dimensions class to handle the size of the content and wrapper
+	*
+	* @example
+	* const dimensions = new Dimensions(wrapper, content)
+	* dimensions.on('resize', (e) => {
+	*   console.log(e.width, e.height)
+	* })
+	*/
+	var Dimensions = class {
+		width = 0;
+		height = 0;
+		scrollHeight = 0;
+		scrollWidth = 0;
+		debouncedResize;
+		wrapperResizeObserver;
+		contentResizeObserver;
+		constructor(wrapper, content, { autoResize = true, debounce: debounceValue = 250 } = {}) {
+			this.wrapper = wrapper;
+			this.content = content;
+			if (autoResize) {
+				this.debouncedResize = debounce(this.resize, debounceValue);
+				if (this.wrapper instanceof Window) window.addEventListener("resize", this.debouncedResize);
+				else {
+					this.wrapperResizeObserver = new ResizeObserver(this.debouncedResize);
+					this.wrapperResizeObserver.observe(this.wrapper);
+				}
+				this.contentResizeObserver = new ResizeObserver(this.debouncedResize);
+				this.contentResizeObserver.observe(this.content);
+			}
+			this.resize();
+		}
+		destroy() {
+			this.wrapperResizeObserver?.disconnect();
+			this.contentResizeObserver?.disconnect();
+			if (this.wrapper === window && this.debouncedResize) window.removeEventListener("resize", this.debouncedResize);
+		}
+		resize = () => {
+			this.onWrapperResize();
+			this.onContentResize();
+		};
+		onWrapperResize = () => {
+			if (this.wrapper instanceof Window) {
+				this.width = window.innerWidth;
+				this.height = window.innerHeight;
+			} else {
+				this.width = this.wrapper.clientWidth;
+				this.height = this.wrapper.clientHeight;
+			}
+		};
+		onContentResize = () => {
+			if (this.wrapper instanceof Window) {
+				this.scrollHeight = this.content.scrollHeight;
+				this.scrollWidth = this.content.scrollWidth;
+			} else {
+				this.scrollHeight = this.wrapper.scrollHeight;
+				this.scrollWidth = this.wrapper.scrollWidth;
+			}
+		};
+		get limit() {
+			return {
+				x: this.scrollWidth - this.width,
+				y: this.scrollHeight - this.height
+			};
+		}
+	};
 
-// packages/core/src/lenis.ts
-var defaultEasing = (t) => Math.min(1, 1.001 - 2 ** (-10 * t));
-var Lenis = class {
-  _isScrolling = false;
-  // true when scroll is animating
-  _isStopped = false;
-  // true if user should not be able to scroll - enable/disable programmatically
-  _isLocked = false;
-  // same as isStopped but enabled/disabled when scroll reaches target
-  _preventNextNativeScrollEvent = false;
-  _resetVelocityTimeout = null;
-  _rafId = null;
-  /**
-   * Whether or not the user is touching the screen
-   */
-  isTouching;
-  /**
-   * The time in ms since the lenis instance was created
-   */
-  time = 0;
-  /**
-   * User data that will be forwarded through the scroll event
-   *
-   * @example
-   * lenis.scrollTo(100, {
-   *   userData: {
-   *     foo: 'bar'
-   *   }
-   * })
-   */
-  userData = {};
-  /**
-   * The last velocity of the scroll
-   */
-  lastVelocity = 0;
-  /**
-   * The current velocity of the scroll
-   */
-  velocity = 0;
-  /**
-   * The direction of the scroll
-   */
-  direction = 0;
-  /**
-   * The options passed to the lenis instance
-   */
-  options;
-  /**
-   * The target scroll value
-   */
-  targetScroll;
-  /**
-   * The animated scroll value
-   */
-  animatedScroll;
-  // These are instanciated here as they don't need information from the options
-  animate = new Animate();
-  emitter = new Emitter();
-  // These are instanciated in the constructor as they need information from the options
-  dimensions;
-  // This is not private because it's used in the Snap class
-  virtualScroll;
-  constructor({
-    wrapper = window,
-    content = document.documentElement,
-    eventsTarget = wrapper,
-    smoothWheel = true,
-    syncTouch = false,
-    syncTouchLerp = 0.075,
-    touchInertiaExponent = 1.7,
-    duration,
-    // in seconds
-    easing,
-    lerp: lerp2 = 0.1,
-    infinite = false,
-    orientation = "vertical",
-    // vertical, horizontal
-    gestureOrientation = orientation === "horizontal" ? "both" : "vertical",
-    // vertical, horizontal, both
-    touchMultiplier = 1,
-    wheelMultiplier = 1,
-    autoResize = true,
-    prevent,
-    virtualScroll,
-    overscroll = true,
-    autoRaf = false,
-    anchors = false,
-    autoToggle = false,
-    // https://caniuse.com/?search=transition-behavior
-    allowNestedScroll = false,
-    __experimental__naiveDimensions = false,
-    naiveDimensions = __experimental__naiveDimensions,
-    stopInertiaOnNavigate = false
-  } = {}) {
-    window.lenisVersion = version;
-    if (!window.lenis) {
-      window.lenis = {};
-    }
-    window.lenis.version = version;
-    if (orientation === "horizontal") {
-      window.lenis.horizontal = true;
-    }
-    if (syncTouch === true) {
-      window.lenis.touch = true;
-    }
-    if (!wrapper || wrapper === document.documentElement) {
-      wrapper = window;
-    }
-    if (typeof duration === "number" && typeof easing !== "function") {
-      easing = defaultEasing;
-    } else if (typeof easing === "function" && typeof duration !== "number") {
-      duration = 1;
-    }
-    this.options = {
-      wrapper,
-      content,
-      eventsTarget,
-      smoothWheel,
-      syncTouch,
-      syncTouchLerp,
-      touchInertiaExponent,
-      duration,
-      easing,
-      lerp: lerp2,
-      infinite,
-      gestureOrientation,
-      orientation,
-      touchMultiplier,
-      wheelMultiplier,
-      autoResize,
-      prevent,
-      virtualScroll,
-      overscroll,
-      autoRaf,
-      anchors,
-      autoToggle,
-      allowNestedScroll,
-      naiveDimensions,
-      stopInertiaOnNavigate
-    };
-    this.dimensions = new Dimensions(wrapper, content, { autoResize });
-    this.updateClassName();
-    this.targetScroll = this.animatedScroll = this.actualScroll;
-    this.options.wrapper.addEventListener("scroll", this.onNativeScroll);
-    this.options.wrapper.addEventListener("scrollend", this.onScrollEnd, {
-      capture: true
-    });
-    if (this.options.anchors || this.options.stopInertiaOnNavigate) {
-      this.options.wrapper.addEventListener(
-        "click",
-        this.onClick
-      );
-    }
-    this.options.wrapper.addEventListener(
-      "pointerdown",
-      this.onPointerDown
-    );
-    this.virtualScroll = new VirtualScroll(eventsTarget, {
-      touchMultiplier,
-      wheelMultiplier
-    });
-    this.virtualScroll.on("scroll", this.onVirtualScroll);
-    if (this.options.autoToggle) {
-      this.checkOverflow();
-      this.rootElement.addEventListener("transitionend", this.onTransitionEnd);
-    }
-    if (this.options.autoRaf) {
-      this._rafId = requestAnimationFrame(this.raf);
-    }
-  }
-  /**
-   * Destroy the lenis instance, remove all event listeners and clean up the class name
-   */
-  destroy() {
-    this.emitter.destroy();
-    this.options.wrapper.removeEventListener("scroll", this.onNativeScroll);
-    this.options.wrapper.removeEventListener("scrollend", this.onScrollEnd, {
-      capture: true
-    });
-    this.options.wrapper.removeEventListener(
-      "pointerdown",
-      this.onPointerDown
-    );
-    if (this.options.anchors || this.options.stopInertiaOnNavigate) {
-      this.options.wrapper.removeEventListener(
-        "click",
-        this.onClick
-      );
-    }
-    this.virtualScroll.destroy();
-    this.dimensions.destroy();
-    this.cleanUpClassName();
-    if (this._rafId) {
-      cancelAnimationFrame(this._rafId);
-    }
-  }
-  on(event, callback) {
-    return this.emitter.on(event, callback);
-  }
-  off(event, callback) {
-    return this.emitter.off(event, callback);
-  }
-  onScrollEnd = (e) => {
-    if (!(e instanceof CustomEvent)) {
-      if (this.isScrolling === "smooth" || this.isScrolling === false) {
-        e.stopPropagation();
-      }
-    }
-  };
-  dispatchScrollendEvent = () => {
-    this.options.wrapper.dispatchEvent(
-      new CustomEvent("scrollend", {
-        bubbles: this.options.wrapper === window,
-        // cancelable: false,
-        detail: {
-          lenisScrollEnd: true
-        }
-      })
-    );
-  };
-  get overflow() {
-    const property = this.isHorizontal ? "overflow-x" : "overflow-y";
-    return getComputedStyle(this.rootElement)[property];
-  }
-  checkOverflow() {
-    if (["hidden", "clip"].includes(this.overflow)) {
-      this.internalStop();
-    } else {
-      this.internalStart();
-    }
-  }
-  onTransitionEnd = (event) => {
-    if (event.propertyName.includes("overflow")) {
-      this.checkOverflow();
-    }
-  };
-  setScroll(scroll) {
-    if (this.isHorizontal) {
-      this.options.wrapper.scrollTo({ left: scroll, behavior: "instant" });
-    } else {
-      this.options.wrapper.scrollTo({ top: scroll, behavior: "instant" });
-    }
-  }
-  onClick = (event) => {
-    const path = event.composedPath();
-    const linkElements = path.filter(
-      (node) => node instanceof HTMLAnchorElement && node.href
-    );
-    const linkElementsUrls = linkElements.map(
-      (element) => new URL(element.href)
-    );
-    const currentUrl = new URL(window.location.href);
-    if (this.options.anchors) {
-      const anchorElementUrl = linkElementsUrls.find(
-        (targetUrl) => currentUrl.host === targetUrl.host && currentUrl.pathname === targetUrl.pathname && targetUrl.hash
-      );
-      if (anchorElementUrl) {
-        const options = typeof this.options.anchors === "object" && this.options.anchors ? this.options.anchors : void 0;
-        const target = `#${anchorElementUrl.hash.split("#")[1]}`;
-        this.scrollTo(target, options);
-        return;
-      }
-    }
-    if (this.options.stopInertiaOnNavigate) {
-      const hasPageLinkElementUrl = linkElementsUrls.some(
-        (targetUrl) => currentUrl.host === targetUrl.host && currentUrl.pathname !== targetUrl.pathname
-      );
-      if (hasPageLinkElementUrl) {
-        this.reset();
-        return;
-      }
-    }
-  };
-  onPointerDown = (event) => {
-    if (event.button === 1) {
-      this.reset();
-    }
-  };
-  onVirtualScroll = (data) => {
-    if (typeof this.options.virtualScroll === "function" && this.options.virtualScroll(data) === false)
-      return;
-    const { deltaX, deltaY, event } = data;
-    this.emitter.emit("virtual-scroll", { deltaX, deltaY, event });
-    if (event.ctrlKey) return;
-    if (event.lenisStopPropagation) return;
-    const isTouch = event.type.includes("touch");
-    const isWheel = event.type.includes("wheel");
-    this.isTouching = event.type === "touchstart" || event.type === "touchmove";
-    const isClickOrTap = deltaX === 0 && deltaY === 0;
-    const isTapToStop = this.options.syncTouch && isTouch && event.type === "touchstart" && isClickOrTap && !this.isStopped && !this.isLocked;
-    if (isTapToStop) {
-      this.reset();
-      return;
-    }
-    const isUnknownGesture = this.options.gestureOrientation === "vertical" && deltaY === 0 || this.options.gestureOrientation === "horizontal" && deltaX === 0;
-    if (isClickOrTap || isUnknownGesture) {
-      return;
-    }
-    let composedPath = event.composedPath();
-    composedPath = composedPath.slice(0, composedPath.indexOf(this.rootElement));
-    const prevent = this.options.prevent;
-    const gestureOrientation = Math.abs(deltaX) >= Math.abs(deltaY) ? "horizontal" : "vertical";
-    if (composedPath.find(
-      (node) => node instanceof HTMLElement && (typeof prevent === "function" && prevent?.(node) || node.hasAttribute?.("data-lenis-prevent") || gestureOrientation === "vertical" && node.hasAttribute?.("data-lenis-prevent-vertical") || gestureOrientation === "horizontal" && node.hasAttribute?.("data-lenis-prevent-horizontal") || isTouch && node.hasAttribute?.("data-lenis-prevent-touch") || isWheel && node.hasAttribute?.("data-lenis-prevent-wheel") || this.options.allowNestedScroll && this.hasNestedScroll(node, {
-        deltaX,
-        deltaY
-      }))
-    ))
-      return;
-    if (this.isStopped || this.isLocked) {
-      if (event.cancelable) {
-        event.preventDefault();
-      }
-      return;
-    }
-    const isSmooth = this.options.syncTouch && isTouch || this.options.smoothWheel && isWheel;
-    if (!isSmooth) {
-      this.isScrolling = "native";
-      this.animate.stop();
-      event.lenisStopPropagation = true;
-      return;
-    }
-    let delta = deltaY;
-    if (this.options.gestureOrientation === "both") {
-      delta = Math.abs(deltaY) > Math.abs(deltaX) ? deltaY : deltaX;
-    } else if (this.options.gestureOrientation === "horizontal") {
-      delta = deltaX;
-    }
-    if (!this.options.overscroll || this.options.infinite || this.options.wrapper !== window && this.limit > 0 && (this.animatedScroll > 0 && this.animatedScroll < this.limit || this.animatedScroll === 0 && deltaY > 0 || this.animatedScroll === this.limit && deltaY < 0)) {
-      event.lenisStopPropagation = true;
-    }
-    if (event.cancelable) {
-      event.preventDefault();
-    }
-    const isSyncTouch = isTouch && this.options.syncTouch;
-    const isTouchEnd = isTouch && event.type === "touchend";
-    const hasTouchInertia = isTouchEnd;
-    if (hasTouchInertia) {
-      delta = Math.sign(this.velocity) * Math.abs(this.velocity) ** this.options.touchInertiaExponent;
-    }
-    this.scrollTo(this.targetScroll + delta, {
-      programmatic: false,
-      ...isSyncTouch ? {
-        lerp: hasTouchInertia ? this.options.syncTouchLerp : 1
-      } : {
-        lerp: this.options.lerp,
-        duration: this.options.duration,
-        easing: this.options.easing
-      }
-    });
-  };
-  /**
-   * Force lenis to recalculate the dimensions
-   */
-  resize() {
-    this.dimensions.resize();
-    this.animatedScroll = this.targetScroll = this.actualScroll;
-    this.emit();
-  }
-  emit() {
-    this.emitter.emit("scroll", this);
-  }
-  onNativeScroll = () => {
-    if (this._resetVelocityTimeout !== null) {
-      clearTimeout(this._resetVelocityTimeout);
-      this._resetVelocityTimeout = null;
-    }
-    if (this._preventNextNativeScrollEvent) {
-      this._preventNextNativeScrollEvent = false;
-      return;
-    }
-    if (this.isScrolling === false || this.isScrolling === "native") {
-      const lastScroll = this.animatedScroll;
-      this.animatedScroll = this.targetScroll = this.actualScroll;
-      this.lastVelocity = this.velocity;
-      this.velocity = this.animatedScroll - lastScroll;
-      this.direction = Math.sign(
-        this.animatedScroll - lastScroll
-      );
-      if (!this.isStopped) {
-        this.isScrolling = "native";
-      }
-      this.emit();
-      if (this.velocity !== 0) {
-        this._resetVelocityTimeout = setTimeout(() => {
-          this.lastVelocity = this.velocity;
-          this.velocity = 0;
-          this.isScrolling = false;
-          this.emit();
-        }, 400);
-      }
-    }
-  };
-  reset() {
-    this.isLocked = false;
-    this.isScrolling = false;
-    this.animatedScroll = this.targetScroll = this.actualScroll;
-    this.lastVelocity = this.velocity = 0;
-    this.animate.stop();
-  }
-  /**
-   * Start lenis scroll after it has been stopped
-   */
-  start() {
-    if (!this.isStopped) return;
-    if (this.options.autoToggle) {
-      this.rootElement.style.removeProperty("overflow");
-      return;
-    }
-    this.internalStart();
-  }
-  internalStart() {
-    if (!this.isStopped) return;
-    this.reset();
-    this.isStopped = false;
-    this.emit();
-  }
-  /**
-   * Stop lenis scroll
-   */
-  stop() {
-    if (this.isStopped) return;
-    if (this.options.autoToggle) {
-      this.rootElement.style.setProperty("overflow", "clip");
-      return;
-    }
-    this.internalStop();
-  }
-  internalStop() {
-    if (this.isStopped) return;
-    this.reset();
-    this.isStopped = true;
-    this.emit();
-  }
-  /**
-   * RequestAnimationFrame for lenis
-   *
-   * @param time The time in ms from an external clock like `requestAnimationFrame` or Tempus
-   */
-  raf = (time) => {
-    const deltaTime = time - (this.time || time);
-    this.time = time;
-    this.animate.advance(deltaTime * 1e-3);
-    if (this.options.autoRaf) {
-      this._rafId = requestAnimationFrame(this.raf);
-    }
-  };
-  /**
-   * Scroll to a target value
-   *
-   * @param target The target value to scroll to
-   * @param options The options for the scroll
-   *
-   * @example
-   * lenis.scrollTo(100, {
-   *   offset: 100,
-   *   duration: 1,
-   *   easing: (t) => 1 - Math.cos((t * Math.PI) / 2),
-   *   lerp: 0.1,
-   *   onStart: () => {
-   *     console.log('onStart')
-   *   },
-   *   onComplete: () => {
-   *     console.log('onComplete')
-   *   },
-   * })
-   */
-  scrollTo(_target, {
-    offset = 0,
-    immediate = false,
-    lock = false,
-    programmatic = true,
-    // called from outside of the class
-    lerp: lerp2 = programmatic ? this.options.lerp : void 0,
-    duration = programmatic ? this.options.duration : void 0,
-    easing = programmatic ? this.options.easing : void 0,
-    onStart,
-    onComplete,
-    force = false,
-    // scroll even if stopped
-    userData
-  } = {}) {
-    if ((this.isStopped || this.isLocked) && !force) return;
-    let target = _target;
-    let adjustedOffset = offset;
-    if (typeof target === "string" && ["top", "left", "start", "#"].includes(target)) {
-      target = 0;
-    } else if (typeof target === "string" && ["bottom", "right", "end"].includes(target)) {
-      target = this.limit;
-    } else {
-      let node = null;
-      if (typeof target === "string") {
-        node = document.querySelector(target);
-        if (!node) {
-          if (target === "#top") {
-            target = 0;
-          } else {
-            console.warn("Lenis: Target not found", target);
-          }
-        }
-      } else if (target instanceof HTMLElement && target?.nodeType) {
-        node = target;
-      }
-      if (node) {
-        if (this.options.wrapper !== window) {
-          const wrapperRect = this.rootElement.getBoundingClientRect();
-          adjustedOffset -= this.isHorizontal ? wrapperRect.left : wrapperRect.top;
-        }
-        const rect = node.getBoundingClientRect();
-        target = (this.isHorizontal ? rect.left : rect.top) + this.animatedScroll;
-      }
-    }
-    if (typeof target !== "number") return;
-    target += adjustedOffset;
-    target = Math.round(target);
-    if (this.options.infinite) {
-      if (programmatic) {
-        this.targetScroll = this.animatedScroll = this.scroll;
-        const distance = target - this.animatedScroll;
-        if (distance > this.limit / 2) {
-          target -= this.limit;
-        } else if (distance < -this.limit / 2) {
-          target += this.limit;
-        }
-      }
-    } else {
-      target = clamp(0, target, this.limit);
-    }
-    if (target === this.targetScroll) {
-      onStart?.(this);
-      onComplete?.(this);
-      return;
-    }
-    this.userData = userData ?? {};
-    if (immediate) {
-      this.animatedScroll = this.targetScroll = target;
-      this.setScroll(this.scroll);
-      this.reset();
-      this.preventNextNativeScrollEvent();
-      this.emit();
-      onComplete?.(this);
-      this.userData = {};
-      requestAnimationFrame(() => {
-        this.dispatchScrollendEvent();
-      });
-      return;
-    }
-    if (!programmatic) {
-      this.targetScroll = target;
-    }
-    if (typeof duration === "number" && typeof easing !== "function") {
-      easing = defaultEasing;
-    } else if (typeof easing === "function" && typeof duration !== "number") {
-      duration = 1;
-    }
-    this.animate.fromTo(this.animatedScroll, target, {
-      duration,
-      easing,
-      lerp: lerp2,
-      onStart: () => {
-        if (lock) this.isLocked = true;
-        this.isScrolling = "smooth";
-        onStart?.(this);
-      },
-      onUpdate: (value, completed) => {
-        this.isScrolling = "smooth";
-        this.lastVelocity = this.velocity;
-        this.velocity = value - this.animatedScroll;
-        this.direction = Math.sign(this.velocity);
-        this.animatedScroll = value;
-        this.setScroll(this.scroll);
-        if (programmatic) {
-          this.targetScroll = value;
-        }
-        if (!completed) this.emit();
-        if (completed) {
-          this.reset();
-          this.emit();
-          onComplete?.(this);
-          this.userData = {};
-          requestAnimationFrame(() => {
-            this.dispatchScrollendEvent();
-          });
-          this.preventNextNativeScrollEvent();
-        }
-      }
-    });
-  }
-  preventNextNativeScrollEvent() {
-    this._preventNextNativeScrollEvent = true;
-    requestAnimationFrame(() => {
-      this._preventNextNativeScrollEvent = false;
-    });
-  }
-  hasNestedScroll(node, { deltaX, deltaY }) {
-    const time = Date.now();
-    if (!node._lenis) node._lenis = {};
-    const cache = node._lenis;
-    let hasOverflowX;
-    let hasOverflowY;
-    let isScrollableX;
-    let isScrollableY;
-    let hasOverscrollBehaviorX;
-    let hasOverscrollBehaviorY;
-    let scrollWidth;
-    let scrollHeight;
-    let clientWidth;
-    let clientHeight;
-    if (time - (cache.time ?? 0) > 2e3) {
-      cache.time = Date.now();
-      const computedStyle = window.getComputedStyle(node);
-      cache.computedStyle = computedStyle;
-      hasOverflowX = ["auto", "overlay", "scroll"].includes(
-        computedStyle.overflowX
-      );
-      hasOverflowY = ["auto", "overlay", "scroll"].includes(
-        computedStyle.overflowY
-      );
-      hasOverscrollBehaviorX = ["auto"].includes(
-        computedStyle.overscrollBehaviorX
-      );
-      hasOverscrollBehaviorY = ["auto"].includes(
-        computedStyle.overscrollBehaviorY
-      );
-      cache.hasOverflowX = hasOverflowX;
-      cache.hasOverflowY = hasOverflowY;
-      if (!(hasOverflowX || hasOverflowY)) return false;
-      scrollWidth = node.scrollWidth;
-      scrollHeight = node.scrollHeight;
-      clientWidth = node.clientWidth;
-      clientHeight = node.clientHeight;
-      isScrollableX = scrollWidth > clientWidth;
-      isScrollableY = scrollHeight > clientHeight;
-      cache.isScrollableX = isScrollableX;
-      cache.isScrollableY = isScrollableY;
-      cache.scrollWidth = scrollWidth;
-      cache.scrollHeight = scrollHeight;
-      cache.clientWidth = clientWidth;
-      cache.clientHeight = clientHeight;
-      cache.hasOverscrollBehaviorX = hasOverscrollBehaviorX;
-      cache.hasOverscrollBehaviorY = hasOverscrollBehaviorY;
-    } else {
-      isScrollableX = cache.isScrollableX;
-      isScrollableY = cache.isScrollableY;
-      hasOverflowX = cache.hasOverflowX;
-      hasOverflowY = cache.hasOverflowY;
-      scrollWidth = cache.scrollWidth;
-      scrollHeight = cache.scrollHeight;
-      clientWidth = cache.clientWidth;
-      clientHeight = cache.clientHeight;
-      hasOverscrollBehaviorX = cache.hasOverscrollBehaviorX;
-      hasOverscrollBehaviorY = cache.hasOverscrollBehaviorY;
-    }
-    if (!(hasOverflowX && isScrollableX || hasOverflowY && isScrollableY)) {
-      return false;
-    }
-    const orientation = Math.abs(deltaX) >= Math.abs(deltaY) ? "horizontal" : "vertical";
-    let scroll;
-    let maxScroll;
-    let delta;
-    let hasOverflow;
-    let isScrollable;
-    let hasOverscrollBehavior;
-    if (orientation === "horizontal") {
-      scroll = Math.round(node.scrollLeft);
-      maxScroll = scrollWidth - clientWidth;
-      delta = deltaX;
-      hasOverflow = hasOverflowX;
-      isScrollable = isScrollableX;
-      hasOverscrollBehavior = hasOverscrollBehaviorX;
-    } else if (orientation === "vertical") {
-      scroll = Math.round(node.scrollTop);
-      maxScroll = scrollHeight - clientHeight;
-      delta = deltaY;
-      hasOverflow = hasOverflowY;
-      isScrollable = isScrollableY;
-      hasOverscrollBehavior = hasOverscrollBehaviorY;
-    } else {
-      return false;
-    }
-    if (!hasOverscrollBehavior && (scroll >= maxScroll || scroll <= 0)) {
-      return true;
-    }
-    const willScroll = delta > 0 ? scroll < maxScroll : scroll > 0;
-    return willScroll && hasOverflow && isScrollable;
-  }
-  /**
-   * The root element on which lenis is instanced
-   */
-  get rootElement() {
-    return this.options.wrapper === window ? document.documentElement : this.options.wrapper;
-  }
-  /**
-   * The limit which is the maximum scroll value
-   */
-  get limit() {
-    if (this.options.naiveDimensions) {
-      if (this.isHorizontal) {
-        return this.rootElement.scrollWidth - this.rootElement.clientWidth;
-      }
-      return this.rootElement.scrollHeight - this.rootElement.clientHeight;
-    }
-    return this.dimensions.limit[this.isHorizontal ? "x" : "y"];
-  }
-  /**
-   * Whether or not the scroll is horizontal
-   */
-  get isHorizontal() {
-    return this.options.orientation === "horizontal";
-  }
-  /**
-   * The actual scroll value
-   */
-  get actualScroll() {
-    const wrapper = this.options.wrapper;
-    return this.isHorizontal ? wrapper.scrollX ?? wrapper.scrollLeft : wrapper.scrollY ?? wrapper.scrollTop;
-  }
-  /**
-   * The current scroll value
-   */
-  get scroll() {
-    return this.options.infinite ? modulo(this.animatedScroll, this.limit) : this.animatedScroll;
-  }
-  /**
-   * The progress of the scroll relative to the limit
-   */
-  get progress() {
-    return this.limit === 0 ? 1 : this.scroll / this.limit;
-  }
-  /**
-   * Current scroll state
-   */
-  get isScrolling() {
-    return this._isScrolling;
-  }
-  set isScrolling(value) {
-    if (this._isScrolling !== value) {
-      this._isScrolling = value;
-      this.updateClassName();
-    }
-  }
-  /**
-   * Check if lenis is stopped
-   */
-  get isStopped() {
-    return this._isStopped;
-  }
-  set isStopped(value) {
-    if (this._isStopped !== value) {
-      this._isStopped = value;
-      this.updateClassName();
-    }
-  }
-  /**
-   * Check if lenis is locked
-   */
-  get isLocked() {
-    return this._isLocked;
-  }
-  set isLocked(value) {
-    if (this._isLocked !== value) {
-      this._isLocked = value;
-      this.updateClassName();
-    }
-  }
-  /**
-   * Check if lenis is smooth scrolling
-   */
-  get isSmooth() {
-    return this.isScrolling === "smooth";
-  }
-  /**
-   * The class name applied to the wrapper element
-   */
-  get className() {
-    let className = "lenis";
-    if (this.options.autoToggle) className += " lenis-autoToggle";
-    if (this.isStopped) className += " lenis-stopped";
-    if (this.isLocked) className += " lenis-locked";
-    if (this.isScrolling) className += " lenis-scrolling";
-    if (this.isScrolling === "smooth") className += " lenis-smooth";
-    return className;
-  }
-  updateClassName() {
-    this.cleanUpClassName();
-    this.rootElement.className = `${this.rootElement.className} ${this.className}`.trim();
-  }
-  cleanUpClassName() {
-    this.rootElement.className = this.rootElement.className.replace(/lenis(-\w+)?/g, "").trim();
-  }
-};
+//#endregion
+//#region packages/core/src/emitter.ts
+/**
+	* Emitter class to handle events
+	* @example
+	* const emitter = new Emitter()
+	* emitter.on('event', (data) => {
+	*   console.log(data)
+	* })
+	* emitter.emit('event', 'data')
+	*/
+	var Emitter = class {
+		events = {};
+		/**
+		* Emit an event with the given data
+		* @param event Event name
+		* @param args Data to pass to the event handlers
+		*/
+		emit(event, ...args) {
+			const callbacks = this.events[event] || [];
+			for (let i = 0, length = callbacks.length; i < length; i++) callbacks[i]?.(...args);
+		}
+		/**
+		* Add a callback to the event
+		* @param event Event name
+		* @param cb Callback function
+		* @returns Unsubscribe function
+		*/
+		on(event, cb) {
+			if (this.events[event]) this.events[event].push(cb);
+			else this.events[event] = [cb];
+			return () => {
+				this.events[event] = this.events[event]?.filter((i) => cb !== i);
+			};
+		}
+		/**
+		* Remove a callback from the event
+		* @param event Event name
+		* @param callback Callback function
+		*/
+		off(event, callback) {
+			this.events[event] = this.events[event]?.filter((i) => callback !== i);
+		}
+		/**
+		* Remove all event listeners and clean up
+		*/
+		destroy() {
+			this.events = {};
+		}
+	};
 
-// packages/core/browser.ts
-globalThis.Lenis = Lenis;
-globalThis.Lenis.prototype = Lenis.prototype;
+//#endregion
+//#region packages/core/src/virtual-scroll.ts
+	const LINE_HEIGHT = 100 / 6;
+	const listenerOptions = { passive: false };
+	function getDeltaMultiplier(deltaMode, size) {
+		if (deltaMode === 1) return LINE_HEIGHT;
+		if (deltaMode === 2) return size;
+		return 1;
+	}
+	var VirtualScroll = class {
+		touchStart = {
+			x: 0,
+			y: 0
+		};
+		lastDelta = {
+			x: 0,
+			y: 0
+		};
+		window = {
+			width: 0,
+			height: 0
+		};
+		emitter = new Emitter();
+		constructor(element, options = {
+			wheelMultiplier: 1,
+			touchMultiplier: 1
+		}) {
+			this.element = element;
+			this.options = options;
+			window.addEventListener("resize", this.onWindowResize);
+			this.onWindowResize();
+			this.element.addEventListener("wheel", this.onWheel, listenerOptions);
+			this.element.addEventListener("touchstart", this.onTouchStart, listenerOptions);
+			this.element.addEventListener("touchmove", this.onTouchMove, listenerOptions);
+			this.element.addEventListener("touchend", this.onTouchEnd, listenerOptions);
+		}
+		/**
+		* Add an event listener for the given event and callback
+		*
+		* @param event Event name
+		* @param callback Callback function
+		*/
+		on(event, callback) {
+			return this.emitter.on(event, callback);
+		}
+		/** Remove all event listeners and clean up */
+		destroy() {
+			this.emitter.destroy();
+			window.removeEventListener("resize", this.onWindowResize);
+			this.element.removeEventListener("wheel", this.onWheel, listenerOptions);
+			this.element.removeEventListener("touchstart", this.onTouchStart, listenerOptions);
+			this.element.removeEventListener("touchmove", this.onTouchMove, listenerOptions);
+			this.element.removeEventListener("touchend", this.onTouchEnd, listenerOptions);
+		}
+		/**
+		* Event handler for 'touchstart' event
+		*
+		* @param event Touch event
+		*/
+		onTouchStart = (event) => {
+			const { clientX, clientY } = event.targetTouches ? event.targetTouches[0] : event;
+			this.touchStart.x = clientX;
+			this.touchStart.y = clientY;
+			this.lastDelta = {
+				x: 0,
+				y: 0
+			};
+			this.emitter.emit("scroll", {
+				deltaX: 0,
+				deltaY: 0,
+				event
+			});
+		};
+		/** Event handler for 'touchmove' event */
+		onTouchMove = (event) => {
+			const { clientX, clientY } = event.targetTouches ? event.targetTouches[0] : event;
+			const deltaX = -(clientX - this.touchStart.x) * this.options.touchMultiplier;
+			const deltaY = -(clientY - this.touchStart.y) * this.options.touchMultiplier;
+			this.touchStart.x = clientX;
+			this.touchStart.y = clientY;
+			this.lastDelta = {
+				x: deltaX,
+				y: deltaY
+			};
+			this.emitter.emit("scroll", {
+				deltaX,
+				deltaY,
+				event
+			});
+		};
+		onTouchEnd = (event) => {
+			this.emitter.emit("scroll", {
+				deltaX: this.lastDelta.x,
+				deltaY: this.lastDelta.y,
+				event
+			});
+		};
+		/** Event handler for 'wheel' event */
+		onWheel = (event) => {
+			let { deltaX, deltaY, deltaMode } = event;
+			const multiplierX = getDeltaMultiplier(deltaMode, this.window.width);
+			const multiplierY = getDeltaMultiplier(deltaMode, this.window.height);
+			deltaX *= multiplierX;
+			deltaY *= multiplierY;
+			deltaX *= this.options.wheelMultiplier;
+			deltaY *= this.options.wheelMultiplier;
+			this.emitter.emit("scroll", {
+				deltaX,
+				deltaY,
+				event
+			});
+		};
+		onWindowResize = () => {
+			this.window = {
+				width: window.innerWidth,
+				height: window.innerHeight
+			};
+		};
+	};
+
+//#endregion
+//#region packages/core/src/lenis.ts
+	const defaultEasing = (t) => Math.min(1, 1.001 - 2 ** (-10 * t));
+	var Lenis = class {
+		_isScrolling = false;
+		_isStopped = false;
+		_isLocked = false;
+		_preventNextNativeScrollEvent = false;
+		_resetVelocityTimeout = null;
+		_rafId = null;
+		/**
+		* Whether or not the user is touching the screen
+		*/
+		isTouching;
+		/**
+		* The time in ms since the lenis instance was created
+		*/
+		time = 0;
+		/**
+		* User data that will be forwarded through the scroll event
+		*
+		* @example
+		* lenis.scrollTo(100, {
+		*   userData: {
+		*     foo: 'bar'
+		*   }
+		* })
+		*/
+		userData = {};
+		/**
+		* The last velocity of the scroll
+		*/
+		lastVelocity = 0;
+		/**
+		* The current velocity of the scroll
+		*/
+		velocity = 0;
+		/**
+		* The direction of the scroll
+		*/
+		direction = 0;
+		/**
+		* The options passed to the lenis instance
+		*/
+		options;
+		/**
+		* The target scroll value
+		*/
+		targetScroll;
+		/**
+		* The animated scroll value
+		*/
+		animatedScroll;
+		animate = new Animate();
+		emitter = new Emitter();
+		dimensions;
+		virtualScroll;
+		constructor({ wrapper = window, content = document.documentElement, eventsTarget = wrapper, smoothWheel = true, syncTouch = false, syncTouchLerp = .075, touchInertiaExponent = 1.7, duration, easing, lerp = .1, infinite = false, orientation = "vertical", gestureOrientation = orientation === "horizontal" ? "both" : "vertical", touchMultiplier = 1, wheelMultiplier = 1, autoResize = true, prevent, virtualScroll, overscroll = true, autoRaf = false, anchors = false, autoToggle = false, allowNestedScroll = false, __experimental__naiveDimensions = false, naiveDimensions = __experimental__naiveDimensions, stopInertiaOnNavigate = false } = {}) {
+			window.lenisVersion = version;
+			if (!window.lenis) window.lenis = {};
+			window.lenis.version = version;
+			if (orientation === "horizontal") window.lenis.horizontal = true;
+			if (syncTouch === true) window.lenis.touch = true;
+			if (!wrapper || wrapper === document.documentElement) wrapper = window;
+			if (typeof duration === "number" && typeof easing !== "function") easing = defaultEasing;
+			else if (typeof easing === "function" && typeof duration !== "number") duration = 1;
+			this.options = {
+				wrapper,
+				content,
+				eventsTarget,
+				smoothWheel,
+				syncTouch,
+				syncTouchLerp,
+				touchInertiaExponent,
+				duration,
+				easing,
+				lerp,
+				infinite,
+				gestureOrientation,
+				orientation,
+				touchMultiplier,
+				wheelMultiplier,
+				autoResize,
+				prevent,
+				virtualScroll,
+				overscroll,
+				autoRaf,
+				anchors,
+				autoToggle,
+				allowNestedScroll,
+				naiveDimensions,
+				stopInertiaOnNavigate
+			};
+			this.dimensions = new Dimensions(wrapper, content, { autoResize });
+			this.updateClassName();
+			this.targetScroll = this.animatedScroll = this.actualScroll;
+			this.options.wrapper.addEventListener("scroll", this.onNativeScroll);
+			this.options.wrapper.addEventListener("scrollend", this.onScrollEnd, { capture: true });
+			if (this.options.anchors || this.options.stopInertiaOnNavigate) this.options.wrapper.addEventListener("click", this.onClick);
+			this.options.wrapper.addEventListener("pointerdown", this.onPointerDown);
+			this.virtualScroll = new VirtualScroll(eventsTarget, {
+				touchMultiplier,
+				wheelMultiplier
+			});
+			this.virtualScroll.on("scroll", this.onVirtualScroll);
+			if (this.options.autoToggle) {
+				this.checkOverflow();
+				this.rootElement.addEventListener("transitionend", this.onTransitionEnd);
+			}
+			if (this.options.autoRaf) this._rafId = requestAnimationFrame(this.raf);
+		}
+		/**
+		* Destroy the lenis instance, remove all event listeners and clean up the class name
+		*/
+		destroy() {
+			this.emitter.destroy();
+			this.options.wrapper.removeEventListener("scroll", this.onNativeScroll);
+			this.options.wrapper.removeEventListener("scrollend", this.onScrollEnd, { capture: true });
+			this.options.wrapper.removeEventListener("pointerdown", this.onPointerDown);
+			if (this.options.anchors || this.options.stopInertiaOnNavigate) this.options.wrapper.removeEventListener("click", this.onClick);
+			this.virtualScroll.destroy();
+			this.dimensions.destroy();
+			this.cleanUpClassName();
+			if (this._rafId) cancelAnimationFrame(this._rafId);
+		}
+		on(event, callback) {
+			return this.emitter.on(event, callback);
+		}
+		off(event, callback) {
+			return this.emitter.off(event, callback);
+		}
+		onScrollEnd = (e) => {
+			if (!(e instanceof CustomEvent)) {
+				if (this.isScrolling === "smooth" || this.isScrolling === false) e.stopPropagation();
+			}
+		};
+		dispatchScrollendEvent = () => {
+			this.options.wrapper.dispatchEvent(new CustomEvent("scrollend", {
+				bubbles: this.options.wrapper === window,
+				detail: { lenisScrollEnd: true }
+			}));
+		};
+		get overflow() {
+			const property = this.isHorizontal ? "overflow-x" : "overflow-y";
+			return getComputedStyle(this.rootElement)[property];
+		}
+		checkOverflow() {
+			if (["hidden", "clip"].includes(this.overflow)) this.internalStop();
+			else this.internalStart();
+		}
+		onTransitionEnd = (event) => {
+			if (event.propertyName.includes("overflow")) this.checkOverflow();
+		};
+		setScroll(scroll) {
+			if (this.isHorizontal) this.options.wrapper.scrollTo({
+				left: scroll,
+				behavior: "instant"
+			});
+			else this.options.wrapper.scrollTo({
+				top: scroll,
+				behavior: "instant"
+			});
+		}
+		onClick = (event) => {
+			const linkElementsUrls = event.composedPath().filter((node) => node instanceof HTMLAnchorElement && node.href).map((element) => new URL(element.href));
+			const currentUrl = new URL(window.location.href);
+			if (this.options.anchors) {
+				const anchorElementUrl = linkElementsUrls.find((targetUrl) => currentUrl.host === targetUrl.host && currentUrl.pathname === targetUrl.pathname && targetUrl.hash);
+				if (anchorElementUrl) {
+					const options = typeof this.options.anchors === "object" && this.options.anchors ? this.options.anchors : void 0;
+					const target = `#${anchorElementUrl.hash.split("#")[1]}`;
+					this.scrollTo(target, options);
+					return;
+				}
+			}
+			if (this.options.stopInertiaOnNavigate) {
+				if (linkElementsUrls.some((targetUrl) => currentUrl.host === targetUrl.host && currentUrl.pathname !== targetUrl.pathname)) {
+					this.reset();
+					return;
+				}
+			}
+		};
+		onPointerDown = (event) => {
+			if (event.button === 1) this.reset();
+		};
+		onVirtualScroll = (data) => {
+			if (typeof this.options.virtualScroll === "function" && this.options.virtualScroll(data) === false) return;
+			const { deltaX, deltaY, event } = data;
+			this.emitter.emit("virtual-scroll", {
+				deltaX,
+				deltaY,
+				event
+			});
+			if (event.ctrlKey) return;
+			if (event.lenisStopPropagation) return;
+			const isTouch = event.type.includes("touch");
+			const isWheel = event.type.includes("wheel");
+			this.isTouching = event.type === "touchstart" || event.type === "touchmove";
+			const isClickOrTap = deltaX === 0 && deltaY === 0;
+			if (this.options.syncTouch && isTouch && event.type === "touchstart" && isClickOrTap && !this.isStopped && !this.isLocked) {
+				this.reset();
+				return;
+			}
+			const isUnknownGesture = this.options.gestureOrientation === "vertical" && deltaY === 0 || this.options.gestureOrientation === "horizontal" && deltaX === 0;
+			if (isClickOrTap || isUnknownGesture) return;
+			let composedPath = event.composedPath();
+			composedPath = composedPath.slice(0, composedPath.indexOf(this.rootElement));
+			const prevent = this.options.prevent;
+			const gestureOrientation = Math.abs(deltaX) >= Math.abs(deltaY) ? "horizontal" : "vertical";
+			if (composedPath.find((node) => node instanceof HTMLElement && (typeof prevent === "function" && prevent?.(node) || node.hasAttribute?.("data-lenis-prevent") || gestureOrientation === "vertical" && node.hasAttribute?.("data-lenis-prevent-vertical") || gestureOrientation === "horizontal" && node.hasAttribute?.("data-lenis-prevent-horizontal") || isTouch && node.hasAttribute?.("data-lenis-prevent-touch") || isWheel && node.hasAttribute?.("data-lenis-prevent-wheel") || this.options.allowNestedScroll && this.hasNestedScroll(node, {
+				deltaX,
+				deltaY
+			})))) return;
+			if (this.isStopped || this.isLocked) {
+				if (event.cancelable) event.preventDefault();
+				return;
+			}
+			if (!(this.options.syncTouch && isTouch || this.options.smoothWheel && isWheel)) {
+				this.isScrolling = "native";
+				this.animate.stop();
+				event.lenisStopPropagation = true;
+				return;
+			}
+			let delta = deltaY;
+			if (this.options.gestureOrientation === "both") delta = Math.abs(deltaY) > Math.abs(deltaX) ? deltaY : deltaX;
+			else if (this.options.gestureOrientation === "horizontal") delta = deltaX;
+			if (!this.options.overscroll || this.options.infinite || this.options.wrapper !== window && this.limit > 0 && (this.animatedScroll > 0 && this.animatedScroll < this.limit || this.animatedScroll === 0 && deltaY > 0 || this.animatedScroll === this.limit && deltaY < 0)) event.lenisStopPropagation = true;
+			if (event.cancelable) event.preventDefault();
+			const isSyncTouch = isTouch && this.options.syncTouch;
+			const hasTouchInertia = isTouch && event.type === "touchend";
+			if (hasTouchInertia) delta = Math.sign(this.velocity) * Math.abs(this.velocity) ** this.options.touchInertiaExponent;
+			this.scrollTo(this.targetScroll + delta, {
+				programmatic: false,
+				...isSyncTouch ? { lerp: hasTouchInertia ? this.options.syncTouchLerp : 1 } : {
+					lerp: this.options.lerp,
+					duration: this.options.duration,
+					easing: this.options.easing
+				}
+			});
+		};
+		/**
+		* Force lenis to recalculate the dimensions
+		*/
+		resize() {
+			this.dimensions.resize();
+			this.animatedScroll = this.targetScroll = this.actualScroll;
+			this.emit();
+		}
+		emit() {
+			this.emitter.emit("scroll", this);
+		}
+		onNativeScroll = () => {
+			if (this._resetVelocityTimeout !== null) {
+				clearTimeout(this._resetVelocityTimeout);
+				this._resetVelocityTimeout = null;
+			}
+			if (this._preventNextNativeScrollEvent) {
+				this._preventNextNativeScrollEvent = false;
+				return;
+			}
+			if (this.isScrolling === false || this.isScrolling === "native") {
+				const lastScroll = this.animatedScroll;
+				this.animatedScroll = this.targetScroll = this.actualScroll;
+				this.lastVelocity = this.velocity;
+				this.velocity = this.animatedScroll - lastScroll;
+				this.direction = Math.sign(this.animatedScroll - lastScroll);
+				if (!this.isStopped) this.isScrolling = "native";
+				this.emit();
+				if (this.velocity !== 0) this._resetVelocityTimeout = setTimeout(() => {
+					this.lastVelocity = this.velocity;
+					this.velocity = 0;
+					this.isScrolling = false;
+					this.emit();
+				}, 400);
+			}
+		};
+		reset() {
+			this.isLocked = false;
+			this.isScrolling = false;
+			this.animatedScroll = this.targetScroll = this.actualScroll;
+			this.lastVelocity = this.velocity = 0;
+			this.animate.stop();
+		}
+		/**
+		* Start lenis scroll after it has been stopped
+		*/
+		start() {
+			if (!this.isStopped) return;
+			if (this.options.autoToggle) {
+				this.rootElement.style.removeProperty("overflow");
+				return;
+			}
+			this.internalStart();
+		}
+		internalStart() {
+			if (!this.isStopped) return;
+			this.reset();
+			this.isStopped = false;
+			this.emit();
+		}
+		/**
+		* Stop lenis scroll
+		*/
+		stop() {
+			if (this.isStopped) return;
+			if (this.options.autoToggle) {
+				this.rootElement.style.setProperty("overflow", "clip");
+				return;
+			}
+			this.internalStop();
+		}
+		internalStop() {
+			if (this.isStopped) return;
+			this.reset();
+			this.isStopped = true;
+			this.emit();
+		}
+		/**
+		* RequestAnimationFrame for lenis
+		*
+		* @param time The time in ms from an external clock like `requestAnimationFrame` or Tempus
+		*/
+		raf = (time) => {
+			const deltaTime = time - (this.time || time);
+			this.time = time;
+			this.animate.advance(deltaTime * .001);
+			if (this.options.autoRaf) this._rafId = requestAnimationFrame(this.raf);
+		};
+		/**
+		* Scroll to a target value
+		*
+		* @param target The target value to scroll to
+		* @param options The options for the scroll
+		*
+		* @example
+		* lenis.scrollTo(100, {
+		*   offset: 100,
+		*   duration: 1,
+		*   easing: (t) => 1 - Math.cos((t * Math.PI) / 2),
+		*   lerp: 0.1,
+		*   onStart: () => {
+		*     console.log('onStart')
+		*   },
+		*   onComplete: () => {
+		*     console.log('onComplete')
+		*   },
+		* })
+		*/
+		scrollTo(_target, { offset = 0, immediate = false, lock = false, programmatic = true, lerp = programmatic ? this.options.lerp : void 0, duration = programmatic ? this.options.duration : void 0, easing = programmatic ? this.options.easing : void 0, onStart, onComplete, force = false, userData } = {}) {
+			if ((this.isStopped || this.isLocked) && !force) return;
+			let target = _target;
+			let adjustedOffset = offset;
+			if (typeof target === "string" && [
+				"top",
+				"left",
+				"start",
+				"#"
+			].includes(target)) target = 0;
+			else if (typeof target === "string" && [
+				"bottom",
+				"right",
+				"end"
+			].includes(target)) target = this.limit;
+			else {
+				let node = null;
+				if (typeof target === "string") {
+					node = document.querySelector(target);
+					if (!node) if (target === "#top") target = 0;
+					else console.warn("Lenis: Target not found", target);
+				} else if (target instanceof HTMLElement && target?.nodeType) node = target;
+				if (node) {
+					if (this.options.wrapper !== window) {
+						const wrapperRect = this.rootElement.getBoundingClientRect();
+						adjustedOffset -= this.isHorizontal ? wrapperRect.left : wrapperRect.top;
+					}
+					const rect = node.getBoundingClientRect();
+					const targetStyle = getComputedStyle(node);
+					const scrollMargin = this.isHorizontal ? Number.parseFloat(targetStyle.scrollMarginLeft) : Number.parseFloat(targetStyle.scrollMarginTop);
+					const containerStyle = getComputedStyle(this.rootElement);
+					const scrollPadding = this.isHorizontal ? Number.parseFloat(containerStyle.scrollPaddingLeft) : Number.parseFloat(containerStyle.scrollPaddingTop);
+					target = (this.isHorizontal ? rect.left : rect.top) + this.animatedScroll - (Number.isNaN(scrollMargin) ? 0 : scrollMargin) - (Number.isNaN(scrollPadding) ? 0 : scrollPadding);
+				}
+			}
+			if (typeof target !== "number") return;
+			target += adjustedOffset;
+			target = Math.round(target);
+			if (this.options.infinite) {
+				if (programmatic) {
+					this.targetScroll = this.animatedScroll = this.scroll;
+					const distance = target - this.animatedScroll;
+					if (distance > this.limit / 2) target -= this.limit;
+					else if (distance < -this.limit / 2) target += this.limit;
+				}
+			} else target = clamp(0, target, this.limit);
+			if (target === this.targetScroll) {
+				onStart?.(this);
+				onComplete?.(this);
+				return;
+			}
+			this.userData = userData ?? {};
+			if (immediate) {
+				this.animatedScroll = this.targetScroll = target;
+				this.setScroll(this.scroll);
+				this.reset();
+				this.preventNextNativeScrollEvent();
+				this.emit();
+				onComplete?.(this);
+				this.userData = {};
+				requestAnimationFrame(() => {
+					this.dispatchScrollendEvent();
+				});
+				return;
+			}
+			if (!programmatic) this.targetScroll = target;
+			if (typeof duration === "number" && typeof easing !== "function") easing = defaultEasing;
+			else if (typeof easing === "function" && typeof duration !== "number") duration = 1;
+			this.animate.fromTo(this.animatedScroll, target, {
+				duration,
+				easing,
+				lerp,
+				onStart: () => {
+					if (lock) this.isLocked = true;
+					this.isScrolling = "smooth";
+					onStart?.(this);
+				},
+				onUpdate: (value, completed) => {
+					this.isScrolling = "smooth";
+					this.lastVelocity = this.velocity;
+					this.velocity = value - this.animatedScroll;
+					this.direction = Math.sign(this.velocity);
+					this.animatedScroll = value;
+					this.setScroll(this.scroll);
+					if (programmatic) this.targetScroll = value;
+					if (!completed) this.emit();
+					if (completed) {
+						this.reset();
+						this.emit();
+						onComplete?.(this);
+						this.userData = {};
+						requestAnimationFrame(() => {
+							this.dispatchScrollendEvent();
+						});
+						this.preventNextNativeScrollEvent();
+					}
+				}
+			});
+		}
+		preventNextNativeScrollEvent() {
+			this._preventNextNativeScrollEvent = true;
+			requestAnimationFrame(() => {
+				this._preventNextNativeScrollEvent = false;
+			});
+		}
+		hasNestedScroll(node, { deltaX, deltaY }) {
+			const time = Date.now();
+			if (!node._lenis) node._lenis = {};
+			const cache = node._lenis;
+			let hasOverflowX;
+			let hasOverflowY;
+			let isScrollableX;
+			let isScrollableY;
+			let hasOverscrollBehaviorX;
+			let hasOverscrollBehaviorY;
+			let scrollWidth;
+			let scrollHeight;
+			let clientWidth;
+			let clientHeight;
+			if (time - (cache.time ?? 0) > 2e3) {
+				cache.time = Date.now();
+				const computedStyle = window.getComputedStyle(node);
+				cache.computedStyle = computedStyle;
+				hasOverflowX = [
+					"auto",
+					"overlay",
+					"scroll"
+				].includes(computedStyle.overflowX);
+				hasOverflowY = [
+					"auto",
+					"overlay",
+					"scroll"
+				].includes(computedStyle.overflowY);
+				hasOverscrollBehaviorX = ["auto"].includes(computedStyle.overscrollBehaviorX);
+				hasOverscrollBehaviorY = ["auto"].includes(computedStyle.overscrollBehaviorY);
+				cache.hasOverflowX = hasOverflowX;
+				cache.hasOverflowY = hasOverflowY;
+				if (!(hasOverflowX || hasOverflowY)) return false;
+				scrollWidth = node.scrollWidth;
+				scrollHeight = node.scrollHeight;
+				clientWidth = node.clientWidth;
+				clientHeight = node.clientHeight;
+				isScrollableX = scrollWidth > clientWidth;
+				isScrollableY = scrollHeight > clientHeight;
+				cache.isScrollableX = isScrollableX;
+				cache.isScrollableY = isScrollableY;
+				cache.scrollWidth = scrollWidth;
+				cache.scrollHeight = scrollHeight;
+				cache.clientWidth = clientWidth;
+				cache.clientHeight = clientHeight;
+				cache.hasOverscrollBehaviorX = hasOverscrollBehaviorX;
+				cache.hasOverscrollBehaviorY = hasOverscrollBehaviorY;
+			} else {
+				isScrollableX = cache.isScrollableX;
+				isScrollableY = cache.isScrollableY;
+				hasOverflowX = cache.hasOverflowX;
+				hasOverflowY = cache.hasOverflowY;
+				scrollWidth = cache.scrollWidth;
+				scrollHeight = cache.scrollHeight;
+				clientWidth = cache.clientWidth;
+				clientHeight = cache.clientHeight;
+				hasOverscrollBehaviorX = cache.hasOverscrollBehaviorX;
+				hasOverscrollBehaviorY = cache.hasOverscrollBehaviorY;
+			}
+			if (!(hasOverflowX && isScrollableX || hasOverflowY && isScrollableY)) return false;
+			const orientation = Math.abs(deltaX) >= Math.abs(deltaY) ? "horizontal" : "vertical";
+			let scroll;
+			let maxScroll;
+			let delta;
+			let hasOverflow;
+			let isScrollable;
+			let hasOverscrollBehavior;
+			if (orientation === "horizontal") {
+				scroll = Math.round(node.scrollLeft);
+				maxScroll = scrollWidth - clientWidth;
+				delta = deltaX;
+				hasOverflow = hasOverflowX;
+				isScrollable = isScrollableX;
+				hasOverscrollBehavior = hasOverscrollBehaviorX;
+			} else if (orientation === "vertical") {
+				scroll = Math.round(node.scrollTop);
+				maxScroll = scrollHeight - clientHeight;
+				delta = deltaY;
+				hasOverflow = hasOverflowY;
+				isScrollable = isScrollableY;
+				hasOverscrollBehavior = hasOverscrollBehaviorY;
+			} else return false;
+			if (!hasOverscrollBehavior && (scroll >= maxScroll || scroll <= 0)) return true;
+			return (delta > 0 ? scroll < maxScroll : scroll > 0) && hasOverflow && isScrollable;
+		}
+		/**
+		* The root element on which lenis is instanced
+		*/
+		get rootElement() {
+			return this.options.wrapper === window ? document.documentElement : this.options.wrapper;
+		}
+		/**
+		* The limit which is the maximum scroll value
+		*/
+		get limit() {
+			if (this.options.naiveDimensions) {
+				if (this.isHorizontal) return this.rootElement.scrollWidth - this.rootElement.clientWidth;
+				return this.rootElement.scrollHeight - this.rootElement.clientHeight;
+			}
+			return this.dimensions.limit[this.isHorizontal ? "x" : "y"];
+		}
+		/**
+		* Whether or not the scroll is horizontal
+		*/
+		get isHorizontal() {
+			return this.options.orientation === "horizontal";
+		}
+		/**
+		* The actual scroll value
+		*/
+		get actualScroll() {
+			const wrapper = this.options.wrapper;
+			return this.isHorizontal ? wrapper.scrollX ?? wrapper.scrollLeft : wrapper.scrollY ?? wrapper.scrollTop;
+		}
+		/**
+		* The current scroll value
+		*/
+		get scroll() {
+			return this.options.infinite ? modulo(this.animatedScroll, this.limit) : this.animatedScroll;
+		}
+		/**
+		* The progress of the scroll relative to the limit
+		*/
+		get progress() {
+			return this.limit === 0 ? 1 : this.scroll / this.limit;
+		}
+		/**
+		* Current scroll state
+		*/
+		get isScrolling() {
+			return this._isScrolling;
+		}
+		set isScrolling(value) {
+			if (this._isScrolling !== value) {
+				this._isScrolling = value;
+				this.updateClassName();
+			}
+		}
+		/**
+		* Check if lenis is stopped
+		*/
+		get isStopped() {
+			return this._isStopped;
+		}
+		set isStopped(value) {
+			if (this._isStopped !== value) {
+				this._isStopped = value;
+				this.updateClassName();
+			}
+		}
+		/**
+		* Check if lenis is locked
+		*/
+		get isLocked() {
+			return this._isLocked;
+		}
+		set isLocked(value) {
+			if (this._isLocked !== value) {
+				this._isLocked = value;
+				this.updateClassName();
+			}
+		}
+		/**
+		* Check if lenis is smooth scrolling
+		*/
+		get isSmooth() {
+			return this.isScrolling === "smooth";
+		}
+		/**
+		* The class name applied to the wrapper element
+		*/
+		get className() {
+			let className = "lenis";
+			if (this.options.autoToggle) className += " lenis-autoToggle";
+			if (this.isStopped) className += " lenis-stopped";
+			if (this.isLocked) className += " lenis-locked";
+			if (this.isScrolling) className += " lenis-scrolling";
+			if (this.isScrolling === "smooth") className += " lenis-smooth";
+			return className;
+		}
+		updateClassName() {
+			this.cleanUpClassName();
+			this.rootElement.className = `${this.rootElement.className} ${this.className}`.trim();
+		}
+		cleanUpClassName() {
+			this.rootElement.className = this.rootElement.className.replace(/lenis(-\w+)?/g, "").trim();
+		}
+	};
+
+//#endregion
+//#region packages/core/browser.ts
+	globalThis.Lenis = Lenis;
+	globalThis.Lenis.prototype = Lenis.prototype;
+
+//#endregion
+})();
 //# sourceMappingURL=lenis.js.map