@design.estate/dees-domtools 2.1.1 → 2.3.0

package/dist_bundle/bundle.js

@@ -1180,7 +1180,7 @@ var require_punycode = __commonJS({
       if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
         root6 = freeGlobal;
       }
-      var punycode, maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = "-", regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
+      var punycode, maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp2 = 700, initialBias = 72, initialN = 128, delimiter = "-", regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
         "overflow": "Overflow: input needs wider integers to process",
         "not-basic": "Illegal input >= 0x80 (not a basic code point)",
         "invalid-input": "Invalid input"
@@ -1255,7 +1255,7 @@ var require_punycode = __commonJS({
       }
       function adapt(delta, numPoints, firstTime) {
         var k2 = 0;
-        delta = firstTime ? floor(delta / damp) : delta >> 1;
+        delta = firstTime ? floor(delta / damp2) : delta >> 1;
         delta += floor(delta / numPoints);
         for (; delta > baseMinusTMin * tMax >> 1; k2 += base) {
           delta = floor(delta / baseMinusTMin);
@@ -7898,12 +7898,12 @@ var require_dist_ts2 = __commonJS({
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.objectToYamlString = exports.yamlStringToObject = void 0;
-    var plugins3 = __importStar(require_smartyaml_plugins());
+    var plugins2 = __importStar(require_smartyaml_plugins());
     exports.yamlStringToObject = async (yamlStringArg, optionsArg = {}) => {
-      return plugins3.jsYaml.safeLoad(yamlStringArg);
+      return plugins2.jsYaml.safeLoad(yamlStringArg);
     };
     exports.objectToYamlString = async (objectArg, optionsArg = {}) => {
-      return plugins3.jsYaml.safeDump(objectArg);
+      return plugins2.jsYaml.safeDump(objectArg);
     };
   }
 });
@@ -9175,7 +9175,7 @@ __export(dist_ts_exports2, {
   delayForRandom: () => delayForRandom
 });
 
-// node_modules/.pnpm/@push.rocks+smartpromise@4.1.0/node_modules/@push.rocks/smartpromise/dist_ts/index.js
+// node_modules/.pnpm/@push.rocks+smartpromise@4.2.2/node_modules/@push.rocks/smartpromise/dist_ts/index.js
 var dist_ts_exports = {};
 __export(dist_ts_exports, {
   CumulativeDeferred: () => CumulativeDeferred,
@@ -9191,7 +9191,7 @@ __export(dist_ts_exports, {
   timeoutWrap: () => timeoutWrap
 });
 
-// node_modules/.pnpm/@push.rocks+smartpromise@4.1.0/node_modules/@push.rocks/smartpromise/dist_ts/smartpromise.classes.deferred.js
+// node_modules/.pnpm/@push.rocks+smartpromise@4.2.2/node_modules/@push.rocks/smartpromise/dist_ts/smartpromise.classes.deferred.js
 var Deferred = class {
   claim() {
     if (this.claimed) {
@@ -9228,7 +9228,7 @@ var defer = () => {
   return new Deferred();
 };
 
-// node_modules/.pnpm/@push.rocks+smartpromise@4.1.0/node_modules/@push.rocks/smartpromise/dist_ts/smartpromise.classes.cumulativedeferred.js
+// node_modules/.pnpm/@push.rocks+smartpromise@4.2.2/node_modules/@push.rocks/smartpromise/dist_ts/smartpromise.classes.cumulativedeferred.js
 var CumulativeDeferred = class {
   constructor() {
     this.accumulatedPromises = [];
@@ -9242,6 +9242,11 @@ var CumulativeDeferred = class {
       this.deferred.resolve();
     }, 0);
   }
+  subDefer() {
+    const done = defer();
+    this.addPromise(done.promise);
+    return done;
+  }
   addPromise(promiseArg) {
     this.accumulatedPromises.push(promiseArg);
   }
@@ -9250,7 +9255,7 @@ var cumulativeDefer = () => {
   return new CumulativeDeferred();
 };
 
-// node_modules/.pnpm/@push.rocks+smartpromise@4.1.0/node_modules/@push.rocks/smartpromise/dist_ts/index.js
+// node_modules/.pnpm/@push.rocks+smartpromise@4.2.2/node_modules/@push.rocks/smartpromise/dist_ts/index.js
 var resolvedPromise = (value2) => {
   return Promise.resolve(value2);
 };
@@ -21035,8 +21040,8 @@ function wrap(value2) {
   return newValue;
 }
 var unwrap = (value2) => reverseTransformCache.get(value2);
-function openDB(name, version2, { blocked, upgrade, blocking, terminated } = {}) {
-  const request = indexedDB.open(name, version2);
+function openDB(name, version3, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version3);
   const openPromise = wrap(request);
   if (upgrade) {
     request.addEventListener("upgradeneeded", (event) => {
@@ -24449,16 +24454,16 @@ var Processor = class _Processor extends CallableInstance {
         namespace.settings = (0, import_extend.default)(true, namespace.settings, result.settings);
       }
     }
-    function addList(plugins3) {
+    function addList(plugins2) {
       let index2 = -1;
-      if (plugins3 === null || plugins3 === void 0) {
-      } else if (Array.isArray(plugins3)) {
-        while (++index2 < plugins3.length) {
-          const thing = plugins3[index2];
+      if (plugins2 === null || plugins2 === void 0) {
+      } else if (Array.isArray(plugins2)) {
+        while (++index2 < plugins2.length) {
+          const thing = plugins2[index2];
           add2(thing);
         }
       } else {
-        throw new TypeError("Expected a list of plugins, not `" + plugins3 + "`");
+        throw new TypeError("Expected a list of plugins, not `" + plugins2 + "`");
       }
     }
     function addPlugin(plugin, parameters2) {
@@ -39424,6 +39429,923 @@ var Stringmap2 = class {
   }
 };
 
+// node_modules/.pnpm/lenis@1.1.20/node_modules/lenis/dist/lenis.mjs
+var version2 = "1.1.20";
+function clamp2(min2, input, max2) {
+  return Math.max(min2, Math.min(input, max2));
+}
+function lerp(x2, y4, t3) {
+  return (1 - t3) * x2 + t3 * y4;
+}
+function damp(x2, y4, lambda, deltaTime) {
+  return lerp(x2, y4, 1 - Math.exp(-lambda * deltaTime));
+}
+function modulo(n5, d4) {
+  return (n5 % d4 + d4) % d4;
+}
+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 = clamp2(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(from2, to, { lerp: lerp2, duration, easing, onStart, onUpdate }) {
+    this.from = this.value = from2;
+    this.to = to;
+    this.lerp = lerp2;
+    this.duration = duration;
+    this.easing = easing;
+    this.currentTime = 0;
+    this.isRunning = true;
+    onStart?.();
+    this.onUpdate = onUpdate;
+  }
+};
+function debounce2(callback, delay) {
+  let timer2;
+  return function(...args) {
+    let context2 = this;
+    clearTimeout(timer2);
+    timer2 = setTimeout(() => {
+      timer2 = void 0;
+      callback.apply(context2, args);
+    }, delay);
+  };
+}
+var Dimensions = class {
+  constructor(wrapper, content3, { autoResize = true, debounce: debounceValue = 250 } = {}) {
+    this.wrapper = wrapper;
+    this.content = content3;
+    if (autoResize) {
+      this.debouncedResize = debounce2(this.resize, debounceValue);
+      if (this.wrapper instanceof Window) {
+        window.addEventListener("resize", this.debouncedResize, false);
+      } 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, false);
+    }
+  }
+  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
+    };
+  }
+};
+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) {
+    let callbacks = this.events[event] || [];
+    for (let i5 = 0, length = callbacks.length; i5 < length; i5++) {
+      callbacks[i5]?.(...args);
+    }
+  }
+  /**
+   * Add a callback to the event
+   * @param event Event name
+   * @param cb Callback function
+   * @returns Unsubscribe function
+   */
+  on(event, cb) {
+    this.events[event]?.push(cb) || (this.events[event] = [cb]);
+    return () => {
+      this.events[event] = this.events[event]?.filter((i5) => cb !== i5);
+    };
+  }
+  /**
+   * Remove a callback from the event
+   * @param event Event name
+   * @param callback Callback function
+   */
+  off(event, callback) {
+    this.events[event] = this.events[event]?.filter((i5) => callback !== i5);
+  }
+  /**
+   * Remove all event listeners and clean up
+   */
+  destroy() {
+    this.events = {};
+  }
+};
+var LINE_HEIGHT = 100 / 6;
+var listenerOptions = { passive: false };
+var VirtualScroll = class {
+  constructor(element4, options = { wheelMultiplier: 1, touchMultiplier: 1 }) {
+    this.element = element4;
+    this.options = options;
+    window.addEventListener("resize", this.onWindowResize, false);
+    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, false);
+    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 = deltaMode === 1 ? LINE_HEIGHT : deltaMode === 2 ? this.window.width : 1;
+    const multiplierY = deltaMode === 1 ? LINE_HEIGHT : deltaMode === 2 ? this.window.height : 1;
+    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
+    };
+  };
+};
+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: content3 = document.documentElement,
+    eventsTarget = wrapper,
+    smoothWheel = true,
+    syncTouch = false,
+    syncTouchLerp = 0.075,
+    touchInertiaMultiplier = 35,
+    duration,
+    // in seconds
+    easing = (t3) => Math.min(1, 1.001 - Math.pow(2, -10 * t3)),
+    lerp: lerp2 = 0.1,
+    infinite = false,
+    orientation = "vertical",
+    // vertical, horizontal
+    gestureOrientation = "vertical",
+    // vertical, horizontal, both
+    touchMultiplier = 1,
+    wheelMultiplier = 1,
+    autoResize = true,
+    prevent,
+    virtualScroll,
+    overscroll = true,
+    autoRaf = false,
+    anchors = false,
+    __experimental__naiveDimensions = false
+  } = {}) {
+    window.lenisVersion = version2;
+    if (!wrapper || wrapper === document.documentElement) {
+      wrapper = window;
+    }
+    this.options = {
+      wrapper,
+      content: content3,
+      eventsTarget,
+      smoothWheel,
+      syncTouch,
+      syncTouchLerp,
+      touchInertiaMultiplier,
+      duration,
+      easing,
+      lerp: lerp2,
+      infinite,
+      gestureOrientation,
+      orientation,
+      touchMultiplier,
+      wheelMultiplier,
+      autoResize,
+      prevent,
+      virtualScroll,
+      overscroll,
+      autoRaf,
+      anchors,
+      __experimental__naiveDimensions
+    };
+    this.dimensions = new Dimensions(wrapper, content3, { autoResize });
+    this.updateClassName();
+    this.targetScroll = this.animatedScroll = this.actualScroll;
+    this.options.wrapper.addEventListener("scroll", this.onNativeScroll, false);
+    this.options.wrapper.addEventListener("scrollend", this.onScrollEnd, {
+      capture: true
+    });
+    if (this.options.anchors && this.options.wrapper === window) {
+      this.options.wrapper.addEventListener(
+        "click",
+        this.onClick,
+        false
+      );
+    }
+    this.options.wrapper.addEventListener(
+      "pointerdown",
+      this.onPointerDown,
+      false
+    );
+    this.virtualScroll = new VirtualScroll(eventsTarget, {
+      touchMultiplier,
+      wheelMultiplier
+    });
+    this.virtualScroll.on("scroll", this.onVirtualScroll);
+    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,
+      false
+    );
+    this.options.wrapper.removeEventListener("scrollend", this.onScrollEnd, {
+      capture: true
+    });
+    this.options.wrapper.removeEventListener(
+      "pointerdown",
+      this.onPointerDown,
+      false
+    );
+    if (this.options.anchors && this.options.wrapper === window) {
+      this.options.wrapper.removeEventListener(
+        "click",
+        this.onClick,
+        false
+      );
+    }
+    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 = (e4) => {
+    if (!(e4 instanceof CustomEvent)) {
+      if (this.isScrolling === "smooth" || this.isScrolling === false) {
+        e4.stopPropagation();
+      }
+    }
+  };
+  dispatchScrollendEvent = () => {
+    this.options.wrapper.dispatchEvent(
+      new CustomEvent("scrollend", {
+        bubbles: this.options.wrapper === window,
+        // cancelable: false,
+        detail: {
+          lenisScrollEnd: true
+        }
+      })
+    );
+  };
+  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 path3 = event.composedPath();
+    const anchor = path3.find(
+      (node2) => node2 instanceof HTMLAnchorElement && node2.getAttribute("href")?.startsWith("#")
+    );
+    if (anchor) {
+      const id = anchor.getAttribute("href");
+      if (id) {
+        const options = typeof this.options.anchors === "object" && this.options.anchors ? this.options.anchors : void 0;
+        this.scrollTo(id, options);
+      }
+    }
+  };
+  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;
+    if (!!composedPath.find(
+      (node2) => node2 instanceof HTMLElement && (typeof prevent === "function" && prevent?.(node2) || node2.hasAttribute?.("data-lenis-prevent") || isTouch && node2.hasAttribute?.("data-lenis-prevent-touch") || isWheel && node2.hasAttribute?.("data-lenis-prevent-wheel"))
+    ))
+      return;
+    if (this.isStopped || this.isLocked) {
+      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.animatedScroll > 0 && this.animatedScroll < this.limit || this.animatedScroll === 0 && deltaY > 0 || this.animatedScroll === this.limit && deltaY < 0)) {
+      event.lenisStopPropagation = true;
+    }
+    event.preventDefault();
+    const isSyncTouch = isTouch && this.options.syncTouch;
+    const isTouchEnd = isTouch && event.type === "touchend";
+    const hasTouchInertia = isTouchEnd && Math.abs(delta) > 5;
+    if (hasTouchInertia) {
+      delta = this.velocity * this.options.touchInertiaMultiplier;
+    }
+    this.scrollTo(this.targetScroll + delta, {
+      programmatic: false,
+      ...isSyncTouch ? {
+        lerp: hasTouchInertia ? this.options.syncTouchLerp : 1
+        // immediate: !hasTouchInertia,
+      } : {
+        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;
+    this.reset();
+    this.isStopped = false;
+  }
+  /**
+   * Stop lenis scroll
+   */
+  stop() {
+    if (this.isStopped) return;
+    this.reset();
+    this.isStopped = true;
+  }
+  /**
+   * 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,
+    duration = this.options.duration,
+    easing = this.options.easing,
+    lerp: lerp2 = this.options.lerp,
+    onStart,
+    onComplete,
+    force = false,
+    // scroll even if stopped
+    programmatic = true,
+    // called from outside of the class
+    userData
+  } = {}) {
+    if ((this.isStopped || this.isLocked) && !force) return;
+    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 node2;
+      if (typeof target === "string") {
+        node2 = document.querySelector(target);
+      } else if (target instanceof HTMLElement && target?.nodeType) {
+        node2 = target;
+      }
+      if (node2) {
+        if (this.options.wrapper !== window) {
+          const wrapperRect = this.rootElement.getBoundingClientRect();
+          offset -= this.isHorizontal ? wrapperRect.left : wrapperRect.top;
+        }
+        const rect = node2.getBoundingClientRect();
+        target = (this.isHorizontal ? rect.left : rect.top) + this.animatedScroll;
+      }
+    }
+    if (typeof target !== "number") return;
+    target += offset;
+    target = Math.round(target);
+    if (this.options.infinite) {
+      if (programmatic) {
+        this.targetScroll = this.animatedScroll = this.scroll;
+      }
+    } else {
+      target = clamp2(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;
+    }
+    this.animate.fromTo(this.animatedScroll, target, {
+      duration,
+      easing,
+      lerp: lerp2,
+      onStart: () => {
+        if (lock) this.isLocked = true;
+        this.isScrolling = "smooth";
+        onStart?.(this);
+      },
+      onUpdate: (value2, completed) => {
+        this.isScrolling = "smooth";
+        this.lastVelocity = this.velocity;
+        this.velocity = value2 - this.animatedScroll;
+        this.direction = Math.sign(this.velocity);
+        this.animatedScroll = value2;
+        this.setScroll(this.scroll);
+        if (programmatic) {
+          this.targetScroll = value2;
+        }
+        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;
+    });
+  }
+  /**
+   * 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.__experimental__naiveDimensions) {
+      if (this.isHorizontal) {
+        return this.rootElement.scrollWidth - this.rootElement.clientWidth;
+      } else {
+        return this.rootElement.scrollHeight - this.rootElement.clientHeight;
+      }
+    } else {
+      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(value2) {
+    if (this._isScrolling !== value2) {
+      this._isScrolling = value2;
+      this.updateClassName();
+    }
+  }
+  /**
+   * Check if lenis is stopped
+   */
+  get isStopped() {
+    return this._isStopped;
+  }
+  set isStopped(value2) {
+    if (this._isStopped !== value2) {
+      this._isStopped = value2;
+      this.updateClassName();
+    }
+  }
+  /**
+   * Check if lenis is locked
+   */
+  get isLocked() {
+    return this._isLocked;
+  }
+  set isLocked(value2) {
+    if (this._isLocked !== value2) {
+      this._isLocked = value2;
+      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.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();
+  }
+};
+
 // ts/domtools.plugins.ts
 var import_sweet_scroll = __toESM(require_sweet_scroll(), 1);
 var lik = {
@@ -39432,6 +40354,143 @@ var lik = {
   FastMap: FastMap2
 };
 
+// ts/domtools.classes.scroller.ts
+var Scroller = class {
+  constructor(domtoolsInstanceArg) {
+    // Array to store scroll callback functions.
+    this.scrollCallbacks = [];
+    // Lenis instance (if activated) or null.
+    this.lenisInstance = null;
+    // Bound handlers to allow removal from event listeners.
+    this.handleNativeScroll = (event) => {
+      this.executeScrollCallbacks();
+    };
+    this.handleLenisScroll = (info) => {
+      this.executeScrollCallbacks();
+    };
+    this.sweetScroller = new import_sweet_scroll.default({});
+    this.domtoolsInstance = domtoolsInstanceArg;
+    this.attachNativeScrollListener();
+  }
+  /**
+   * Scrolls to a given element with options.
+   */
+  async scrollToElement(elementArg, optionsArg) {
+    this.sweetScroller.toElement(elementArg, optionsArg);
+    await dist_ts_exports2.delayFor(optionsArg.duration);
+  }
+  /**
+   * Detects whether native smooth scrolling is enabled.
+   */
+  async detectNativeSmoothScroll() {
+    const done = dist_ts_exports.defer();
+    const sampleSize = 100;
+    const acceptableDeltaDifference = 3;
+    const minimumSmoothRatio = 0.75;
+    const eventDeltas = [];
+    function onWheel(event) {
+      eventDeltas.push(event.deltaY);
+      if (eventDeltas.length >= sampleSize) {
+        window.removeEventListener("wheel", onWheel);
+        analyzeEvents();
+      }
+    }
+    function analyzeEvents() {
+      const totalDiffs = eventDeltas.length - 1;
+      let smallDiffCount = 0;
+      for (let i5 = 0; i5 < totalDiffs; i5++) {
+        const diff = Math.abs(eventDeltas[i5 + 1] - eventDeltas[i5]);
+        if (diff <= acceptableDeltaDifference) {
+          smallDiffCount++;
+        }
+      }
+      const smoothRatio = smallDiffCount / totalDiffs;
+      if (smoothRatio >= minimumSmoothRatio) {
+        console.log("Smooth scrolling detected.");
+        done.resolve(true);
+      } else {
+        console.log("Smooth scrolling NOT detected.");
+        done.resolve(false);
+      }
+    }
+    window.addEventListener("wheel", onWheel);
+    return done.promise;
+  }
+  /**
+   * Enables Lenis scrolling.
+   * If optionsArg.disableOnNativeSmoothScroll is true and native smooth scrolling is detected,
+   * Lenis will be destroyed immediately.
+   */
+  async enableLenisScroll(optionsArg) {
+    const lenis = new Lenis({
+      autoRaf: true
+    });
+    if (optionsArg?.disableOnNativeSmoothScroll) {
+      if (await this.detectNativeSmoothScroll()) {
+        lenis.destroy();
+        return;
+      }
+    }
+    this.lenisInstance = lenis;
+    this.detachNativeScrollListener();
+    this.attachLenisScrollListener();
+    const originalDestroy = lenis.destroy.bind(lenis);
+    lenis.destroy = () => {
+      originalDestroy();
+      this.detachLenisScrollListener();
+      this.attachNativeScrollListener();
+      this.lenisInstance = null;
+    };
+  }
+  /**
+   * Registers a callback to be executed on scroll.
+   * @param callback A function to execute on each scroll event.
+   */
+  onScroll(callback) {
+    this.scrollCallbacks.push(callback);
+  }
+  /**
+   * Executes all registered scroll callbacks concurrently.
+   */
+  executeScrollCallbacks() {
+    this.scrollCallbacks.forEach((callback) => {
+      try {
+        callback();
+      } catch (error) {
+        console.error("Error in scroll callback:", error);
+      }
+    });
+  }
+  /**
+   * Attaches the native scroll event listener.
+   */
+  attachNativeScrollListener() {
+    window.addEventListener("scroll", this.handleNativeScroll, { passive: true });
+  }
+  /**
+   * Detaches the native scroll event listener.
+   */
+  detachNativeScrollListener() {
+    window.removeEventListener("scroll", this.handleNativeScroll);
+  }
+  /**
+   * Attaches the Lenis scroll event listener.
+   */
+  attachLenisScrollListener() {
+    if (this.lenisInstance) {
+      this.lenisInstance.on("scroll", this.handleLenisScroll);
+    }
+  }
+  /**
+   * Detaches the Lenis scroll event listener.
+   */
+  detachLenisScrollListener() {
+    if (this.lenisInstance) {
+      this.lenisInstance.off("scroll", this.handleLenisScroll);
+    }
+  }
+};
+
 // ts/domtools.classes.thememanager.ts
 var ThemeManager = class {
   constructor(domtoolsRefArg) {
@@ -39698,10 +40757,7 @@ var DomTools2 = class _DomTools {
       smarturl: dist_ts_exports22
     };
     this.deesComms = new dist_ts_exports16.DeesComms();
-    this.scroller = new import_sweet_scroll.default({
-      /* some options */
-    });
-    // TODO: switch to scroller class
+    this.scroller = new Scroller(this);
     this.themeManager = new ThemeManager(this);
     this.keyboard = new Keyboard(document.body);
     this.domToolsReady = dist_ts_exports.defer();