use-scroller 1.2.0 → 2.0.0

package/dist/chunk-BDIJT5M4.js

@@ -0,0 +1,1188 @@
+// src/core/types.ts
+var EDGE_TOLERANCE = 1;
+
+// src/core/geometry.ts
+var SCROLLABLE_OVERFLOW = ["auto", "scroll", "overlay"];
+function isWindow(target) {
+  return "scrollY" in target;
+}
+function readScroll(target) {
+  if (isWindow(target)) return readWindowScroll(target);
+  return readElementScroll(target);
+}
+function readWindowScroll(win) {
+  const root = win.document.documentElement;
+  const viewportWidth = root.clientWidth;
+  const viewportHeight = hasClassicScrollbar(win) ? root.clientHeight : win.innerHeight;
+  return {
+    x: win.scrollX,
+    y: win.scrollY,
+    ...horizontalRange(root, Math.max(0, root.scrollWidth - viewportWidth)),
+    maxY: Math.max(0, root.scrollHeight - viewportHeight),
+    viewportWidth,
+    viewportHeight
+  };
+}
+function hasClassicScrollbar(win) {
+  return win.innerWidth > win.document.documentElement.clientWidth;
+}
+function readElementScroll(element) {
+  return {
+    x: element.scrollLeft,
+    y: element.scrollTop,
+    ...horizontalRange(element, element.scrollWidth - element.clientWidth),
+    maxY: element.scrollHeight - element.clientHeight,
+    viewportWidth: element.clientWidth,
+    viewportHeight: element.clientHeight
+  };
+}
+function horizontalRange(element, max) {
+  if (getComputedStyle(element).direction === "rtl") return { minX: -max, maxX: 0 };
+  return { minX: 0, maxX: max };
+}
+function writeScroll(target, position) {
+  target.scrollTo({ left: position.x, top: position.y, behavior: "instant" });
+}
+function isScrollable(element, axis) {
+  const style = getComputedStyle(element);
+  const overflow = axis === "x" ? style.overflowX : style.overflowY;
+  if (!SCROLLABLE_OVERFLOW.includes(overflow)) return false;
+  const overflowAmount = axis === "x" ? element.scrollWidth - element.clientWidth : element.scrollHeight - element.clientHeight;
+  return overflowAmount > EDGE_TOLERANCE;
+}
+function findScrollParent(element, axis) {
+  const root = element.ownerDocument.documentElement;
+  for (let el = element.parentElement; el && el !== root; el = el.parentElement) {
+    if (isScrollable(el, axis)) return el;
+  }
+  return window;
+}
+
+// src/core/easings.ts
+var easings = {
+  linear: (t) => t,
+  easeInCubic: (t) => t * t * t,
+  easeOutCubic: (t) => 1 - (1 - t) ** 3,
+  easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2
+};
+var PRECISION = 1e-7;
+var NEWTON_ITERATIONS = 8;
+var MIN_SLOPE = 1e-6;
+function cubicBezier(x1, y1, x2, y2) {
+  if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) {
+    throw new RangeError(`cubicBezier: x1 and x2 must be within [0, 1], got ${x1} and ${x2}`);
+  }
+  const xCurve = polynomial(x1, x2);
+  const yCurve = polynomial(y1, y2);
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    return sample(yCurve, solveForParameter(xCurve, t));
+  };
+}
+function polynomial(p1, p2) {
+  const c = 3 * p1;
+  const b = 3 * (p2 - p1) - c;
+  return { a: 1 - c - b, b, c };
+}
+function sample({ a, b, c }, t) {
+  return ((a * t + b) * t + c) * t;
+}
+function slope({ a, b, c }, t) {
+  return (3 * a * t + 2 * b) * t + c;
+}
+function solveForParameter(curve, x) {
+  var _a;
+  return (_a = newton(curve, x)) != null ? _a : bisect(curve, x);
+}
+function newton(curve, x) {
+  let t = x;
+  for (let i = 0; i < NEWTON_ITERATIONS; i++) {
+    const error = sample(curve, t) - x;
+    if (Math.abs(error) < PRECISION) return t;
+    const derivative = slope(curve, t);
+    if (Math.abs(derivative) < MIN_SLOPE) return null;
+    t -= error / derivative;
+    if (t < 0 || t > 1) return null;
+  }
+  return null;
+}
+function bisect(curve, x) {
+  let low = 0;
+  let high = 1;
+  let t = x;
+  while (high - low > PRECISION) {
+    const value = sample(curve, t);
+    if (Math.abs(value - x) < PRECISION) return t;
+    if (value < x) low = t;
+    else high = t;
+    t = (low + high) / 2;
+  }
+  return t;
+}
+
+// src/core/inline-style.ts
+function setInlineStyles(element, styles) {
+  const previous = Object.keys(styles).map((property) => ({
+    property,
+    value: element.style.getPropertyValue(property),
+    priority: element.style.getPropertyPriority(property)
+  }));
+  for (const [property, value] of Object.entries(styles)) element.style.setProperty(property, value);
+  return () => {
+    for (const { property, value, priority } of previous) {
+      if (value) element.style.setProperty(property, value, priority);
+      else element.style.removeProperty(property);
+    }
+  };
+}
+
+// src/core/animate-scroll.ts
+var AXES = ["x", "y"];
+var INTERRUPT_EVENTS = ["wheel", "touchstart", "pointerdown", "keydown"];
+var SPRING_STEP_MS = 1e3 / 120;
+var SETTLE_DISTANCE = 0.5;
+var SETTLE_SPEED = 10;
+var running = /* @__PURE__ */ new WeakMap();
+function animateScroll(target, to, options = {}) {
+  const {
+    animation = { type: "tween" },
+    interruptible = true,
+    respectReducedMotion = true
+  } = options;
+  cancelScroll(target);
+  if (animation.type === "instant" || respectReducedMotion && prefersReducedMotion()) {
+    return jump(target, to);
+  }
+  const createMotion = animation.type === "tween" ? tween(animation) : spring(animation);
+  return run(target, to, createMotion, interruptible);
+}
+function cancelScroll(target) {
+  var _a;
+  (_a = running.get(target)) == null ? void 0 : _a.cancel();
+}
+function scrollDestination(target) {
+  const metrics = readScroll(target);
+  const current = { x: metrics.x, y: metrics.y };
+  const active = running.get(target);
+  return active ? resolveGoal(active.to, current, metrics) : current;
+}
+function clampToRange(metrics, axis, value) {
+  const min = axis === "x" ? metrics.minX : 0;
+  const max = axis === "x" ? metrics.maxX : metrics.maxY;
+  return Math.min(max, Math.max(min, value));
+}
+function resolveGoal(to, fallback, metrics) {
+  return {
+    x: to.x === void 0 ? fallback.x : clampToRange(metrics, "x", to.x),
+    y: to.y === void 0 ? fallback.y : clampToRange(metrics, "y", to.y)
+  };
+}
+function requestedAxes(to, position) {
+  return {
+    x: to.x === void 0 ? void 0 : position.x,
+    y: to.y === void 0 ? void 0 : position.y
+  };
+}
+function prefersReducedMotion() {
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function jump(target, to) {
+  const metrics = readScroll(target);
+  writeScroll(target, requestedAxes(to, resolveGoal(to, metrics, metrics)));
+  return {
+    finished: Promise.resolve("completed"),
+    cancel() {
+    }
+  };
+}
+function run(target, to, createMotion, interruptible) {
+  const snapElement = isWindow(target) ? target.document.documentElement : target;
+  const restoreSnap = suspendSnap(snapElement);
+  const eventTarget = target;
+  const start = readScroll(target);
+  const from = { x: start.x, y: start.y };
+  const motion = createMotion(from);
+  const startedAt = performance.now();
+  let frame = requestAnimationFrame(step);
+  let stopped = false;
+  let resolveFinished;
+  const finished = new Promise((resolve) => resolveFinished = resolve);
+  const entry = { to, cancel: () => stop("cancelled") };
+  const interrupt = () => stop("interrupted");
+  function step(now) {
+    const metrics = readScroll(target);
+    const { position, done } = motion(Math.max(0, now - startedAt), resolveGoal(to, from, metrics));
+    writeScroll(target, requestedAxes(to, position));
+    if (done) stop("completed");
+    else frame = requestAnimationFrame(step);
+  }
+  function stop(result) {
+    if (stopped) return;
+    stopped = true;
+    cancelAnimationFrame(frame);
+    for (const type of INTERRUPT_EVENTS) eventTarget.removeEventListener(type, interrupt);
+    restoreSnap == null ? void 0 : restoreSnap();
+    if (running.get(target) === entry) running.delete(target);
+    resolveFinished(result);
+  }
+  if (interruptible) {
+    for (const type of INTERRUPT_EVENTS) {
+      eventTarget.addEventListener(type, interrupt, { passive: true });
+    }
+  }
+  running.set(target, entry);
+  return { finished, cancel: entry.cancel };
+}
+function suspendSnap(element) {
+  if (getComputedStyle(element).scrollSnapType === "none") return null;
+  return setInlineStyles(element, { "scroll-snap-type": "none" });
+}
+function tween({ duration = 450, easing = easings.easeOutCubic }) {
+  if (!(duration >= 0)) {
+    throw new RangeError(`animateScroll: tween duration must be >= 0, got ${duration}`);
+  }
+  return (from) => (elapsed, goal) => {
+    const progress2 = duration > 0 ? Math.min(1, elapsed / duration) : 1;
+    if (progress2 === 1) return { position: goal, done: true };
+    const eased = easing(progress2);
+    return {
+      position: { x: from.x + (goal.x - from.x) * eased, y: from.y + (goal.y - from.y) * eased },
+      done: false
+    };
+  };
+}
+function spring({
+  stiffness = 170,
+  damping = 26,
+  mass = 1,
+  velocity: initial = {}
+}) {
+  for (const [name, value] of Object.entries({ stiffness, damping, mass })) {
+    if (!(value > 0)) {
+      throw new RangeError(`animateScroll: spring ${name} must be > 0, got ${value}`);
+    }
+  }
+  return (from) => {
+    var _a, _b;
+    const position = { ...from };
+    const velocity = { x: (_a = initial.x) != null ? _a : 0, y: (_b = initial.y) != null ? _b : 0 };
+    const dt = SPRING_STEP_MS / 1e3;
+    let stepsTaken = 0;
+    return (elapsed, goal) => {
+      for (; stepsTaken < Math.floor(elapsed / SPRING_STEP_MS); stepsTaken++) {
+        for (const axis of AXES) {
+          const force = -stiffness * (position[axis] - goal[axis]) - damping * velocity[axis];
+          velocity[axis] += force / mass * dt;
+          position[axis] += velocity[axis] * dt;
+        }
+      }
+      const settled = AXES.every(
+        (axis) => Math.abs(position[axis] - goal[axis]) < SETTLE_DISTANCE && Math.abs(velocity[axis]) < SETTLE_SPEED
+      );
+      return settled ? { position: goal, done: true } : { position: { ...position }, done: false };
+    };
+  };
+}
+
+// src/core/observe-scroll.ts
+var IDLE_MOTION = {
+  directionX: 0,
+  directionY: 0,
+  velocityX: 0,
+  velocityY: 0,
+  isScrolling: false
+};
+var initialScrollState = {
+  x: 0,
+  y: 0,
+  minX: 0,
+  maxX: 0,
+  maxY: 0,
+  progressX: 0,
+  progressY: 0,
+  atTop: true,
+  atBottom: true,
+  atLeft: true,
+  atRight: true,
+  canScrollX: false,
+  canScrollY: false,
+  ...IDLE_MOTION
+};
+var MAX_TIMEOUT_MS = 2147483647;
+var STATE_KEYS = Object.keys(initialScrollState);
+function observeScroll(target, listener, { idleDelay = 120 } = {}) {
+  if (!(idleDelay >= 0 && idleDelay <= MAX_TIMEOUT_MS)) {
+    throw new RangeError(
+      `observeScroll: idleDelay must be between 0 and ${MAX_TIMEOUT_MS} ms, got ${idleDelay}`
+    );
+  }
+  let state = { ...describePosition(readScroll(target)), ...IDLE_MOTION };
+  let sampledAt = performance.now();
+  let scrolling = false;
+  let scrolledSinceUpdate = false;
+  let frame = null;
+  let idleTimer;
+  function update() {
+    const now = performance.now();
+    const metrics = readScroll(target);
+    const next = nextState(state, metrics, scrolling, currentVelocity(metrics, now - sampledAt));
+    sampledAt = now;
+    scrolledSinceUpdate = false;
+    if (sameState(state, next)) return;
+    state = next;
+    listener(state);
+  }
+  function currentVelocity(metrics, elapsedMs) {
+    if (!scrolling) return { velocityX: 0, velocityY: 0 };
+    if (!scrolledSinceUpdate) return { velocityX: state.velocityX, velocityY: state.velocityY };
+    return {
+      velocityX: speed(metrics.x - state.x, elapsedMs),
+      velocityY: speed(metrics.y - state.y, elapsedMs)
+    };
+  }
+  function scheduleUpdate() {
+    if (frame !== null) return;
+    frame = requestAnimationFrame(() => {
+      frame = null;
+      update();
+    });
+  }
+  function settle() {
+    scrolling = false;
+    update();
+  }
+  function onScroll() {
+    scrolling = true;
+    scrolledSinceUpdate = true;
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(settle, idleDelay);
+    scheduleUpdate();
+  }
+  target.addEventListener("scroll", onScroll, { passive: true });
+  const stopWatchingSize = isWindow(target) ? watchWindowSize(target, scheduleUpdate) : watchElementSize(target, scheduleUpdate);
+  listener(state);
+  return () => {
+    target.removeEventListener("scroll", onScroll);
+    stopWatchingSize();
+    if (frame !== null) cancelAnimationFrame(frame);
+    clearTimeout(idleTimer);
+  };
+}
+function describePosition(metrics) {
+  const { x, y, minX, maxX, maxY } = metrics;
+  const rangeX = maxX - minX;
+  return {
+    x,
+    y,
+    minX,
+    maxX,
+    maxY,
+    progressX: progress(x - minX, rangeX),
+    progressY: progress(y, maxY),
+    atTop: y <= EDGE_TOLERANCE,
+    atBottom: y >= maxY - EDGE_TOLERANCE,
+    atLeft: x <= minX + EDGE_TOLERANCE,
+    atRight: x >= maxX - EDGE_TOLERANCE,
+    canScrollX: rangeX > EDGE_TOLERANCE,
+    canScrollY: maxY > EDGE_TOLERANCE
+  };
+}
+function progress(offset, range) {
+  if (range <= EDGE_TOLERANCE) return 0;
+  return Math.min(1, Math.max(0, offset / range));
+}
+function nextState(previous, metrics, isScrolling, velocity) {
+  return {
+    ...describePosition(metrics),
+    directionX: directionOf(metrics.x - previous.x, previous.directionX),
+    directionY: directionOf(metrics.y - previous.y, previous.directionY),
+    ...velocity,
+    isScrolling
+  };
+}
+function directionOf(delta, previous) {
+  if (delta > 0) return 1;
+  if (delta < 0) return -1;
+  return previous;
+}
+function speed(delta, elapsedMs) {
+  return elapsedMs > 0 ? delta / elapsedMs * 1e3 : 0;
+}
+function sameState(a, b) {
+  return STATE_KEYS.every((key) => a[key] === b[key]);
+}
+function watchElementSize(element, onResize) {
+  const resizeObserver = new ResizeObserver(onResize);
+  resizeObserver.observe(element);
+  for (const child of element.children) resizeObserver.observe(child);
+  const mutationObserver = new MutationObserver((records) => {
+    let changed = false;
+    for (const record of records) {
+      if (record.type === "characterData") {
+        if (record.target.parentNode === element) changed = true;
+        continue;
+      }
+      if (record.target !== element) continue;
+      changed = true;
+      for (const node of record.addedNodes) {
+        if (node instanceof Element) resizeObserver.observe(node);
+      }
+      for (const node of record.removedNodes) {
+        if (node instanceof Element) resizeObserver.unobserve(node);
+      }
+    }
+    if (changed) onResize();
+  });
+  mutationObserver.observe(element, { childList: true, subtree: true, characterData: true });
+  return () => {
+    resizeObserver.disconnect();
+    mutationObserver.disconnect();
+  };
+}
+function watchWindowSize(win, onResize) {
+  const { documentElement, body } = win.document;
+  const resizeObserver = new ResizeObserver(onResize);
+  resizeObserver.observe(documentElement);
+  resizeObserver.observe(body);
+  win.addEventListener("resize", onResize);
+  return () => {
+    resizeObserver.disconnect();
+    win.removeEventListener("resize", onResize);
+  };
+}
+
+// src/core/lock-scroll.ts
+var activeLocks = /* @__PURE__ */ new Set();
+var containedElements = /* @__PURE__ */ new Map();
+var unlockPage = null;
+function lockScroll({ allow = [] } = {}) {
+  const lock = { allow: [...allow] };
+  if (activeLocks.size === 0) unlockPage = lockPage();
+  activeLocks.add(lock);
+  syncContainment();
+  return () => {
+    if (!activeLocks.delete(lock)) return;
+    syncContainment();
+    if (activeLocks.size === 0) {
+      unlockPage == null ? void 0 : unlockPage();
+      unlockPage = null;
+    }
+  };
+}
+function lockPage() {
+  const { documentElement, body } = document;
+  const restoreBody = reservesScrollbarGutter(documentElement) ? noop : compensateScrollbar(documentElement, body);
+  const restoreRoot = setInlineStyles(documentElement, {
+    "overflow-x": "hidden",
+    "overflow-y": "hidden"
+  });
+  const stopGuarding = guardTouchScroll();
+  return () => {
+    stopGuarding();
+    restoreBody();
+    restoreRoot();
+  };
+}
+function reservesScrollbarGutter(root) {
+  return getComputedStyle(root).getPropertyValue("scrollbar-gutter").includes("stable");
+}
+function compensateScrollbar(root, body) {
+  const scrollbarWidth = window.innerWidth - root.clientWidth;
+  const paddingRight = parseFloat(getComputedStyle(body).paddingRight) + scrollbarWidth;
+  return setInlineStyles(body, { "padding-right": `${paddingRight}px` });
+}
+function noop() {
+}
+function syncContainment() {
+  const allowed = allowedElements();
+  for (const [element, restore] of containedElements) {
+    if (allowed.has(element)) continue;
+    restore();
+    containedElements.delete(element);
+  }
+  for (const element of allowed) {
+    if (containedElements.has(element)) continue;
+    containedElements.set(
+      element,
+      setInlineStyles(element, {
+        "overscroll-behavior-x": "contain",
+        "overscroll-behavior-y": "contain"
+      })
+    );
+  }
+}
+function allowedElements() {
+  const allowed = /* @__PURE__ */ new Set();
+  for (const lock of activeLocks) {
+    for (const element of lock.allow) allowed.add(element);
+  }
+  return allowed;
+}
+function guardTouchScroll() {
+  let previous = null;
+  function onTouchStart(event) {
+    previous = touchPoint(event);
+  }
+  function onTouchMove(event) {
+    const current = touchPoint(event);
+    const delta = previous && current ? { x: previous.x - current.x, y: previous.y - current.y } : null;
+    previous = current;
+    if (event.touches.length > 1) return;
+    if (!delta || !canScrollInside(event.target, delta)) event.preventDefault();
+  }
+  document.addEventListener("touchstart", onTouchStart, { passive: true });
+  document.addEventListener("touchmove", onTouchMove, { passive: false });
+  return () => {
+    document.removeEventListener("touchstart", onTouchStart);
+    document.removeEventListener("touchmove", onTouchMove);
+  };
+}
+function touchPoint(event) {
+  const touch = event.touches[0];
+  return touch ? { x: touch.clientX, y: touch.clientY } : null;
+}
+function canScrollInside(target, delta) {
+  if (!(target instanceof Element)) return false;
+  const boundary = outermostAllowedAncestor(target);
+  if (!boundary) return false;
+  const axis = Math.abs(delta.x) > Math.abs(delta.y) ? "x" : "y";
+  const scroller = nearestScroller(target, boundary, axis);
+  return scroller !== null && canScrollToward(scroller, axis, delta[axis]);
+}
+function outermostAllowedAncestor(target) {
+  const allowed = allowedElements();
+  let outermost = null;
+  for (let el = target; el; el = el.parentElement) {
+    if (el instanceof HTMLElement && allowed.has(el)) outermost = el;
+  }
+  return outermost;
+}
+function nearestScroller(target, boundary, axis) {
+  for (let el = target; el; el = el.parentElement) {
+    if (el instanceof HTMLElement && isScrollable(el, axis)) return el;
+    if (el === boundary) return null;
+  }
+  return null;
+}
+function canScrollToward(scroller, axis, delta) {
+  const { x, y, minX, maxX, maxY } = readScroll(scroller);
+  const [position, min, max] = axis === "x" ? [x, minX, maxX] : [y, 0, maxY];
+  if (delta > 0) return position < max - EDGE_TOLERANCE;
+  if (delta < 0) return position > min + EDGE_TOLERANCE;
+  return false;
+}
+
+// src/core/fling.ts
+var DECELERATION_PER_MS = 0.998;
+var MIN_FLING_VELOCITY = 50;
+var FRAME_MS = 1e3 / 60;
+var EASE_OUT_CUBIC_INITIAL_SLOPE = 3;
+function projectMomentum(velocity) {
+  return velocity / 1e3 * DECELERATION_PER_MS / (1 - DECELERATION_PER_MS);
+}
+function fling(target, axis, velocity) {
+  if (!(Math.abs(velocity) >= MIN_FLING_VELOCITY)) return null;
+  const metrics = readScroll(target);
+  const current = axis === "x" ? metrics.x : metrics.y;
+  const destination = clampToRange(metrics, axis, current + projectMomentum(velocity));
+  const duration = Math.max(
+    FRAME_MS,
+    EASE_OUT_CUBIC_INITIAL_SLOPE * Math.abs(destination - current) / Math.abs(velocity) * 1e3
+  );
+  return animateScroll(target, axis === "x" ? { x: destination } : { y: destination }, {
+    animation: { type: "tween", duration, easing: easings.easeOutCubic },
+    // Momentum carries on the user's own gesture, which native scrolling keeps under reduced motion.
+    respectReducedMotion: false
+  });
+}
+
+// src/core/snap.ts
+var FLICK_VELOCITY = 300;
+function readSnapPositions(container, axis) {
+  const containerStyle = getComputedStyle(container);
+  if (containerStyle.scrollSnapType === "none") return [];
+  const rightToLeft = axis === "x" && containerStyle.direction === "rtl";
+  const port = scrollport(container, axis);
+  const origin = contentOrigin(container, axis);
+  const metrics = readScroll(container);
+  const positions = /* @__PURE__ */ new Set();
+  for (const [child, style] of snapAreaCandidates(container)) {
+    const logical = snapAlignment(style.scrollSnapAlign, axis);
+    if (logical === null) continue;
+    const alignment = rightToLeft ? mirrored(logical) : logical;
+    const area = snapArea(child, style, origin, axis);
+    positions.add(clampToRange(metrics, axis, alignedPosition(area, port, alignment)));
+  }
+  return [...positions].sort((a, b) => a - b);
+}
+function* snapAreaCandidates(root) {
+  for (const child of root.children) {
+    const style = getComputedStyle(child);
+    yield [child, style];
+    if (style.scrollSnapType === "none") yield* snapAreaCandidates(child);
+  }
+}
+function pickSnapTarget(positions, current, projected, velocity) {
+  if (positions.length === 0) throw new RangeError("pickSnapTarget: positions must not be empty");
+  const nearest = positions.reduce(
+    (best, position) => Math.abs(position - projected) < Math.abs(best - projected) ? position : best
+  );
+  if (Math.abs(velocity) < FLICK_VELOCITY) return nearest;
+  const direction = Math.sign(velocity);
+  const isAhead = (position) => (position - current) * direction > EDGE_TOLERANCE;
+  if (isAhead(nearest)) return nearest;
+  const ahead = positions.filter(isAhead);
+  if (ahead.length === 0) return nearest;
+  return direction > 0 ? ahead[0] : ahead[ahead.length - 1];
+}
+function snapAlignment(value, axis) {
+  const [block, inline = block] = value.split(" ");
+  const keyword = axis === "x" ? inline : block;
+  if (keyword === "start" || keyword === "center" || keyword === "end") return keyword;
+  return null;
+}
+function mirrored(alignment) {
+  if (alignment === "start") return "end";
+  if (alignment === "end") return "start";
+  return alignment;
+}
+function scrollport(container, axis) {
+  const style = getComputedStyle(container);
+  const size = axis === "x" ? container.clientWidth : container.clientHeight;
+  const [paddingStart, paddingEnd] = axis === "x" ? [style.scrollPaddingLeft, style.scrollPaddingRight] : [style.scrollPaddingTop, style.scrollPaddingBottom];
+  return { start: resolvePadding(paddingStart, size), end: resolvePadding(paddingEnd, size), size };
+}
+function resolvePadding(value, size) {
+  if (value === "auto") return 0;
+  if (value.endsWith("%")) return parseFloat(value) / 100 * size;
+  return parseFloat(value);
+}
+function contentOrigin(container, axis) {
+  const box = container.getBoundingClientRect();
+  if (axis === "x") return box.left + container.clientLeft - container.scrollLeft;
+  return box.top + container.clientTop - container.scrollTop;
+}
+function snapArea(child, style, origin, axis) {
+  const box = child.getBoundingClientRect();
+  if (axis === "x") {
+    return {
+      start: box.left - parseFloat(style.scrollMarginLeft) - origin,
+      end: box.right + parseFloat(style.scrollMarginRight) - origin
+    };
+  }
+  return {
+    start: box.top - parseFloat(style.scrollMarginTop) - origin,
+    end: box.bottom + parseFloat(style.scrollMarginBottom) - origin
+  };
+}
+function alignedPosition(area, port, alignment) {
+  switch (alignment) {
+    case "start":
+      return area.start - port.start;
+    case "end":
+      return area.end - (port.size - port.end);
+    case "center":
+      return (area.start + area.end) / 2 - (port.start + (port.size - port.start - port.end) / 2);
+    default: {
+      const exhaustive = alignment;
+      return exhaustive;
+    }
+  }
+}
+
+// src/core/velocity.ts
+var VELOCITY_WINDOW_MS = 100;
+function recordSample(samples, sample2) {
+  samples.push(sample2);
+  while (sample2.time - samples[0].time > VELOCITY_WINDOW_MS) samples.shift();
+}
+function releaseVelocity(samples) {
+  const first = samples[0];
+  const last = samples[samples.length - 1];
+  const elapsed = last.time - first.time;
+  return elapsed > 0 ? (last.position - first.position) / elapsed * 1e3 : 0;
+}
+
+// src/core/drag-scroll.ts
+var DRAG_SLOP = 8;
+var CLICK_AFTER_DRAG_MS = 100;
+var NATIVE_PAN = { x: "pan-y pinch-zoom", y: "pan-x pinch-zoom" };
+function dragScroll(element, { axis = "x", mouse = false } = {}) {
+  const restoreTouchAction = setInlineStyles(element, { "touch-action": NATIVE_PAN[axis] });
+  let gesture = null;
+  let release = null;
+  let suppressClicksUntil = -Infinity;
+  function accepts(event) {
+    if (!event.isPrimary) return false;
+    if (event.pointerType === "touch") return true;
+    return mouse && event.pointerType === "mouse" && event.button === 0;
+  }
+  function onPointerDown(event) {
+    suppressClicksUntil = -Infinity;
+    if (!accepts(event)) return;
+    endGesture(0);
+    gesture = {
+      kind: "pending",
+      pointerId: event.pointerId,
+      pointerType: event.pointerType,
+      origin: pointFrom(event),
+      snap: interruptRelease()
+    };
+  }
+  function interruptRelease() {
+    if (!release) return null;
+    const { handle, positions } = release;
+    handle.cancel();
+    return { positions, restore: suspendSnap2() };
+  }
+  function suspendSnap2() {
+    return setInlineStyles(element, { "scroll-snap-type": "none" });
+  }
+  function onPointerMove(event) {
+    if ((gesture == null ? void 0 : gesture.pointerId) !== event.pointerId) return;
+    if (gesture.kind === "pending") {
+      if (!isPressed(event)) {
+        endGesture(0);
+        return;
+      }
+      const intent = judgeIntent(gesture.origin, pointFrom(event), axis);
+      if (intent === "cross-axis") endGesture(0);
+      if (intent === "along-axis") gesture = startDrag(gesture, event);
+      return;
+    }
+    const position = dragPosition(gesture, event);
+    recordSample(gesture.samples, { time: event.timeStamp, position });
+    writeScroll(element, axis === "x" ? { x: position } : { y: position });
+  }
+  function dragPosition(drag, event) {
+    return drag.startScroll - (alongAxis(event, axis) - drag.origin);
+  }
+  function startDrag(pending, event) {
+    var _a;
+    element.setPointerCapture(event.pointerId);
+    cancelScroll(element);
+    const snap = (_a = pending.snap) != null ? _a : {
+      positions: readSnapPositions(element, axis),
+      restore: suspendSnap2()
+    };
+    const startScroll = readScroll(element)[axis];
+    return {
+      kind: "dragging",
+      pointerId: event.pointerId,
+      pointerType: event.pointerType,
+      origin: alongAxis(event, axis),
+      startScroll,
+      samples: [{ time: event.timeStamp, position: startScroll }],
+      snap,
+      restoreUserSelect: event.pointerType === "mouse" ? setInlineStyles(element, { "user-select": "none", "-webkit-user-select": "none" }) : noop2
+    };
+  }
+  function onPointerUp(event) {
+    if ((gesture == null ? void 0 : gesture.pointerId) !== event.pointerId) return;
+    if (gesture.kind === "pending") {
+      endGesture(0);
+      return;
+    }
+    recordSample(gesture.samples, { time: event.timeStamp, position: dragPosition(gesture, event) });
+    suppressClicksUntil = event.timeStamp + CLICK_AFTER_DRAG_MS;
+    endGesture(releaseVelocity(gesture.samples));
+  }
+  function onPointerCancel(event) {
+    if ((gesture == null ? void 0 : gesture.pointerId) === event.pointerId) endGesture(0);
+  }
+  function endGesture(velocity) {
+    const ended = gesture;
+    gesture = null;
+    if ((ended == null ? void 0 : ended.kind) === "dragging") ended.restoreUserSelect();
+    if (ended == null ? void 0 : ended.snap) settle(ended.snap, velocity);
+  }
+  function settle({ positions, restore }, velocity) {
+    if (positions.length === 0) {
+      restore();
+      track(fling(element, axis, velocity), positions);
+      return;
+    }
+    const current = readScroll(element)[axis];
+    const target = pickSnapTarget(positions, current, current + projectMomentum(velocity), velocity);
+    restore();
+    const handle = animateScroll(element, axis === "x" ? { x: target } : { y: target }, {
+      animation: { type: "spring", velocity: axis === "x" ? { x: velocity } : { y: velocity } },
+      respectReducedMotion: false
+    });
+    track(handle, positions);
+  }
+  function track(handle, positions) {
+    if (!handle) return;
+    const current = { handle, positions };
+    release = current;
+    void handle.finished.then(() => {
+      if (release === current) release = null;
+    });
+  }
+  function onDragStart(event) {
+    if ((gesture == null ? void 0 : gesture.pointerType) === "mouse") event.preventDefault();
+  }
+  function onClick(event) {
+    if (event.timeStamp > suppressClicksUntil) return;
+    suppressClicksUntil = -Infinity;
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  element.addEventListener("pointerdown", onPointerDown);
+  element.addEventListener("pointermove", onPointerMove);
+  element.addEventListener("pointerup", onPointerUp);
+  element.addEventListener("pointercancel", onPointerCancel);
+  element.addEventListener("dragstart", onDragStart);
+  element.addEventListener("click", onClick, { capture: true });
+  return () => {
+    var _a;
+    element.removeEventListener("pointerdown", onPointerDown);
+    element.removeEventListener("pointermove", onPointerMove);
+    element.removeEventListener("pointerup", onPointerUp);
+    element.removeEventListener("pointercancel", onPointerCancel);
+    element.removeEventListener("dragstart", onDragStart);
+    element.removeEventListener("click", onClick, { capture: true });
+    if ((gesture == null ? void 0 : gesture.kind) === "dragging") gesture.restoreUserSelect();
+    (_a = gesture == null ? void 0 : gesture.snap) == null ? void 0 : _a.restore();
+    gesture = null;
+    release == null ? void 0 : release.handle.cancel();
+    release = null;
+    restoreTouchAction();
+  };
+}
+function judgeIntent(origin, point, axis) {
+  const dx = point.x - origin.x;
+  const dy = point.y - origin.y;
+  if (Math.hypot(dx, dy) < DRAG_SLOP) return "undecided";
+  const [along, cross] = axis === "x" ? [dx, dy] : [dy, dx];
+  return Math.abs(cross) > Math.abs(along) ? "cross-axis" : "along-axis";
+}
+function isPressed(event) {
+  return (event.buttons & 1) === 1;
+}
+function pointFrom(event) {
+  return { x: event.clientX, y: event.clientY };
+}
+function alongAxis(event, axis) {
+  return axis === "x" ? event.clientX : event.clientY;
+}
+function noop2() {
+}
+
+// src/core/scroll-to.ts
+var EDGE_DESTINATIONS = {
+  top: { y: -Infinity },
+  bottom: { y: Infinity },
+  left: { x: -Infinity },
+  right: { x: Infinity }
+};
+function scrollToEdge(target, edge, options) {
+  return animateScroll(target, EDGE_DESTINATIONS[edge], options);
+}
+function scrollBy(target, delta, options) {
+  const base = scrollDestination(target);
+  return animateScroll(
+    target,
+    {
+      x: delta.x === void 0 ? void 0 : base.x + delta.x,
+      y: delta.y === void 0 ? void 0 : base.y + delta.y
+    },
+    options
+  );
+}
+function scrollToElement(target, element, options = {}) {
+  if (!isWindow(target) && !target.contains(element)) {
+    throw new Error("scrollToElement: element is not inside the scroll target");
+  }
+  const { align = "start", offset = 0, ...animateOptions } = options;
+  const metrics = readScroll(target);
+  const viewport = viewportOrigin(target);
+  const rect = element.getBoundingClientRect();
+  const x = placeOnAxis(align, {
+    elementStart: rect.left - viewport.left,
+    elementSize: rect.width,
+    viewportSize: metrics.viewportWidth,
+    scroll: metrics.x,
+    inset: 0
+  });
+  const y = placeOnAxis(align, {
+    elementStart: rect.top - viewport.top,
+    elementSize: rect.height,
+    viewportSize: metrics.viewportHeight,
+    scroll: metrics.y,
+    inset: offset
+  });
+  return animateScroll(target, { x, y }, animateOptions);
+}
+function viewportOrigin(target) {
+  if (isWindow(target)) return { left: 0, top: 0 };
+  const rect = target.getBoundingClientRect();
+  return { left: rect.left + target.clientLeft, top: rect.top + target.clientTop };
+}
+function placeOnAxis(align, placement) {
+  const { elementStart, elementSize, viewportSize, scroll, inset } = placement;
+  const start = scroll + elementStart - inset;
+  const end = scroll + elementStart + elementSize - viewportSize;
+  switch (align) {
+    case "start":
+      return start;
+    case "end":
+      return end;
+    case "center":
+      return scroll + elementStart + elementSize / 2 - (inset + viewportSize) / 2;
+    case "nearest": {
+      const fullyVisible = elementStart >= inset && elementStart + elementSize <= viewportSize;
+      if (fullyVisible) return void 0;
+      return Math.abs(start - scroll) <= Math.abs(end - scroll) ? start : end;
+    }
+    default: {
+      const exhaustive = align;
+      throw new Error(`scrollToElement: unknown align ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/core/active-section.ts
+function pickActiveSection(sectionTops, line, atEnd) {
+  let active = -1;
+  sectionTops.forEach((top, index) => {
+    if (top === null) return;
+    if (atEnd || top <= line + EDGE_TOLERANCE) active = index;
+  });
+  return active;
+}
+function observeActiveSection(sections, listener, { root = window, offset = 0 } = {}) {
+  if (!Number.isFinite(offset)) {
+    throw new RangeError(`observeActiveSection: offset must be a finite number, got ${offset}`);
+  }
+  if (!isWindow(root) && !sections.every((section) => root.contains(section))) {
+    throw new Error("observeActiveSection: every section must be inside the root");
+  }
+  let atEnd = false;
+  let active;
+  function update() {
+    const line = viewportOrigin(root).top + offset;
+    const tops = sections.map(layoutTop);
+    const next = pickActiveSection(tops, line, atEnd);
+    if (next === active) return;
+    active = next;
+    listener(next);
+  }
+  const resizeObserver = new ResizeObserver(update);
+  for (const section of sections) resizeObserver.observe(section);
+  const stopObservingScroll = observeScroll(root, (state) => {
+    atEnd = state.canScrollY && state.atBottom;
+    update();
+  });
+  return () => {
+    stopObservingScroll();
+    resizeObserver.disconnect();
+  };
+}
+function layoutTop(element) {
+  if (element.getClientRects().length === 0) return null;
+  return element.getBoundingClientRect().top;
+}
+
+// src/core/restore-scroll.ts
+var INTERACTION_EVENTS = ["wheel", "touchstart", "pointerdown", "keydown"];
+var MAX_TIMEOUT_MS2 = 2147483647;
+var historyHolds = /* @__PURE__ */ new Set();
+var originalHistoryRestoration = "auto";
+function restoreScroll(target, key, { storage, timeout = 3e3 } = {}) {
+  if (!(timeout >= 0 && timeout <= MAX_TIMEOUT_MS2)) {
+    throw new RangeError(
+      `restoreScroll: timeout must be between 0 and ${MAX_TIMEOUT_MS2} ms, got ${timeout}`
+    );
+  }
+  const storageKey = `use-scroller:${key}`;
+  let store;
+  let saved;
+  try {
+    store = storage != null ? storage : window.sessionStorage;
+    saved = parsePosition(store.getItem(storageKey));
+  } catch {
+    return noop3;
+  }
+  let unsavedPosition = null;
+  let frame = null;
+  let saving = false;
+  function save() {
+    frame = null;
+    const position = unsavedPosition;
+    unsavedPosition = null;
+    if (!position) return;
+    try {
+      store.setItem(storageKey, JSON.stringify(position));
+    } catch {
+    }
+  }
+  function onScroll() {
+    unsavedPosition = scrollPosition(target);
+    if (frame === null) frame = requestAnimationFrame(save);
+  }
+  function flush() {
+    if (frame !== null) cancelAnimationFrame(frame);
+    save();
+  }
+  function startSaving() {
+    saving = true;
+    target.addEventListener("scroll", onScroll, { passive: true });
+    window.addEventListener("pagehide", flush);
+  }
+  const releaseHistory = isWindow(target) ? takeOverHistoryRestoration(target.history) : noop3;
+  const stopRestoring = saved ? restoreWhenReachable(target, saved, timeout, startSaving) : noop3;
+  if (!saved) startSaving();
+  return () => {
+    stopRestoring();
+    if (saving) {
+      target.removeEventListener("scroll", onScroll);
+      window.removeEventListener("pagehide", flush);
+      flush();
+    }
+    releaseHistory();
+  };
+}
+function restoreWhenReachable(target, position, timeout, onSettled) {
+  let waiting = true;
+  let stopObserving = noop3;
+  const timer = setTimeout(() => {
+    writeScroll(target, position);
+    settle();
+  }, timeout);
+  function stop() {
+    waiting = false;
+    stopObserving();
+    clearTimeout(timer);
+    for (const type of INTERACTION_EVENTS) target.removeEventListener(type, settle);
+  }
+  function settle() {
+    stop();
+    onSettled();
+  }
+  function restoreIfReachable(range) {
+    if (!waiting || !isReachable(range, position)) return;
+    writeScroll(target, position);
+    settle();
+  }
+  for (const type of INTERACTION_EVENTS) {
+    target.addEventListener(type, settle, { passive: true });
+  }
+  stopObserving = observeScroll(target, restoreIfReachable);
+  if (!waiting) stopObserving();
+  return stop;
+}
+function takeOverHistoryRestoration(history) {
+  const hold = {};
+  if (historyHolds.size === 0) {
+    originalHistoryRestoration = history.scrollRestoration;
+    history.scrollRestoration = "manual";
+  }
+  historyHolds.add(hold);
+  return () => {
+    if (!historyHolds.delete(hold)) return;
+    if (historyHolds.size === 0) history.scrollRestoration = originalHistoryRestoration;
+  };
+}
+function isReachable(range, position) {
+  return position.y <= range.maxY + EDGE_TOLERANCE && position.x >= range.minX - EDGE_TOLERANCE && position.x <= range.maxX + EDGE_TOLERANCE;
+}
+function scrollPosition(target) {
+  if (isWindow(target)) return { x: target.scrollX, y: target.scrollY };
+  return { x: target.scrollLeft, y: target.scrollTop };
+}
+function parsePosition(json) {
+  if (json === null) return null;
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  return isPosition(value) ? { x: value.x, y: value.y } : null;
+}
+function isPosition(value) {
+  return typeof value === "object" && value !== null && "x" in value && "y" in value && Number.isFinite(value.x) && Number.isFinite(value.y);
+}
+function noop3() {
+}
+
+// src/core/stick-to-bottom.ts
+var STICK_THRESHOLD = 8;
+function stickToBottom(element, onChange) {
+  let stuck = true;
+  let stopped = false;
+  let ownAnimation = null;
+  let previous = jumpToBottom(element);
+  function setStuck(next) {
+    if (next === stuck) return;
+    stuck = next;
+    onChange == null ? void 0 : onChange(stuck);
+  }
+  onChange == null ? void 0 : onChange(stuck);
+  const unobserve = observeScroll(element, (current) => {
+    const nextStuck = stuckAfter(stuck, previous, current);
+    const follow = nextStuck && !ownAnimation && grewWithoutMovingUp(previous, current);
+    previous = follow ? jumpToBottom(element) : { y: current.y, maxY: current.maxY };
+    setStuck(nextStuck);
+  });
+  return {
+    scrollToBottom(options) {
+      if (stopped) throw new Error("stickToBottom: scrollToBottom called after stop()");
+      const handle = animateScroll(element, { y: Infinity }, options);
+      ownAnimation = handle;
+      setStuck(true);
+      void handle.finished.then((result) => {
+        if (ownAnimation !== handle) return;
+        ownAnimation = null;
+        if (result !== "completed") setStuck(isNearBottom(readScroll(element)));
+      });
+      return handle;
+    },
+    stop() {
+      stopped = true;
+      const animation = ownAnimation;
+      ownAnimation = null;
+      animation == null ? void 0 : animation.cancel();
+      unobserve();
+    }
+  };
+}
+function jumpToBottom(element) {
+  writeScroll(element, { y: readScroll(element).maxY });
+  const { y, maxY } = readScroll(element);
+  return { y, maxY };
+}
+function isNearBottom({ y, maxY }) {
+  return maxY - y <= STICK_THRESHOLD;
+}
+function stuckAfter(stuck, previous, current) {
+  if (isNearBottom(current)) return true;
+  if (current.y < previous.y) return false;
+  return stuck;
+}
+function grewWithoutMovingUp(previous, current) {
+  return current.maxY > previous.maxY && current.y >= previous.y;
+}
+
+export {
+  isWindow,
+  readScroll,
+  isScrollable,
+  findScrollParent,
+  easings,
+  cubicBezier,
+  animateScroll,
+  cancelScroll,
+  initialScrollState,
+  observeScroll,
+  lockScroll,
+  dragScroll,
+  scrollToEdge,
+  scrollBy,
+  scrollToElement,
+  observeActiveSection,
+  restoreScroll,
+  stickToBottom
+};