@silverlila/slider 0.0.0-stage → 0.1.0

package/dist/chunk-OAWJ54V3.js

@@ -0,0 +1,765 @@
+// src/core/autoplay.ts
+var DEFAULT_DELAY = 4e3;
+var INTERACTIONS = ["pointerdown", "wheel", "keydown"];
+function autoplay(slider, options = {}) {
+  const delay = options.delay ?? DEFAULT_DELAY;
+  if (!(delay > 0)) throw new RangeError(`delay must be > 0, got ${delay}`);
+  const root = options.root ?? slider.viewport;
+  const pauseOnHover = options.pauseOnHover ?? true;
+  const stopOnInteraction = options.stopOnInteraction ?? true;
+  const { viewport } = slider;
+  const listeners = /* @__PURE__ */ new Set();
+  let playing = !matchMedia("(prefers-reduced-motion: reduce)").matches;
+  let hovered = false;
+  let focused = false;
+  let pressed = false;
+  let timer = null;
+  let index = slider.getState().index;
+  let destroyed = false;
+  function isPaused() {
+    return hovered || focused || pressed || document.visibilityState === "hidden";
+  }
+  function schedule() {
+    if (timer !== null) clearTimeout(timer);
+    timer = playing && !isPaused() ? setTimeout(advance, delay) : null;
+  }
+  function advance() {
+    timer = null;
+    if (slider.getState().canNext) slider.next();
+    else slider.scrollTo(0);
+    schedule();
+  }
+  function setPlaying(value) {
+    if (playing === value) return;
+    playing = value;
+    schedule();
+    for (const listener of listeners) listener(playing);
+  }
+  function onSliderChange(state) {
+    if (state.index === index) return;
+    index = state.index;
+    schedule();
+  }
+  function onPointerEnter() {
+    hovered = true;
+    schedule();
+  }
+  function onPointerLeave() {
+    hovered = false;
+    schedule();
+  }
+  function onFocusIn(event) {
+    focused = event.target instanceof Element && event.target.matches(":focus-visible");
+    schedule();
+  }
+  function onFocusOut(event) {
+    focused = event.relatedTarget instanceof Node && root.contains(event.relatedTarget);
+    schedule();
+  }
+  function onPointerDown() {
+    pressed = true;
+    schedule();
+  }
+  function onPointerUp() {
+    pressed = false;
+    schedule();
+  }
+  function onInteraction() {
+    setPlaying(false);
+  }
+  const unsubscribe = slider.subscribe(onSliderChange);
+  if (pauseOnHover) {
+    root.addEventListener("pointerenter", onPointerEnter);
+    root.addEventListener("pointerleave", onPointerLeave);
+  }
+  root.addEventListener("focusin", onFocusIn);
+  root.addEventListener("focusout", onFocusOut);
+  viewport.addEventListener("pointerdown", onPointerDown);
+  window.addEventListener("pointerup", onPointerUp);
+  window.addEventListener("pointercancel", onPointerUp);
+  document.addEventListener("visibilitychange", schedule);
+  if (stopOnInteraction) {
+    for (const type of INTERACTIONS) viewport.addEventListener(type, onInteraction);
+  }
+  schedule();
+  function assertAlive() {
+    if (destroyed) throw new Error("Autoplay was destroyed");
+  }
+  return {
+    play() {
+      assertAlive();
+      hovered = false;
+      focused = false;
+      setPlaying(true);
+      schedule();
+    },
+    stop() {
+      assertAlive();
+      setPlaying(false);
+    },
+    isPlaying() {
+      assertAlive();
+      return playing;
+    },
+    subscribe(listener) {
+      assertAlive();
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      unsubscribe();
+      root.removeEventListener("pointerenter", onPointerEnter);
+      root.removeEventListener("pointerleave", onPointerLeave);
+      root.removeEventListener("focusin", onFocusIn);
+      root.removeEventListener("focusout", onFocusOut);
+      viewport.removeEventListener("pointerdown", onPointerDown);
+      window.removeEventListener("pointerup", onPointerUp);
+      window.removeEventListener("pointercancel", onPointerUp);
+      document.removeEventListener("visibilitychange", schedule);
+      for (const type of INTERACTIONS) viewport.removeEventListener(type, onInteraction);
+      listeners.clear();
+    }
+  };
+}
+
+// src/core/geometry.ts
+import { readScroll } from "use-scroller/core";
+var SNAP_MERGE_DISTANCE = 1;
+var FIT_TOLERANCE = 0.5;
+var MIRRORED = { start: "end", center: "center", end: "start" };
+function readLayout(viewport, axis) {
+  const style = getComputedStyle(viewport);
+  if (style.position === "static") {
+    throw new Error(
+      "Slider viewport must be positioned; add position: relative (the stylesheet does this)"
+    );
+  }
+  const children = childrenOf(viewport);
+  const slides = children.filter((child) => !isClone(child));
+  const clones = children.filter(isClone);
+  const direction = axis === "x" && style.direction === "rtl" ? -1 : 1;
+  const scroll = readScroll(viewport);
+  return {
+    slides,
+    clones,
+    clonesBefore: countLeadingClones(children),
+    clonesAfter: countLeadingClones([...children].reverse()),
+    boxes: slides.map((slide) => readBox(slide, axis)),
+    gap: parseGap(axis === "x" ? style.columnGap : style.rowGap),
+    port: readPort(viewport, style, axis),
+    range: axis === "x" ? { min: scroll.minX, max: scroll.maxX } : { min: 0, max: scroll.maxY },
+    direction
+  };
+}
+function isClone(child) {
+  return child.hasAttribute("data-slider-clone");
+}
+function countLeadingClones(children) {
+  const firstReal = children.findIndex((child) => !isClone(child));
+  return firstReal === -1 ? children.length : firstReal;
+}
+function childrenOf(viewport) {
+  return Array.from(viewport.children).filter(
+    (child) => child instanceof HTMLElement
+  );
+}
+function readBox(slide, axis) {
+  if (axis === "x") return { start: slide.offsetLeft, end: slide.offsetLeft + slide.offsetWidth };
+  return { start: slide.offsetTop, end: slide.offsetTop + slide.offsetHeight };
+}
+function parseGap(value) {
+  return value === "normal" ? 0 : parseFloat(value);
+}
+function readPort(viewport, style, axis) {
+  const size = axis === "x" ? viewport.clientWidth : viewport.clientHeight;
+  return {
+    size,
+    paddingBefore: resolvePadding(
+      axis === "x" ? style.scrollPaddingLeft : style.scrollPaddingTop,
+      size
+    ),
+    paddingAfter: resolvePadding(
+      axis === "x" ? style.scrollPaddingRight : style.scrollPaddingBottom,
+      size
+    )
+  };
+}
+function resolvePadding(value, size) {
+  if (value === "auto") return 0;
+  if (value.endsWith("%")) return parseFloat(value) / 100 * size;
+  return parseFloat(value);
+}
+function alignedPosition(box, port, align, direction) {
+  const before = port.paddingBefore;
+  const after = port.paddingAfter;
+  const physicalAlign = direction === 1 ? align : MIRRORED[align];
+  switch (physicalAlign) {
+    case "start":
+      return box.start - before;
+    case "end":
+      return box.end - (port.size - after);
+    case "center":
+      return (box.start + box.end) / 2 - (before + (port.size - before - after) / 2);
+    default: {
+      const exhaustive = physicalAlign;
+      return exhaustive;
+    }
+  }
+}
+function groupSize(layout, slidesPerMove) {
+  if (slidesPerMove !== "auto") return slidesPerMove;
+  const available = layout.port.size - layout.port.paddingBefore - layout.port.paddingAfter;
+  let size = 1;
+  while (size < layout.boxes.length) {
+    const span = unionSize(layout.boxes.slice(0, size + 1));
+    if (span > available + FIT_TOLERANCE) break;
+    size++;
+  }
+  return size;
+}
+function unionSize(boxes) {
+  const start = Math.min(...boxes.map((box) => box.start));
+  const end = Math.max(...boxes.map((box) => box.end));
+  return end - start;
+}
+function anchors(slideCount, size, align) {
+  const result = [];
+  for (let first = 0; first < slideCount; first += size) {
+    const last = Math.min(first + size, slideCount) - 1;
+    result.push(anchorOf(first, last, align));
+  }
+  return result;
+}
+function anchorOf(first, last, align) {
+  if (align === "start") return first;
+  if (align === "end") return last;
+  return Math.floor((first + last) / 2);
+}
+function snapPositions(layout, anchorIndexes, align) {
+  const { boxes, port, range, direction } = layout;
+  const positions = [];
+  for (const index of anchorIndexes) {
+    const aligned = alignedPosition(boxes[index], port, align, direction);
+    const position = clamp(aligned, range.min, range.max);
+    const previous = positions[positions.length - 1];
+    if (previous !== void 0 && Math.abs(position - previous) <= SNAP_MERGE_DISTANCE) continue;
+    positions.push(position);
+  }
+  return positions;
+}
+function nearestSnap(positions, p) {
+  let nearest = 0;
+  for (let i = 1; i < positions.length; i++) {
+    if (Math.abs(positions[i] - p) < Math.abs(positions[nearest] - p)) nearest = i;
+  }
+  return nearest;
+}
+function progressOf(positions, p) {
+  if (positions.length < 2) return 0;
+  const first = positions[0];
+  const last = positions[positions.length - 1];
+  return clamp((p - first) / (last - first), 0, 1);
+}
+function periodOf(layout) {
+  if (layout.boxes.length === 0) return 0;
+  return unionSize(layout.boxes) + layout.gap;
+}
+function loopSnapPositions(layout, anchorIndexes, align) {
+  const { boxes, port, direction } = layout;
+  return anchorIndexes.map((index) => alignedPosition(boxes[index], port, align, direction));
+}
+function copiesNeeded(layout) {
+  const period = periodOf(layout);
+  return period > 0 ? Math.max(1, Math.ceil(2 * layout.port.size / period)) : 0;
+}
+function canonical(loop, p) {
+  return loop.snaps[0] + loop.direction * mod(logicalOffset(loop, p), loop.period);
+}
+function positionOf(loop, v) {
+  const n = loop.snaps.length;
+  const offset = logicalOffset(loop, loop.snaps[mod(v, n)]) + Math.floor(v / n) * loop.period;
+  return loop.snaps[0] + loop.direction * offset;
+}
+function virtualAt(loop, p) {
+  const n = loop.snaps.length;
+  const u = logicalOffset(loop, p);
+  const copy = Math.floor(u / loop.period);
+  const r = u - copy * loop.period;
+  let nearest = 0;
+  let nearestDistance = Infinity;
+  let wrapped = false;
+  loop.snaps.forEach((snap, i) => {
+    const direct = Math.abs(r - logicalOffset(loop, snap));
+    const around = loop.period - direct;
+    const distance = Math.min(direct, around);
+    if (distance >= nearestDistance) return;
+    nearest = i;
+    nearestDistance = distance;
+    wrapped = around < direct;
+  });
+  const ownerCopy = wrapped && r > logicalOffset(loop, loop.snaps[nearest]) ? copy + 1 : copy;
+  return ownerCopy * n + nearest;
+}
+function nearestCongruent(from, index, n) {
+  const base = from - mod(from, n) + mod(index, n);
+  let nearest = base + n;
+  for (const candidate of [base, base - n]) {
+    if (Math.abs(candidate - from) < Math.abs(nearest - from)) nearest = candidate;
+  }
+  return nearest;
+}
+function loopProgress(loop, p) {
+  return mod(logicalOffset(loop, p), loop.period) / loop.period;
+}
+function logicalOffset(loop, p) {
+  return loop.direction * (p - loop.snaps[0]);
+}
+function mod(a, n) {
+  return (a % n + n) % n;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/core/clones.ts
+function renderClones(slider) {
+  const { viewport } = slider;
+  let rendered = null;
+  function render({ loopCopies, slideCount }) {
+    if ((rendered == null ? void 0 : rendered.loopCopies) === loopCopies && rendered.slideCount === slideCount) return;
+    rendered = { loopCopies, slideCount };
+    removeClones(viewport);
+    const slides = childrenOf(viewport);
+    if (loopCopies === 0 || slides.length === 0) return;
+    slides[0].before(copiesOf(slides, loopCopies));
+    slides[slides.length - 1].after(copiesOf(slides, loopCopies));
+  }
+  render(slider.getState());
+  const unsubscribe = slider.subscribe(render);
+  return () => {
+    unsubscribe();
+    removeClones(viewport);
+  };
+}
+function removeClones(viewport) {
+  for (const clone of viewport.querySelectorAll(":scope > [data-slider-clone]")) clone.remove();
+}
+function copiesOf(slides, copies) {
+  const fragment = document.createDocumentFragment();
+  for (let copy = 0; copy < copies; copy++) {
+    slides.forEach((slide, index) => fragment.append(cloneSlide(slide, index)));
+  }
+  return fragment;
+}
+function cloneSlide(slide, index) {
+  const clone = slide.cloneNode(true);
+  if (!(clone instanceof HTMLElement)) throw new Error("Slider slides must be HTML elements");
+  clone.setAttribute("data-slider-clone", String(index));
+  clone.setAttribute("aria-hidden", "true");
+  clone.inert = true;
+  clone.removeAttribute("id");
+  for (const element of clone.querySelectorAll("[id]")) element.removeAttribute("id");
+  return clone;
+}
+
+// src/core/slide-progress.ts
+import { observeScroll } from "use-scroller/core";
+function slideProgress(slider) {
+  const { viewport } = slider;
+  const { axis, align } = slider.options;
+  let cached = null;
+  function currentMetrics(children) {
+    const key = {
+      childCount: children.length,
+      portSize: axis === "x" ? viewport.clientWidth : viewport.clientHeight
+    };
+    if (cached === null || !isSameKey(cached.key, key)) {
+      const { port, gap, direction } = readLayout(viewport, axis);
+      cached = { key, metrics: { port, gap, direction } };
+    }
+    return cached.metrics;
+  }
+  function write() {
+    const children = childrenOf(viewport);
+    const { port, gap, direction } = currentMetrics(children);
+    const position = axis === "x" ? viewport.scrollLeft : viewport.scrollTop;
+    const values = children.map((child) => {
+      const box = readBox(child, axis);
+      const aligned = alignedPosition(box, port, align, direction);
+      return direction * (aligned - position) / (box.end - box.start + gap);
+    });
+    children.forEach((child, i) => {
+      child.style.setProperty("--slide-progress", String(round(values[i])));
+      child.style.setProperty("--slide-distance", String(round(Math.abs(values[i]))));
+    });
+  }
+  const stopObserving = observeScroll(viewport, write);
+  return () => {
+    stopObserving();
+    for (const child of childrenOf(viewport)) {
+      child.style.removeProperty("--slide-progress");
+      child.style.removeProperty("--slide-distance");
+    }
+  };
+}
+function isSameKey(a, b) {
+  return a.childCount === b.childCount && a.portSize === b.portSize;
+}
+function round(value) {
+  return Math.round(value * 1e4) / 1e4;
+}
+
+// src/core/slider.ts
+import {
+  animateScroll,
+  cancelScroll,
+  dragScroll,
+  observeScroll as observeScroll2
+} from "use-scroller/core";
+var DEFAULT_ANIMATION = { type: "tween" };
+var SNAP_TOLERANCE = 1;
+var STATE_KEYS = [
+  "index",
+  "snapCount",
+  "slideCount",
+  "canPrev",
+  "canNext",
+  "progress",
+  "loopCopies"
+];
+function createSlider(viewport, options = {}) {
+  const resolved = resolveOptions(options);
+  const startIndex = options.startIndex ?? 0;
+  assertInteger(startIndex, "startIndex");
+  const { axis, align } = resolved;
+  let layout = readLayout(viewport, axis);
+  let snaps = [];
+  let loopCopies = 0;
+  let loop = null;
+  const tracked = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  let pending = null;
+  let current = null;
+  let heldSnapType = null;
+  let pointerDown = false;
+  let scrolling = false;
+  let destroyed = false;
+  const resizeObserver = new ResizeObserver(remeasure);
+  const mutationObserver = new MutationObserver(remeasure);
+  applyLayout();
+  jumpToSnap(startIndex);
+  let state = computeState(livePosition());
+  const stopObservingScroll = observeScroll2(viewport, onScroll);
+  resizeObserver.observe(viewport);
+  mutationObserver.observe(viewport, { childList: true });
+  const stopDragging = resolved.draggable ? dragScroll(viewport, { axis, mouse: true }) : null;
+  const onPointerDown = () => {
+    pointerDown = true;
+  };
+  const onPointerUp = () => {
+    pointerDown = false;
+    recentre();
+  };
+  viewport.addEventListener("pointerdown", onPointerDown);
+  window.addEventListener("pointerup", onPointerUp);
+  window.addEventListener("pointercancel", onPointerUp);
+  function applyLayout() {
+    const size = groupSize(layout, resolved.slidesPerMove);
+    const anchorIndexes = anchors(layout.slides.length, size, align);
+    loopCopies = resolved.loop ? copiesNeeded(layout) : 0;
+    loop = isLoopActive(layout, loopCopies) ? {
+      snaps: loopSnapPositions(layout, anchorIndexes, align),
+      period: periodOf(layout),
+      direction: layout.direction
+    } : null;
+    snaps = loop ? loop.snaps : snapPositions(layout, anchorIndexes, align);
+    const anchorSet = new Set(anchorIndexes);
+    layout.slides.forEach((slide, i) => {
+      slide.style.scrollSnapAlign = anchorSet.has(i) ? align : "none";
+    });
+    for (const clone of layout.clones) {
+      const source = Number(clone.getAttribute("data-slider-clone"));
+      clone.style.scrollSnapAlign = loop && anchorSet.has(source) ? align : "none";
+    }
+    trackSlides(layout.slides);
+  }
+  function trackSlides(slides) {
+    const present = new Set(slides);
+    for (const slide of tracked) {
+      if (present.has(slide)) continue;
+      slide.style.removeProperty("scroll-snap-align");
+      resizeObserver.unobserve(slide);
+      tracked.delete(slide);
+    }
+    for (const slide of slides) {
+      if (tracked.has(slide)) continue;
+      resizeObserver.observe(slide);
+      tracked.add(slide);
+    }
+  }
+  function remeasure() {
+    if (destroyed) return;
+    layout = readLayout(viewport, axis);
+    applyLayout();
+    if (pending === null && !pointerDown && !scrolling) jumpToSnap(state.index);
+    update(livePosition());
+  }
+  function onScroll(scroll) {
+    scrolling = scroll.isScrolling;
+    update(axis === "x" ? scroll.x : scroll.y);
+    recentre();
+  }
+  function recentre() {
+    if (loop === null || scrolling || pointerDown || pending !== null) return;
+    const position = livePosition();
+    const onSnap = Math.abs(positionOf(loop, virtualAt(loop, position)) - position);
+    if (onSnap > SNAP_TOLERANCE) return;
+    const target = canonical(loop, position);
+    if (Math.abs(target - position) > SNAP_TOLERANCE) jumpTo(target);
+  }
+  function computeState(position) {
+    const snapCount = snaps.length;
+    const slideCount = layout.slides.length;
+    if (loop) {
+      const looping = snapCount > 1;
+      return {
+        index: (pending == null ? void 0 : pending.index) ?? mod(virtualAt(loop, position), snapCount),
+        snapCount,
+        slideCount,
+        canPrev: looping,
+        canNext: looping,
+        progress: loopProgress(loop, position),
+        loopCopies
+      };
+    }
+    const index = (pending == null ? void 0 : pending.index) ?? nearestSnap(snaps, position);
+    const movable = snapCount > 1;
+    return {
+      index,
+      snapCount,
+      slideCount,
+      canPrev: movable && (resolved.rewind || index > 0),
+      canNext: movable && (resolved.rewind || index < snapCount - 1),
+      progress: progressOf(snaps, position),
+      loopCopies
+    };
+  }
+  function update(position) {
+    const next = computeState(position);
+    if (STATE_KEYS.every((key) => next[key] === state[key])) return;
+    state = next;
+    for (const listener of listeners) listener(state);
+  }
+  function livePosition() {
+    return axis === "x" ? viewport.scrollLeft : viewport.scrollTop;
+  }
+  function clampIndex(index) {
+    return Math.min(Math.max(index, 0), snaps.length - 1);
+  }
+  function jumpToSnap(index) {
+    if (snaps.length === 0) return;
+    jumpTo(snaps[clampIndex(index)]);
+  }
+  function jumpTo(position) {
+    viewport.scrollTo(
+      axis === "x" ? { left: position, behavior: "instant" } : { top: position, behavior: "instant" }
+    );
+  }
+  function holdSnap() {
+    if (heldSnapType !== null) return;
+    cancelScroll(viewport);
+    heldSnapType = viewport.style.scrollSnapType;
+    viewport.style.scrollSnapType = "none";
+  }
+  function releaseSnap() {
+    if (heldSnapType === null) return;
+    viewport.style.scrollSnapType = heldSnapType;
+    heldSnapType = null;
+  }
+  function navigate(index, navigateOptions = {}) {
+    holdSnap();
+    animateTo({ index, virtual: index }, snaps[index], navigateOptions);
+  }
+  function navigateLoop(active, from, target, navigateOptions = {}) {
+    holdSnap();
+    const n = active.snaps.length;
+    const copy = Math.floor(from / n);
+    if (copy !== 0) jumpTo(livePosition() - active.direction * copy * active.period);
+    const virtual = target - copy * n;
+    animateTo({ index: mod(virtual, n), virtual }, positionOf(active, virtual), navigateOptions);
+  }
+  function loopFrom(active) {
+    return (pending == null ? void 0 : pending.virtual) ?? virtualAt(active, livePosition());
+  }
+  function animateTo(target, position, navigateOptions) {
+    pending = target;
+    const handle = animateScroll(viewport, axis === "x" ? { x: position } : { y: position }, {
+      animation: navigateOptions.animation ?? resolved.animation
+    });
+    current = handle;
+    update(livePosition());
+    void handle.finished.then(() => {
+      if (current !== handle) return;
+      current = null;
+      pending = null;
+      releaseSnap();
+      update(livePosition());
+      recentre();
+    });
+  }
+  function assertAlive() {
+    if (destroyed) throw new Error("Slider was destroyed");
+  }
+  return {
+    viewport,
+    options: resolved,
+    getState() {
+      assertAlive();
+      return state;
+    },
+    subscribe(listener) {
+      assertAlive();
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    next(navigateOptions) {
+      assertAlive();
+      if (loop) {
+        const from2 = loopFrom(loop);
+        if (snaps.length > 1) navigateLoop(loop, from2, from2 + 1, navigateOptions);
+        return;
+      }
+      const last = snaps.length - 1;
+      const from = (pending == null ? void 0 : pending.index) ?? state.index;
+      if (from < last) navigate(from + 1, navigateOptions);
+      else if (resolved.rewind && last > 0) navigate(0, navigateOptions);
+    },
+    prev(navigateOptions) {
+      assertAlive();
+      if (loop) {
+        const from2 = loopFrom(loop);
+        if (snaps.length > 1) navigateLoop(loop, from2, from2 - 1, navigateOptions);
+        return;
+      }
+      const last = snaps.length - 1;
+      const from = (pending == null ? void 0 : pending.index) ?? state.index;
+      if (from > 0) navigate(from - 1, navigateOptions);
+      else if (resolved.rewind && last > 0) navigate(last, navigateOptions);
+    },
+    scrollTo(index, navigateOptions) {
+      assertAlive();
+      assertInteger(index, "index");
+      if (snaps.length === 0) return;
+      if (loop) {
+        const from = loopFrom(loop);
+        navigateLoop(loop, from, nearestCongruent(from, index, snaps.length), navigateOptions);
+        return;
+      }
+      navigate(clampIndex(index), navigateOptions);
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      stopObservingScroll();
+      resizeObserver.disconnect();
+      mutationObserver.disconnect();
+      stopDragging == null ? void 0 : stopDragging();
+      viewport.removeEventListener("pointerdown", onPointerDown);
+      window.removeEventListener("pointerup", onPointerUp);
+      window.removeEventListener("pointercancel", onPointerUp);
+      current == null ? void 0 : current.cancel();
+      current = null;
+      pending = null;
+      releaseSnap();
+      for (const slide of tracked) slide.style.removeProperty("scroll-snap-align");
+      for (const clone of layout.clones) clone.style.removeProperty("scroll-snap-align");
+      tracked.clear();
+      listeners.clear();
+    }
+  };
+}
+function isLoopActive(layout, copies) {
+  const expected = copies * layout.slides.length;
+  return expected > 0 && layout.clonesBefore === expected && layout.clonesAfter === expected;
+}
+function resolveOptions(options) {
+  const slidesPerMove = options.slidesPerMove ?? 1;
+  if (slidesPerMove !== "auto" && !(Number.isInteger(slidesPerMove) && slidesPerMove >= 1)) {
+    throw new RangeError(`slidesPerMove must be an integer >= 1 or 'auto', got ${slidesPerMove}`);
+  }
+  return {
+    axis: options.axis ?? "x",
+    align: options.align ?? "start",
+    slidesPerMove,
+    loop: options.loop ?? false,
+    rewind: options.rewind ?? false,
+    draggable: options.draggable ?? true,
+    animation: options.animation ?? DEFAULT_ANIMATION
+  };
+}
+function assertInteger(value, name) {
+  if (!Number.isInteger(value)) throw new RangeError(`${name} must be an integer, got ${value}`);
+}
+
+// src/core/sync.ts
+var CLONE_ATTRIBUTE = "data-slider-clone";
+function syncSliders(main, thumbs) {
+  const { viewport } = thumbs;
+  let index = null;
+  function follow(state) {
+    if (state.index === index) return;
+    index = state.index;
+    thumbs.scrollTo(Math.min(index, thumbs.getState().snapCount - 1));
+    const selected = realSlides(viewport)[index];
+    for (const child of viewport.children) {
+      if (child === selected) {
+        child.setAttribute("aria-current", "true");
+        child.setAttribute("data-selected", "");
+      } else {
+        clearSelection(child);
+      }
+    }
+  }
+  function onClick(event) {
+    const { target } = event;
+    if (!(target instanceof Node)) return;
+    const child = Array.from(viewport.children).find((element) => element.contains(target));
+    if (child === void 0) return;
+    main.scrollTo(slideIndexOf(viewport, child));
+  }
+  follow(main.getState());
+  const unsubscribe = main.subscribe(follow);
+  viewport.addEventListener("click", onClick);
+  return () => {
+    unsubscribe();
+    viewport.removeEventListener("click", onClick);
+    for (const child of viewport.children) clearSelection(child);
+  };
+}
+function realSlides(viewport) {
+  return Array.from(viewport.children).filter((child) => !child.hasAttribute(CLONE_ATTRIBUTE));
+}
+function slideIndexOf(viewport, child) {
+  const source = child.getAttribute(CLONE_ATTRIBUTE);
+  return source === null ? realSlides(viewport).indexOf(child) : Number(source);
+}
+function clearSelection(element) {
+  element.removeAttribute("aria-current");
+  element.removeAttribute("data-selected");
+}
+
+export {
+  autoplay,
+  renderClones,
+  slideProgress,
+  createSlider,
+  syncSliders
+};