@surdeddd/bottom-sheet 0.1.0 → 0.3.0

package/dist/svelte-core.js

@@ -0,0 +1,3147 @@
+import 'svelte/internal/client';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/lifecycle/sheetStack.ts
+var BASE_Z = 100;
+var STEP = 10;
+var SheetStack = class {
+  constructor() {
+    __publicField(this, "entries", []);
+  }
+  push(entry) {
+    this.entries.push(entry);
+    this.recompute();
+    return () => this.remove(entry.id);
+  }
+  remove(id) {
+    const idx = this.entries.findIndex((e) => e.id === id);
+    if (idx === -1) return;
+    this.entries.splice(idx, 1);
+    this.recompute();
+  }
+  promote(id) {
+    const idx = this.entries.findIndex((e) => e.id === id);
+    if (idx === -1) return;
+    if (idx !== this.entries.length - 1) {
+      const [entry] = this.entries.splice(idx, 1);
+      this.entries.push(entry);
+    }
+    this.recompute();
+  }
+  update() {
+    this.recompute();
+  }
+  size() {
+    return this.entries.length;
+  }
+  clear() {
+    this.entries = [];
+  }
+  recompute() {
+    let top = null;
+    const open = [];
+    for (const entry of this.entries) {
+      if (!entry.isOpen || entry.isOpen()) {
+        top = entry;
+        open.push(entry);
+      }
+    }
+    if (!top && this.entries.length > 0) {
+      top = this.entries[this.entries.length - 1];
+    }
+    this.entries.forEach((entry, i) => {
+      entry.setZIndex(BASE_Z + i * STEP);
+      entry.setIsTop(entry === top);
+      if (entry.setDepth) {
+        const openIdx = open.indexOf(entry);
+        entry.setDepth(openIdx === -1 ? 0 : open.length - 1 - openIdx);
+      }
+    });
+  }
+};
+var sheetStack = new SheetStack();
+
+// src/core/primitives/transform.ts
+function buildTransformTemplate(axis) {
+  switch (axis) {
+    case "bottom":
+      return (offset) => `translate3d(0, ${offset}px, 0)`;
+    case "top":
+      return (offset) => `translate3d(0, ${-offset}px, 0)`;
+    case "left":
+      return (offset) => `translate3d(${-offset}px, 0, 0)`;
+    case "right":
+      return (offset) => `translate3d(${offset}px, 0, 0)`;
+  }
+}
+var layoutAxis = (axis) => axis === "left" || axis === "right" ? "width" : "height";
+
+// src/core/primitives/instance-id.ts
+var counters = {};
+function nextInstanceId(prefix) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}-${crypto.randomUUID()}`;
+  }
+  counters[prefix] = (counters[prefix] ?? 0) + 1;
+  return `${prefix}-${counters[prefix]}`;
+}
+
+// src/core/primitives/event-bus.ts
+function createEventBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(event, fn) {
+      let set = listeners.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+      }
+      set.add(fn);
+      return () => {
+        set.delete(fn);
+      };
+    },
+    emit(event, payload) {
+      const set = listeners.get(event);
+      if (!set) return;
+      for (const fn of [...set]) {
+        fn(payload);
+      }
+    },
+    listenerCount(event) {
+      return listeners.get(event)?.size ?? 0;
+    },
+    clear() {
+      listeners.clear();
+    }
+  };
+}
+
+// src/core/primitives/cssLength.ts
+var probe = null;
+var PROBE_ATTR = "data-bs-probe";
+var ensureProbe = (axis) => {
+  if (typeof document === "undefined") return null;
+  if (!probe || !probe.isConnected) {
+    const existing = document.querySelector(`[${PROBE_ATTR}]`);
+    if (existing) {
+      probe = existing;
+    } else {
+      probe = document.createElement("div");
+      probe.setAttribute("aria-hidden", "true");
+      probe.setAttribute(PROBE_ATTR, "");
+      probe.style.cssText = "position:absolute;visibility:hidden;pointer-events:none;contain:strict;left:0;top:0;width:0;height:0;";
+      document.body.appendChild(probe);
+    }
+  }
+  if (axis === "vertical") {
+    probe.style.width = "0";
+    probe.style.height = "";
+  } else {
+    probe.style.height = "0";
+    probe.style.width = "";
+  }
+  return probe;
+};
+var isViewportAxisVertical = (mode) => mode === "bottom" || mode === "top";
+var viewportSize = (mode) => {
+  if (typeof window === "undefined") return 0;
+  return isViewportAxisVertical(mode) ? window.innerHeight : window.innerWidth;
+};
+var PERCENT = /^(-?\d+(?:\.\d+)?)%$/;
+var resolveSnap = (point, mode, measureFit) => {
+  if (typeof point === "number") return Math.max(0, point);
+  if (point === "full") return viewportSize(mode);
+  if (point === "fit") return Math.max(0, measureFit?.() ?? 0);
+  const pctMatch = point.match(PERCENT);
+  if (pctMatch) {
+    const pct = parseFloat(pctMatch[1]) / 100;
+    return Math.max(0, viewportSize(mode) * pct);
+  }
+  const axis = isViewportAxisVertical(mode) ? "vertical" : "horizontal";
+  const el = ensureProbe(axis);
+  if (!el) return 0;
+  if (axis === "vertical") {
+    el.style.height = point;
+    return Math.max(0, el.getBoundingClientRect().height);
+  }
+  el.style.width = point;
+  return Math.max(0, el.getBoundingClientRect().width);
+};
+
+// src/core/primitives/snap-points.ts
+var resolveSnapList = (points, mode, measureFit) => points.map((p) => {
+  const raw = resolveSnap(p.size, mode, measureFit);
+  if (!Number.isFinite(raw) || raw < 0) {
+    console.warn(
+      `[BottomSheet] snap "${p.id}" resolved to invalid size (${String(p.size)} \u2192 ${raw}); clamped to 0.`
+    );
+    return { id: p.id, size: 0 };
+  }
+  return { id: p.id, size: raw };
+}).sort((a, b) => a.size - b.size);
+var VH_NOT_DVH = /(^|[^a-z])vh\b/i;
+var auditVhUsage = (points) => {
+  for (const p of points) {
+    if (typeof p.size !== "string") continue;
+    if (!VH_NOT_DVH.test(p.size)) continue;
+    console.warn(
+      `[BottomSheet] snap "${p.id}" uses "vh" \u2014 prefer "dvh" on mobile (iOS Safari URL bar makes vh unstable). See https://web.dev/blog/viewport-units`
+    );
+  }
+};
+var findNearest = (size, resolved, allowed, direction = 0, bias = 0) => {
+  const pool = resolved.filter((p) => allowed.includes(p.id));
+  if (pool.length === 0) return null;
+  const target = size + direction * bias;
+  let best = pool[0];
+  let bestDist = Math.abs(target - best.size);
+  for (let i = 1; i < pool.length; i++) {
+    const cand = pool[i];
+    const dist = Math.abs(target - cand.size);
+    if (dist < bestDist) {
+      best = cand;
+      bestDist = dist;
+    }
+  }
+  return best;
+};
+var allowedRange = (resolved, allowed) => {
+  const pool = resolved.filter((p) => allowed.includes(p.id));
+  if (pool.length === 0) return { min: 0, max: 0 };
+  return {
+    min: pool[0].size,
+    max: pool[pool.length - 1].size
+  };
+};
+var findById = (id, resolved) => resolved.find((p) => p.id === id) ?? null;
+var MOUSE_FLICK_VELOCITY = 0.4;
+var MOUSE_DRAG_THRESHOLD = 12;
+var DIRECTIONAL_INTENT_VELOCITY = 0.15;
+var findDragSettleTarget = (input) => {
+  const speed = Math.abs(input.velocity);
+  const flickThreshold = input.pointerKind === "mouse" ? MOUSE_FLICK_VELOCITY : input.flickVelocity;
+  const dragThresh = input.pointerKind === "mouse" ? MOUSE_DRAG_THRESHOLD : input.dragThreshold;
+  let direction = 0;
+  if (speed > flickThreshold || speed > DIRECTIONAL_INTENT_VELOCITY) {
+    direction = input.velocity > 0 ? 1 : -1;
+  }
+  if (Math.abs(input.delta) < dragThresh && direction === 0) {
+    return findById(input.activeId, input.resolved);
+  }
+  const speedBias = speed > flickThreshold ? Math.min(speed * 180, input.maxAxisSize) : 0;
+  return findNearest(
+    input.size,
+    input.resolved,
+    input.allowed,
+    direction,
+    speedBias
+  );
+};
+
+// src/core/primitives/snap-resolver.ts
+var SnapResolver = class {
+  constructor(raw, allowed, mode, measureFit, onMaxAxisSizeChange) {
+    __publicField(this, "mode", mode);
+    __publicField(this, "measureFit", measureFit);
+    __publicField(this, "onMaxAxisSizeChange", onMaxAxisSizeChange);
+    __publicField(this, "raw");
+    __publicField(this, "allowedIds");
+    __publicField(this, "resolved", []);
+    __publicField(this, "maxAxisSize", 0);
+    __publicField(this, "rangeCache", null);
+    this.raw = raw;
+    this.allowedIds = allowed ?? raw.map((p) => p.id);
+    this.recompute();
+  }
+  recompute() {
+    this.resolved = resolveSnapList(this.raw, this.mode, this.measureFit);
+    this.maxAxisSize = this.resolved.reduce(
+      (m, s) => s.size > m ? s.size : m,
+      0
+    );
+    this.rangeCache = null;
+    this.onMaxAxisSizeChange?.(this.maxAxisSize);
+  }
+  setRaw(raw) {
+    this.raw = raw;
+    this.recompute();
+  }
+  setAllowedIds(ids) {
+    this.allowedIds = ids;
+    this.rangeCache = null;
+  }
+  findById(id) {
+    return findById(id, this.resolved);
+  }
+  findDragSettleTarget(args) {
+    return findDragSettleTarget({
+      ...args,
+      resolved: this.resolved,
+      allowed: this.allowedIds,
+      maxAxisSize: this.maxAxisSize
+    });
+  }
+  getAllowedRange() {
+    return this.rangeCache ?? (this.rangeCache = allowedRange(this.resolved, this.allowedIds));
+  }
+  getResolvedSnaps() {
+    return this.resolved;
+  }
+  getAllowedIds() {
+    return this.allowedIds;
+  }
+  getMaxAxisSize() {
+    return this.maxAxisSize;
+  }
+  setMaxAxisSize(n) {
+    this.maxAxisSize = n;
+    this.onMaxAxisSizeChange?.(n);
+  }
+};
+
+// src/core/features/persist.ts
+function readPersistedId(key) {
+  if (!key) return null;
+  if (typeof window === "undefined") return null;
+  if (typeof localStorage === "undefined") return null;
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function installPersist(engine, key) {
+  const unsubscribe = engine.on("snap", ({ id }) => {
+    if (typeof window === "undefined") return;
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(key, id);
+    } catch {
+    }
+  });
+  return unsubscribe;
+}
+
+// src/core/features/auto-collapse.ts
+function installAutoCollapse(deps) {
+  const { ms } = deps;
+  if (ms === void 0 || ms <= 0) {
+    return () => {
+    };
+  }
+  let timer = null;
+  const clearTimer = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  const fire = () => {
+    if (deps.isDestroyed()) return;
+    if (deps.isDragging()) return;
+    const active = deps.resolveSnap(deps.getActiveId());
+    if (!active || active.size === 0) return;
+    let target = null;
+    for (const id of deps.getAllowedIds()) {
+      const snap = deps.resolveSnap(id);
+      if (!snap || snap.size <= 0) continue;
+      if (!target || snap.size < target.size) target = snap;
+    }
+    if (!target) return;
+    if (target.id === active.id || target.size >= active.size) return;
+    deps.snapTo(target.id);
+  };
+  const reset = () => {
+    clearTimer();
+    if (deps.isDestroyed()) return;
+    timer = setTimeout(() => {
+      timer = null;
+      fire();
+    }, ms);
+  };
+  const unsubscribe = deps.on("snap", () => reset());
+  if ((deps.resolveSnap(deps.getActiveId())?.size ?? 0) > 0) reset();
+  return () => {
+    clearTimer();
+    unsubscribe();
+  };
+}
+
+// src/core/features/linked-sheets.ts
+function notifyLinkedSheets(sheets, self) {
+  if (sheets.length === 0) return;
+  for (const linked of sheets) {
+    if (linked === self) continue;
+    try {
+      if (linked.state.size === 0) continue;
+      const ids = linked.getAllowedIds();
+      const target = ids.find((id) => id !== "closed");
+      if (target && target !== linked.state.activeId) {
+        void linked.snapTo(target);
+      }
+    } catch (err) {
+      queueMicrotask(() => {
+        throw err;
+      });
+    }
+  }
+}
+
+// src/core/features/route.ts
+function installRoute(deps) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  if (!deps.routedTo && !deps.closeOnBack) {
+    return () => {
+    };
+  }
+  let routePushed = false;
+  let closeOnBackPushed = false;
+  let detachPopstate = null;
+  const popOurMarker = (key, expected) => {
+    const state = history.state;
+    if (state && state[key] === expected) {
+      try {
+        history.back();
+      } catch {
+      }
+    }
+  };
+  const onOpen = () => {
+    if (deps.routedTo && !detachPopstate) {
+      const target = deps.routedTo;
+      try {
+        history.pushState({ __bsRouted: target }, "", target);
+        routePushed = true;
+      } catch {
+      }
+      const onPop = (event) => {
+        if (deps.isDestroyed()) return;
+        const state = event.state;
+        if ((!state || state.__bsRouted !== target) && deps.getSize() > 0) {
+          routePushed = false;
+          void deps.close();
+        }
+      };
+      window.addEventListener("popstate", onPop);
+      detachPopstate = () => window.removeEventListener("popstate", onPop);
+    } else if (deps.closeOnBack && !detachPopstate) {
+      try {
+        history.pushState({ __bsSheet: deps.sheetId }, "");
+        closeOnBackPushed = true;
+      } catch {
+      }
+      const onPop = () => {
+        if (deps.isDestroyed()) return;
+        if (deps.getSize() > 0 && deps.isTopSheet()) {
+          const state = history.state;
+          if (state?.__bsSheet !== deps.sheetId) closeOnBackPushed = false;
+          void deps.close();
+        }
+      };
+      window.addEventListener("popstate", onPop);
+      detachPopstate = () => window.removeEventListener("popstate", onPop);
+    }
+  };
+  const onClose = () => {
+    detachPopstate?.();
+    detachPopstate = null;
+    if (routePushed) {
+      routePushed = false;
+      if (deps.routedTo !== void 0) popOurMarker("__bsRouted", deps.routedTo);
+    }
+    if (closeOnBackPushed) {
+      closeOnBackPushed = false;
+      popOurMarker("__bsSheet", deps.sheetId);
+    }
+  };
+  const unsubscribeOpen = deps.on("open", onOpen);
+  const unsubscribeClose = deps.on("close", onClose);
+  if (deps.getSize() > 0) onOpen();
+  return () => {
+    unsubscribeOpen();
+    unsubscribeClose();
+    detachPopstate?.();
+    detachPopstate = null;
+    if (routePushed) {
+      routePushed = false;
+      if (deps.routedTo !== void 0) popOurMarker("__bsRouted", deps.routedTo);
+    }
+    if (closeOnBackPushed) {
+      closeOnBackPushed = false;
+      popOurMarker("__bsSheet", deps.sheetId);
+    }
+  };
+}
+
+// src/core/features/content-swipe.ts
+var CONTENT_PULL_THRESHOLD = 60;
+function installContentSwipe(deps) {
+  const { container } = deps;
+  let startY = 0;
+  let moved = false;
+  const onTouchStart = (e) => {
+    const t = e.touches[0];
+    if (!t) return;
+    startY = t.clientY;
+    moved = false;
+  };
+  const onTouchMove = (e) => {
+    const t = e.touches[0];
+    if (!t) return;
+    if (Math.abs(t.clientY - startY) > CONTENT_PULL_THRESHOLD) moved = true;
+  };
+  const onTouchEnd = (e) => {
+    if (!moved) return;
+    if (deps.isDragging() || deps.isAnimating()) return;
+    const t = e.changedTouches[0];
+    if (!t) return;
+    const deltaY = t.clientY - startY;
+    const atTop = container.scrollTop <= 0;
+    const allowed = deps.getAllowedIds();
+    const idx = allowed.indexOf(deps.getActiveId());
+    if (idx === -1) return;
+    if (atTop && deltaY > CONTENT_PULL_THRESHOLD && idx > 0) {
+      deps.snapTo(allowed[idx - 1]);
+    } else if (deltaY < -CONTENT_PULL_THRESHOLD && idx < allowed.length - 1) {
+      deps.snapTo(allowed[idx + 1]);
+    }
+  };
+  container.addEventListener("touchstart", onTouchStart, { passive: true });
+  container.addEventListener("touchmove", onTouchMove, { passive: true });
+  container.addEventListener("touchend", onTouchEnd, { passive: true });
+  return () => {
+    container.removeEventListener("touchstart", onTouchStart);
+    container.removeEventListener("touchmove", onTouchMove);
+    container.removeEventListener("touchend", onTouchEnd);
+  };
+}
+
+// src/core/features/visual-viewport.ts
+var SAFETY_PAD = 8;
+function installVisualViewport(deps) {
+  if (typeof window === "undefined" || !window.visualViewport) {
+    return () => {
+    };
+  }
+  const vv = window.visualViewport;
+  let rafId = null;
+  const onResize = () => {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      if (deps.isDestroyed()) return;
+      deps.recomputeSnaps();
+      const isVertical = deps.isVerticalAxis();
+      const visible = isVertical ? vv.height : vv.width;
+      const windowSize = isVertical ? window.innerHeight : window.innerWidth;
+      const clamp = Math.max(0, Math.min(windowSize, visible) - SAFETY_PAD);
+      if (clamp < deps.getMaxAxisSize()) {
+        deps.setMaxAxisSize(clamp);
+      }
+      const max = deps.getMaxAxisSize();
+      deps.setSize(Math.min(deps.getSize(), max));
+      const current = deps.resolveActiveSnap();
+      if (current && !deps.isDragging()) {
+        deps.applySize(Math.min(current.size, max));
+      } else {
+        deps.applySize(deps.getSize());
+      }
+    });
+  };
+  vv.addEventListener("resize", onResize);
+  return () => {
+    vv.removeEventListener("resize", onResize);
+    if (rafId !== null) cancelAnimationFrame(rafId);
+  };
+}
+
+// src/core/features/resize-observer.ts
+function installResizeObserver(deps) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const onResize = () => {
+    if (deps.isDestroyed()) return;
+    deps.recomputeSnaps();
+    const mode = deps.getMode();
+    const isVerticalAxis = mode === "bottom" || mode === "top";
+    const viewportSize2 = isVerticalAxis ? window.innerHeight : window.innerWidth;
+    const max = deps.getMaxAxisSize();
+    if (viewportSize2 > 0 && viewportSize2 < max) {
+      deps.setMaxAxisSize(viewportSize2);
+    }
+    const wasAnimating = deps.isAnimating?.() ?? false;
+    deps.cancelInFlight();
+    deps.newCycle();
+    const current = deps.resolveActiveSnap();
+    const newMax = deps.getMaxAxisSize();
+    const targetSize = current ? Math.min(current.size, newMax) : Math.min(deps.getSize(), newMax);
+    deps.setSize(targetSize);
+    if (current && !deps.isDragging()) {
+      deps.applySize(targetSize);
+      if (wasAnimating) deps.resyncAfterCancel?.();
+    }
+  };
+  let resizeObserver = null;
+  if (typeof ResizeObserver !== "undefined") {
+    resizeObserver = new ResizeObserver(onResize);
+    resizeObserver.observe(document.documentElement);
+  } else {
+    window.addEventListener("resize", onResize);
+  }
+  window.addEventListener("orientationchange", onResize);
+  const onVisibility = () => {
+    if (deps.isDestroyed()) return;
+    if (document.hidden) deps.cancelInFlight();
+  };
+  document.addEventListener("visibilitychange", onVisibility);
+  return () => {
+    resizeObserver?.disconnect();
+    window.removeEventListener("resize", onResize);
+    window.removeEventListener("orientationchange", onResize);
+    document.removeEventListener("visibilitychange", onVisibility);
+  };
+}
+
+// src/core/features/slider-keyboard.ts
+function installSliderKeyboard(deps) {
+  const isVerticalAxis = deps.mode === "bottom" || deps.mode === "top";
+  const stepUp = isVerticalAxis ? "ArrowUp" : "ArrowRight";
+  const stepDown = isVerticalAxis ? "ArrowDown" : "ArrowLeft";
+  const sheetExpandsKey = deps.mode === "top" ? stepDown : stepUp;
+  const sheetCollapsesKey = deps.mode === "top" ? stepUp : stepDown;
+  const onHandleKey = (e) => {
+    if (deps.isDestroyed()) return;
+    const allowed = deps.getAllowedIds();
+    const idx = allowed.indexOf(deps.getActiveId());
+    if (idx === -1) return;
+    if (e.key === sheetExpandsKey && idx < allowed.length - 1) {
+      e.preventDefault();
+      deps.snapTo(allowed[idx + 1]);
+    } else if (e.key === sheetCollapsesKey && idx > 0) {
+      e.preventDefault();
+      deps.snapTo(allowed[idx - 1]);
+    } else if (e.key === "Home") {
+      e.preventDefault();
+      deps.snapTo(allowed[0]);
+    } else if (e.key === "End") {
+      e.preventDefault();
+      deps.snapTo(allowed[allowed.length - 1]);
+    }
+  };
+  deps.handle.addEventListener("keydown", onHandleKey);
+  return () => deps.handle.removeEventListener("keydown", onHandleKey);
+}
+
+// src/core/types.ts
+var SCRIM_PRESETS = Object.freeze({
+  subtle: {
+    color: "rgba(0,0,0,0.2)",
+    blur: void 0,
+    range: [0.3, 1],
+    interactive: false
+  },
+  standard: {
+    color: "rgba(0,0,0,0.4)",
+    blur: void 0,
+    range: [0, 1],
+    interactive: false
+  },
+  monitoring: {
+    color: "rgba(15,15,20,0.55)",
+    blur: "4px",
+    range: [0, 1],
+    interactive: false
+  },
+  cinematic: {
+    color: "rgba(0,0,0,0.7)",
+    blur: "12px",
+    range: [0, 1],
+    interactive: false
+  }
+});
+
+// src/core/primitives/hot-path-thresholds.ts
+var SIZE_WRITE_EPSILON = 0.5;
+var OPACITY_WRITE_EPSILON = 5e-3;
+var POINTER_EVENTS_OPACITY_THRESHOLD = 0.05;
+var RANGE_DIVISION_EPSILON = 1e-4;
+
+// src/core/primitives/opacity-dedup.ts
+var WriteSentinel = class {
+  constructor() {
+    __publicField(this, "last", -1);
+  }
+  shouldWrite(next, epsilon) {
+    if (Math.abs(next - this.last) <= epsilon) return false;
+    this.last = next;
+    return true;
+  }
+  invalidate() {
+    this.last = -1;
+  }
+  setLastWritten(value) {
+    this.last = value;
+  }
+  get value() {
+    return this.last;
+  }
+};
+
+// src/core/primitives/devWarn.ts
+function devWarn(...args) {
+  if (typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
+    console.warn(...args);
+  }
+}
+
+// src/core/primitives/overlay-position.ts
+function resolveSheetAnchoredStyle(mode, position, inset) {
+  const sizeOffset = `calc(var(--bs-size, 0px) + ${inset})`;
+  switch (mode) {
+    case "bottom":
+      if (position === "sheet-top-left") return { bottom: sizeOffset, left: inset };
+      if (position === "sheet-top-right") return { bottom: sizeOffset, right: inset };
+      return { bottom: sizeOffset, left: "50%", transform: "translateX(-50%)" };
+    case "top":
+      if (position === "sheet-top-left") return { top: sizeOffset, left: inset };
+      if (position === "sheet-top-right") return { top: sizeOffset, right: inset };
+      return { top: sizeOffset, left: "50%", transform: "translateX(-50%)" };
+    case "left":
+      if (position === "sheet-top-left") return { left: sizeOffset, top: inset };
+      if (position === "sheet-top-right") return { left: sizeOffset, bottom: inset };
+      return { left: sizeOffset, top: "50%", transform: "translateY(-50%)" };
+    case "right":
+      if (position === "sheet-top-left") return { right: sizeOffset, top: inset };
+      if (position === "sheet-top-right") return { right: sizeOffset, bottom: inset };
+      return { right: sizeOffset, top: "50%", transform: "translateY(-50%)" };
+  }
+}
+function applyOverlayPosition(ws, mode, position, inset) {
+  switch (position) {
+    case "top-left":
+      ws.top = inset;
+      ws.left = inset;
+      break;
+    case "top-center":
+      ws.top = inset;
+      ws.left = "50%";
+      ws.transform = "translateX(-50%)";
+      break;
+    case "top-right":
+      ws.top = inset;
+      ws.right = inset;
+      break;
+    case "center-left":
+      ws.top = "50%";
+      ws.left = inset;
+      ws.transform = "translateY(-50%)";
+      break;
+    case "center":
+      ws.top = "50%";
+      ws.left = "50%";
+      ws.transform = "translate(-50%, -50%)";
+      break;
+    case "center-right":
+      ws.top = "50%";
+      ws.right = inset;
+      ws.transform = "translateY(-50%)";
+      break;
+    case "bottom-left":
+      ws.bottom = inset;
+      ws.left = inset;
+      break;
+    case "bottom-center":
+      ws.bottom = inset;
+      ws.left = "50%";
+      ws.transform = "translateX(-50%)";
+      break;
+    case "bottom-right":
+      ws.bottom = inset;
+      ws.right = inset;
+      break;
+    case "sheet-top-left":
+    case "sheet-top-center":
+    case "sheet-top-right": {
+      const style = resolveSheetAnchoredStyle(mode, position, inset);
+      if (style.top !== void 0) ws.top = style.top;
+      if (style.bottom !== void 0) ws.bottom = style.bottom;
+      if (style.left !== void 0) ws.left = style.left;
+      if (style.right !== void 0) ws.right = style.right;
+      if (style.transform !== void 0) ws.transform = style.transform;
+      break;
+    }
+  }
+}
+
+// src/core/controllers/scrim-controller.ts
+var VALID_CSS_LENGTH = /^-?\d+(?:\.\d+)?(?:px|em|rem|%)$/;
+var ScrimController = class {
+  constructor(deps, opts) {
+    __publicField(this, "screenComponent");
+    __publicField(this, "backdrop");
+    __publicField(this, "mode");
+    __publicField(this, "isDestroyed");
+    __publicField(this, "isTopSheet");
+    __publicField(this, "getAllowedIds");
+    __publicField(this, "getResolvedSnaps");
+    __publicField(this, "snapToFn");
+    __publicField(this, "closeFn");
+    __publicField(this, "scrimInteractive", false);
+    __publicField(this, "scrimMode");
+    __publicField(this, "backdropRange");
+    __publicField(this, "screenRange");
+    __publicField(this, "scrimEnabled", true);
+    __publicField(this, "savedScrimRanges", null);
+    __publicField(this, "scrimTapToCloseEnabled", false);
+    __publicField(this, "detachScrimTap", null);
+    __publicField(this, "scrimOverlayTeardown", null);
+    __publicField(this, "backdropOpacitySentinel", new WriteSentinel());
+    __publicField(this, "screenOpacitySentinel", new WriteSentinel());
+    __publicField(this, "lastBackdropPointer", "");
+    __publicField(this, "lastScreenDisplay", "");
+    this.screenComponent = deps.screenComponent;
+    this.backdrop = deps.backdrop;
+    this.mode = deps.mode;
+    this.isDestroyed = deps.isDestroyed;
+    this.isTopSheet = deps.isTopSheet;
+    this.getAllowedIds = deps.getAllowedIds;
+    this.getResolvedSnaps = deps.getResolvedSnaps;
+    this.snapToFn = deps.snapTo;
+    this.closeFn = deps.close;
+    this.scrimMode = opts.scrimMode ?? "full";
+    const preset = opts.scrimPreset ? SCRIM_PRESETS[opts.scrimPreset] : null;
+    this.backdropRange = opts.backdropRange ?? preset?.range ?? [0, 1];
+    this.screenRange = opts.screenRange ?? preset?.range ?? [0, 1];
+    this.scrimTapToCloseEnabled = opts.scrimTapToClose ?? false;
+    if (this.screenComponent) {
+      this.applyScrimStyles({
+        color: opts.scrimColor ?? preset?.color,
+        blur: opts.scrimBlur ?? preset?.blur,
+        interactive: opts.scrimInteractive ?? preset?.interactive ?? false
+      });
+      if (this.scrimMode === "above-sheet") {
+        this.applyAboveSheetInset();
+      } else if (this.scrimMode === "off") {
+        const s = this.screenComponent.style;
+        s.opacity = "0";
+        s.display = "none";
+        this.screenOpacitySentinel.setLastWritten(0);
+        this.lastScreenDisplay = "none";
+      }
+    }
+  }
+  invalidateOpacityCache() {
+    this.backdropOpacitySentinel.invalidate();
+    this.screenOpacitySentinel.invalidate();
+  }
+  attach() {
+    if (this.scrimTapToCloseEnabled) {
+      this.setScrimTapToClose(true);
+    }
+  }
+  applyOpacity(progress, progressChanged) {
+    if (!progressChanged && this.backdropOpacitySentinel.value !== -1 && this.screenOpacitySentinel.value !== -1) {
+      return;
+    }
+    if (this.backdrop && this.isTopSheet()) {
+      const [s, e] = this.backdropRange;
+      const range = Math.max(e - s, RANGE_DIVISION_EPSILON);
+      const backdropOpacity = Math.min(
+        Math.max((progress - s) / range, 0),
+        1
+      );
+      if (this.backdropOpacitySentinel.shouldWrite(
+        backdropOpacity,
+        OPACITY_WRITE_EPSILON
+      )) {
+        this.backdrop.style.opacity = String(backdropOpacity);
+      }
+      const nextPointer = backdropOpacity > POINTER_EVENTS_OPACITY_THRESHOLD ? "auto" : "none";
+      if (nextPointer !== this.lastBackdropPointer) {
+        this.backdrop.style.pointerEvents = nextPointer;
+        this.lastBackdropPointer = nextPointer;
+      }
+    }
+    if (this.screenComponent && this.scrimMode !== "off") {
+      const [ss, se] = this.screenRange;
+      const screenOpacity = Math.min(
+        1,
+        Math.max(
+          0,
+          (progress - ss) / Math.max(RANGE_DIVISION_EPSILON, se - ss)
+        )
+      );
+      if (this.screenOpacitySentinel.shouldWrite(
+        screenOpacity,
+        OPACITY_WRITE_EPSILON
+      )) {
+        this.screenComponent.style.opacity = String(screenOpacity);
+      }
+      const nextDisplay = screenOpacity > 0 ? "" : "none";
+      if (nextDisplay !== this.lastScreenDisplay) {
+        this.screenComponent.style.display = nextDisplay;
+        this.lastScreenDisplay = nextDisplay;
+      }
+    }
+  }
+  setBackdropRange(range, applySize) {
+    if (this.isDestroyed()) return;
+    this.backdropRange = range;
+    this.invalidateOpacityCache();
+    applySize();
+  }
+  setScreenRange(range, applySize) {
+    if (this.isDestroyed()) return;
+    this.screenRange = range;
+    this.invalidateOpacityCache();
+    applySize();
+  }
+  setScrimColor(color) {
+    if (this.isDestroyed()) return;
+    this.applyScrimStyles({ color: color === void 0 ? null : color });
+  }
+  setScrimBlur(blur) {
+    if (this.isDestroyed()) return;
+    this.applyScrimStyles({ blur: blur === void 0 ? null : blur });
+  }
+  setScrimInteractive(interactive) {
+    if (this.isDestroyed()) return;
+    this.applyScrimStyles({ interactive });
+  }
+  setScrimMode(mode, applySize) {
+    if (this.isDestroyed()) return;
+    if (mode === this.scrimMode) return;
+    this.invalidateOpacityCache();
+    const previous = this.scrimMode;
+    this.scrimMode = mode;
+    if (this.screenComponent) {
+      const s = this.screenComponent.style;
+      if (previous === "above-sheet" && mode !== "above-sheet") {
+        s.position = "";
+        s.inset = "";
+        s.pointerEvents = "";
+      }
+      if (mode === "above-sheet") {
+        this.applyAboveSheetInset();
+      } else if (mode === "off") {
+        s.opacity = "0";
+        s.display = "none";
+        this.screenOpacitySentinel.setLastWritten(0);
+        this.lastScreenDisplay = "none";
+      } else {
+        if (this.lastScreenDisplay === "none") {
+          s.display = "";
+          this.lastScreenDisplay = "";
+        }
+      }
+    }
+    applySize();
+  }
+  setScrimTapToClose(enabled) {
+    if (this.isDestroyed()) return;
+    if (!this.screenComponent) return;
+    const installed = this.detachScrimTap !== null;
+    if (enabled === installed) return;
+    if (enabled) {
+      const target = this.screenComponent;
+      if (target.style.pointerEvents === "none") {
+        target.style.pointerEvents = "auto";
+      }
+      const onClick = () => {
+        if (this.isDestroyed()) return;
+        if (this.closeFn) {
+          this.closeFn();
+          return;
+        }
+        const allowed = this.getAllowedIds();
+        const snaps = this.getResolvedSnaps();
+        const fallback = allowed.find((id) => {
+          const snap = findById(id, snaps);
+          return snap !== null && snap.size === 0;
+        });
+        if (fallback) this.snapToFn(fallback);
+      };
+      target.addEventListener("click", onClick);
+      this.detachScrimTap = () => target.removeEventListener("click", onClick);
+      this.scrimTapToCloseEnabled = true;
+    } else {
+      this.detachScrimTap?.();
+      this.detachScrimTap = null;
+      this.scrimTapToCloseEnabled = false;
+    }
+  }
+  setScrimEnabled(enabled, applySize) {
+    if (this.isDestroyed()) return;
+    if (enabled === this.scrimEnabled) return;
+    this.scrimEnabled = enabled;
+    this.invalidateOpacityCache();
+    if (!enabled) {
+      this.savedScrimRanges = {
+        screen: this.screenRange,
+        backdrop: this.backdropRange
+      };
+      this.screenRange = [1, 1];
+      this.backdropRange = [1, 1];
+    } else {
+      this.screenRange = this.savedScrimRanges?.screen ?? [0, 1];
+      this.backdropRange = this.savedScrimRanges?.backdrop ?? [0, 1];
+      this.savedScrimRanges = null;
+    }
+    applySize();
+  }
+  setScrim(opts, applySize) {
+    if (this.isDestroyed()) return;
+    if (opts.preset) {
+      const cfg = SCRIM_PRESETS[opts.preset];
+      this.applyScrimStyles({
+        color: cfg.color,
+        blur: cfg.blur ?? null,
+        interactive: cfg.interactive
+      });
+      if (!this.scrimEnabled && this.savedScrimRanges) {
+        this.savedScrimRanges = { screen: cfg.range, backdrop: cfg.range };
+      } else {
+        this.screenRange = cfg.range;
+        this.backdropRange = cfg.range;
+      }
+    }
+    const noop = () => {
+    };
+    if (opts.mode !== void 0) this.setScrimMode(opts.mode, noop);
+    if (opts.enabled !== void 0) this.setScrimEnabled(opts.enabled, noop);
+    if (opts.tapToClose !== void 0) this.setScrimTapToClose(opts.tapToClose);
+    this.applyScrimStyles({
+      color: opts.color,
+      blur: opts.blur,
+      interactive: opts.interactive
+    });
+    if (opts.range !== void 0) {
+      if (!this.scrimEnabled && this.savedScrimRanges) {
+        this.savedScrimRanges = {
+          screen: opts.range,
+          backdrop: this.savedScrimRanges.backdrop
+        };
+      } else {
+        this.screenRange = opts.range;
+      }
+    }
+    this.invalidateOpacityCache();
+    applySize();
+  }
+  setScrimOverlay(opts) {
+    if (this.isDestroyed()) return () => {
+    };
+    if (!this.screenComponent) return () => {
+    };
+    this.scrimOverlayTeardown?.();
+    const screen = this.screenComponent;
+    const insetRaw = opts.inset ?? "16px";
+    const inset = VALID_CSS_LENGTH.test(insetRaw) ? insetRaw : "16px";
+    if (inset !== insetRaw) {
+      devWarn(
+        `[bottom-sheet] setScrimOverlay: invalid inset ${JSON.stringify(insetRaw)}; expected a CSS length like "16px" / "1rem" / "5%". Falling back to "16px".`
+      );
+    }
+    if (opts.children.ownerDocument && opts.children.ownerDocument !== screen.ownerDocument) {
+      devWarn(
+        "[bottom-sheet] setScrimOverlay: children belong to a different document than the scrim. Cross-document adoption can drop event listeners; construct children via the same document as the sheet root."
+      );
+    }
+    const position = opts.position ?? "top-right";
+    const interactive = opts.interactive ?? true;
+    const wrapper = screen.ownerDocument.createElement("div");
+    wrapper.className = "bs-scrim-overlay";
+    const ws = wrapper.style;
+    ws.position = "absolute";
+    applyOverlayPosition(ws, this.mode, position, inset);
+    if (interactive) {
+      ws.pointerEvents = "auto";
+    }
+    wrapper.appendChild(opts.children);
+    const host = screen.parentElement;
+    if (!host) {
+      devWarn(
+        "[bottom-sheet] setScrimOverlay: scrim element has no parent, skipping overlay injection. Mount the sheet root before calling setScrimOverlay."
+      );
+      return () => {
+      };
+    }
+    host.appendChild(wrapper);
+    const teardown = () => {
+      if (wrapper.parentNode) wrapper.parentNode.removeChild(wrapper);
+      if (this.scrimOverlayTeardown === teardown) {
+        this.scrimOverlayTeardown = null;
+      }
+    };
+    this.scrimOverlayTeardown = teardown;
+    return teardown;
+  }
+  destroy() {
+    this.detachScrimTap?.();
+    this.detachScrimTap = null;
+    this.scrimOverlayTeardown?.();
+    this.scrimOverlayTeardown = null;
+    if (this.screenComponent) {
+      const s = this.screenComponent.style;
+      s.opacity = "";
+      s.display = "";
+    }
+    if (this.backdrop) {
+      this.backdrop.style.opacity = "";
+      this.backdrop.style.pointerEvents = "";
+    }
+    this.invalidateOpacityCache();
+    this.lastBackdropPointer = "";
+    this.lastScreenDisplay = "";
+  }
+  applyScrimStyles(opts) {
+    if (!this.screenComponent) return;
+    const s = this.screenComponent.style;
+    if (opts.color !== void 0) {
+      s.background = opts.color === null ? "" : opts.color;
+    }
+    if (opts.blur !== void 0) {
+      const w = s;
+      if (opts.blur === null) {
+        s.backdropFilter = "";
+        w.webkitBackdropFilter = "";
+      } else {
+        const filter = `blur(${opts.blur})`;
+        s.backdropFilter = filter;
+        w.webkitBackdropFilter = filter;
+      }
+    }
+    if (opts.interactive !== void 0) {
+      this.scrimInteractive = opts.interactive;
+      s.pointerEvents = opts.interactive ? "auto" : "none";
+    }
+  }
+  applyAboveSheetInset() {
+    if (!this.screenComponent) return;
+    const insetByMode = {
+      bottom: "0 0 var(--bs-size) 0",
+      top: "var(--bs-size) 0 0 0",
+      left: "0 0 0 var(--bs-size)",
+      right: "0 var(--bs-size) 0 0"
+    };
+    const s = this.screenComponent.style;
+    s.position = "fixed";
+    s.inset = insetByMode[this.mode];
+    s.pointerEvents = this.scrimInteractive || this.scrimTapToCloseEnabled ? "auto" : "none";
+  }
+};
+
+// src/core/animation/animation.ts
+var easeOutBack = (t) => {
+  const c1 = 1.40158;
+  const c3 = c1 + 1;
+  return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+};
+var easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+var easeLinear = (t) => t;
+var easeOutQuint = (t) => 1 - Math.pow(1 - t, 5);
+var tween = ({
+  from,
+  to,
+  duration,
+  easing = easeOutCubic,
+  onUpdate
+}) => {
+  let cancelled = false;
+  let rafId = 0;
+  let resolveFn = null;
+  const start = performance.now();
+  const promise = new Promise((resolve) => {
+    resolveFn = resolve;
+    if (duration <= 0) {
+      onUpdate(to);
+      resolve();
+      return;
+    }
+    const step = (now) => {
+      if (cancelled) return;
+      const elapsed = now - start;
+      const t = Math.min(elapsed / duration, 1);
+      const value = from + (to - from) * easing(t);
+      onUpdate(value);
+      if (t < 1) {
+        rafId = requestAnimationFrame(step);
+      } else {
+        resolve();
+      }
+    };
+    rafId = requestAnimationFrame(step);
+  });
+  return {
+    cancel: () => {
+      cancelled = true;
+      cancelAnimationFrame(rafId);
+      resolveFn?.();
+    },
+    promise
+  };
+};
+var prefersReducedMotion = () => {
+  if (typeof window === "undefined" || !window.matchMedia) return false;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+};
+
+// src/core/animation/spring.ts
+var DEFAULT_SPRING = {
+  stiffness: 220,
+  damping: 26,
+  mass: 1,
+  restDelta: 0.5,
+  restSpeed: 0.5
+};
+var MAX_DT = 1 / 30;
+var runSpring = ({
+  from,
+  to,
+  velocity = 0,
+  config,
+  onUpdate
+}) => {
+  const cfg = { ...DEFAULT_SPRING, ...config };
+  let cancelled = false;
+  let rafId = 0;
+  let resolveFn = null;
+  let x = from;
+  let v = velocity;
+  let lastTime = performance.now();
+  const promise = new Promise((resolve) => {
+    resolveFn = resolve;
+    const step = (now) => {
+      if (cancelled) return;
+      const dt = Math.min((now - lastTime) / 1e3, MAX_DT);
+      lastTime = now;
+      const steps = Math.max(1, Math.ceil(dt * 240));
+      const subDt = dt / steps;
+      let stepsLeft = steps;
+      while (stepsLeft-- > 0) {
+        const force = -cfg.stiffness * (x - to) - cfg.damping * v;
+        const accel = force / cfg.mass;
+        v += accel * subDt;
+        x += v * subDt;
+      }
+      if (!Number.isFinite(x) || !Number.isFinite(v)) {
+        onUpdate(to, 0);
+        resolve();
+        return;
+      }
+      onUpdate(x, v);
+      const isAtRest = Math.abs(to - x) < (cfg.restDelta ?? 0.5) && Math.abs(v) < (cfg.restSpeed ?? 0.5);
+      if (isAtRest) {
+        onUpdate(to, 0);
+        resolve();
+      } else {
+        rafId = requestAnimationFrame(step);
+      }
+    };
+    rafId = requestAnimationFrame(step);
+  });
+  return {
+    cancel: () => {
+      cancelled = true;
+      cancelAnimationFrame(rafId);
+      resolveFn?.();
+    },
+    promise
+  };
+};
+
+// src/core/animation/animation-presets.ts
+var DEFAULT_DURATION = 220;
+function resolveAnimationPreset(animation) {
+  switch (animation) {
+    case "ios-spring":
+      return {
+        kind: "spring",
+        spring: { stiffness: 300, damping: 30, mass: 1 }
+      };
+    case "material-bounce":
+      return {
+        kind: "spring",
+        spring: { stiffness: 200, damping: 22, mass: 1 }
+      };
+    case "linear":
+      return { kind: "tween", duration: DEFAULT_DURATION, easing: easeLinear };
+    case "snappy":
+      return { kind: "tween", duration: 180, easing: easeOutQuint };
+    case "tween":
+      return { kind: "tween" };
+    case "spring":
+    case void 0:
+    default:
+      return { kind: "spring" };
+  }
+}
+
+// src/core/controllers/animation-runner.ts
+var DEFAULT_DURATION2 = 220;
+var VELOCITY_PX_PER_S = 1e3;
+var AnimationRunner = class {
+  constructor(deps, opts) {
+    __publicField(this, "element");
+    __publicField(this, "getRootEl");
+    __publicField(this, "applySizeFn");
+    __publicField(this, "getSize");
+    __publicField(this, "isDragging");
+    __publicField(this, "animationKind");
+    __publicField(this, "springConfig");
+    __publicField(this, "duration");
+    __publicField(this, "easing");
+    __publicField(this, "respectReducedMotion");
+    __publicField(this, "reducedMotion", false);
+    __publicField(this, "detachReducedMotion", null);
+    __publicField(this, "viewTransitionsAvailable");
+    __publicField(this, "currentTween", null);
+    __publicField(this, "currentSpring", null);
+    this.element = deps.element;
+    this.getRootEl = deps.getRootEl;
+    this.applySizeFn = deps.applySize;
+    this.getSize = deps.getSize;
+    this.isDragging = deps.isDragging;
+    const preset = resolveAnimationPreset(opts.animation);
+    this.animationKind = preset.kind;
+    this.duration = opts.duration ?? preset.duration ?? DEFAULT_DURATION2;
+    this.easing = opts.easing ?? preset.easing ?? easeOutBack;
+    this.springConfig = { ...preset.spring ?? {}, ...opts.spring ?? {} };
+    this.respectReducedMotion = opts.respectReducedMotion ?? true;
+    const viewTransitionsEnabled = opts.viewTransitions ?? false;
+    this.viewTransitionsAvailable = viewTransitionsEnabled && typeof document !== "undefined" && typeof document.startViewTransition === "function";
+    if (this.respectReducedMotion && typeof window !== "undefined" && typeof window.matchMedia === "function") {
+      const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
+      this.reducedMotion = mq.matches;
+      const onMqChange = (e) => {
+        this.reducedMotion = e.matches;
+      };
+      if (typeof mq.addEventListener === "function") {
+        mq.addEventListener("change", onMqChange);
+        this.detachReducedMotion = () => mq.removeEventListener("change", onMqChange);
+      } else if (typeof mq.addListener === "function") {
+        mq.addListener(onMqChange);
+        this.detachReducedMotion = () => mq.removeListener(onMqChange);
+      }
+    }
+  }
+  get isAnimating() {
+    return this.currentTween !== null || this.currentSpring !== null;
+  }
+  cancel() {
+    this.currentTween?.cancel();
+    this.currentSpring?.cancel();
+  }
+  async animateTo(target, velocityPxPerMs) {
+    if (target === this.getSize()) return;
+    this.currentTween?.cancel();
+    this.currentSpring?.cancel();
+    this.getRootEl()?.setAttribute("data-animating", "true");
+    this.element.style.willChange = "transform";
+    if (this.reducedMotion) {
+      this.applySizeFn(target);
+      this.getRootEl()?.removeAttribute("data-animating");
+      if (!this.isDragging()) this.element.style.willChange = "auto";
+      return;
+    }
+    if (this.animationKind === "spring") {
+      const spring = runSpring({
+        from: this.getSize(),
+        to: target,
+        velocity: velocityPxPerMs * VELOCITY_PX_PER_S,
+        config: this.springConfig,
+        onUpdate: (v) => this.applySizeFn(v)
+      });
+      this.currentSpring = spring;
+      await spring.promise;
+      if (this.currentSpring === spring) this.currentSpring = null;
+    } else {
+      const tw = tween({
+        from: this.getSize(),
+        to: target,
+        duration: this.duration,
+        easing: this.easing,
+        onUpdate: (v) => this.applySizeFn(v)
+      });
+      this.currentTween = tw;
+      await tw.promise;
+      if (this.currentTween === tw) this.currentTween = null;
+    }
+    if (!this.isAnimating) {
+      this.getRootEl()?.removeAttribute("data-animating");
+      if (!this.isDragging()) this.element.style.willChange = "auto";
+    }
+  }
+  destroy() {
+    this.detachReducedMotion?.();
+    this.detachReducedMotion = null;
+    this.currentTween = null;
+    this.currentSpring = null;
+  }
+};
+
+// src/core/lifecycle/focusTrap.ts
+var FOCUSABLE = [
+  "a[href]",
+  "area[href]",
+  "button:not([disabled])",
+  "input:not([disabled]):not([type='hidden'])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "iframe",
+  "object",
+  "embed",
+  "[contenteditable='true']",
+  "[tabindex]:not([tabindex='-1'])"
+].join(",");
+var isVisible = (el) => {
+  if (typeof el.checkVisibility === "function") {
+    return el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true });
+  }
+  return el.offsetParent !== null;
+};
+var focusables = (root) => Array.from(root.querySelectorAll(FOCUSABLE)).filter(
+  (el) => !el.hasAttribute("inert") && isVisible(el) && !el.matches("[aria-hidden='true']")
+);
+var trapStack = [];
+var installFocusTrap = (container, options = {}) => {
+  if (typeof document === "undefined") return () => {
+  };
+  const token = {};
+  trapStack.push(token);
+  const isActive = () => trapStack[trapStack.length - 1] === token;
+  const previouslyFocused = document.activeElement;
+  const focusInitial = () => {
+    const initial = typeof options.initialFocus === "string" ? container.querySelector(options.initialFocus) : options.initialFocus ?? focusables(container)[0] ?? container;
+    initial?.focus({ preventScroll: true });
+  };
+  focusInitial();
+  const handleKey = (e) => {
+    if (!isActive()) return;
+    if (e.key === "Escape" && options.onEscape) {
+      options.onEscape();
+      return;
+    }
+    if (e.key !== "Tab") return;
+    const list = focusables(container);
+    if (list.length === 0) {
+      e.preventDefault();
+      return;
+    }
+    const first = list[0];
+    const last = list[list.length - 1];
+    const active = document.activeElement;
+    if (e.shiftKey && active === first) {
+      e.preventDefault();
+      last.focus();
+    } else if (!e.shiftKey && active === last) {
+      e.preventDefault();
+      first.focus();
+    }
+  };
+  const handleFocusIn = (e) => {
+    if (!isActive()) return;
+    const target = e.target;
+    if (target && !container.contains(target)) {
+      const list = focusables(container);
+      list[0]?.focus({ preventScroll: true });
+    }
+  };
+  document.addEventListener("keydown", handleKey, true);
+  document.addEventListener("focusin", handleFocusIn, true);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const idx = trapStack.indexOf(token);
+    if (idx !== -1) trapStack.splice(idx, 1);
+    document.removeEventListener("keydown", handleKey, true);
+    document.removeEventListener("focusin", handleFocusIn, true);
+    if (previouslyFocused && document.contains(previouslyFocused)) {
+      previouslyFocused.focus({ preventScroll: true });
+    } else {
+      const fallback = document.querySelector("[data-bs-restore-fallback]");
+      fallback?.focus({ preventScroll: true });
+    }
+  };
+};
+
+// src/core/lifecycle/scrollLock.ts
+var lockCount = 0;
+var savedStyles = null;
+var lockBodyScroll = () => {
+  if (typeof document === "undefined") return () => {
+  };
+  if (lockCount === 0) {
+    const body = document.body;
+    savedStyles = {
+      overflow: body.style.overflow,
+      position: body.style.position,
+      top: body.style.top,
+      width: body.style.width,
+      scrollY: window.scrollY
+    };
+    body.style.overflow = "hidden";
+    body.style.position = "fixed";
+    body.style.top = `-${savedStyles.scrollY}px`;
+    body.style.width = "100%";
+  }
+  lockCount++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    lockCount = Math.max(0, lockCount - 1);
+    if (lockCount === 0 && savedStyles) {
+      const body = document.body;
+      body.style.overflow = savedStyles.overflow;
+      body.style.position = savedStyles.position;
+      body.style.top = savedStyles.top;
+      body.style.width = savedStyles.width;
+      window.scrollTo(0, savedStyles.scrollY);
+      savedStyles = null;
+    }
+  };
+};
+
+// src/core/features/inert-siblings.ts
+function createInertSiblings(rootProvider) {
+  const tracked = [];
+  return {
+    apply() {
+      if (typeof document === "undefined") return;
+      let top = rootProvider();
+      while (top.parentElement && top.parentElement !== document.body) {
+        top = top.parentElement;
+      }
+      const parent = top.parentElement ?? document.body;
+      for (const child of Array.from(parent.children)) {
+        if (child === top) continue;
+        if (child.hasAttribute("inert")) continue;
+        if (child.classList.contains("bs-backdrop") || child.classList.contains("bs-screen") || child.classList.contains("bs-root")) {
+          continue;
+        }
+        child.setAttribute("inert", "");
+        tracked.push(child);
+      }
+    },
+    remove() {
+      for (const el of tracked) el.removeAttribute("inert");
+      tracked.length = 0;
+    }
+  };
+}
+
+// src/core/controllers/lifecycle-controller.ts
+var LifecycleController = class {
+  constructor(deps, opts) {
+    __publicField(this, "element");
+    __publicField(this, "focusTrapEnabled");
+    __publicField(this, "initialFocus");
+    __publicField(this, "closeOnEscape");
+    __publicField(this, "bodyScrollLockEnabled");
+    __publicField(this, "inertSiblingsEnabled");
+    __publicField(this, "inertSiblings");
+    __publicField(this, "shouldApplyInertSiblings");
+    __publicField(this, "returnFocus");
+    __publicField(this, "releaseFocusTrap", null);
+    __publicField(this, "releaseScrollLock", null);
+    __publicField(this, "installed", false);
+    __publicField(this, "destroyed", false);
+    this.element = deps.element;
+    this.focusTrapEnabled = opts.focusTrap ?? false;
+    this.initialFocus = opts.initialFocus;
+    this.closeOnEscape = opts.closeOnEscape ?? true;
+    this.bodyScrollLockEnabled = opts.lockBodyScroll ?? true;
+    this.inertSiblingsEnabled = opts.inertSiblings ?? false;
+    this.shouldApplyInertSiblings = opts.shouldApplyInertSiblings ?? (() => true);
+    this.returnFocus = opts.returnFocus;
+    this.inertSiblings = createInertSiblings(() => this.element);
+  }
+  get isInstalled() {
+    return this.installed;
+  }
+  install() {
+    if (this.destroyed) return;
+    this.installed = true;
+    if (this.bodyScrollLockEnabled && !this.releaseScrollLock) {
+      this.releaseScrollLock = lockBodyScroll();
+    }
+    if (this.focusTrapEnabled && !this.releaseFocusTrap) {
+      this.releaseFocusTrap = installFocusTrap(this.element, {
+        initialFocus: this.initialFocus
+      });
+    }
+    if (this.inertSiblingsEnabled && this.shouldApplyInertSiblings()) {
+      this.inertSiblings.apply();
+    }
+  }
+  setReturnFocus(target) {
+    if (this.destroyed) return;
+    this.returnFocus = target;
+  }
+  release() {
+    if (!this.installed) return;
+    this.installed = false;
+    this.releaseFocusTrap?.();
+    this.releaseFocusTrap = null;
+    this.releaseScrollLock?.();
+    this.releaseScrollLock = null;
+    this.inertSiblings.remove();
+    if (this.returnFocus) {
+      const target = typeof this.returnFocus === "function" ? this.returnFocus() : this.returnFocus;
+      target?.focus?.();
+    }
+  }
+  destroy() {
+    this.release();
+    this.destroyed = true;
+  }
+};
+
+// src/core/gestures.ts
+var isAxisVertical = (mode) => mode === "bottom" || mode === "top";
+var SampleRing = class {
+  constructor(capacity) {
+    __publicField(this, "slots");
+    __publicField(this, "capacity");
+    __publicField(this, "head", 0);
+    __publicField(this, "size", 0);
+    this.capacity = capacity;
+    this.slots = new Array(capacity);
+    for (let i = 0; i < capacity; i++) this.slots[i] = { t: 0, v: 0 };
+  }
+  push(t, v) {
+    const slot = this.slots[this.head];
+    slot.t = t;
+    slot.v = v;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.size < this.capacity) this.size++;
+  }
+  pruneBefore(cutoff, minKeep) {
+    while (this.size > minKeep) {
+      const oldestIdx = (this.head - this.size + this.capacity) % this.capacity;
+      if (this.slots[oldestIdx].t < cutoff) this.size--;
+      else break;
+    }
+  }
+  get length() {
+    return this.size;
+  }
+  oldest() {
+    if (this.size === 0) return void 0;
+    return this.slots[(this.head - this.size + this.capacity) % this.capacity];
+  }
+  newest() {
+    if (this.size === 0) return void 0;
+    return this.slots[(this.head - 1 + this.capacity) % this.capacity];
+  }
+  reset() {
+    this.head = 0;
+    this.size = 0;
+  }
+};
+var installGestures = (handle, mode, callbacks) => {
+  let activePointerId = null;
+  let activePointerType = "touch";
+  let startCoord = 0;
+  let lastCoord = 0;
+  const VELOCITY_WINDOW_MS = (kind) => kind === "mouse" ? 160 : 120;
+  const MAX_SAMPLES = 32;
+  const samples = new SampleRing(MAX_SAMPLES);
+  const axis = isAxisVertical(mode) ? "Y" : "X";
+  const sign = mode === "bottom" || mode === "right" ? -1 : 1;
+  const coordOf = (e) => axis === "Y" ? e.clientY : e.clientX;
+  const onPointerDown = (e) => {
+    if (activePointerId !== null) return;
+    if (e.button !== void 0 && e.button !== 0) return;
+    activePointerId = e.pointerId;
+    activePointerType = e.pointerType || "touch";
+    startCoord = coordOf(e);
+    lastCoord = startCoord;
+    samples.reset();
+    samples.push(e.timeStamp, startCoord);
+    try {
+      handle.setPointerCapture(e.pointerId);
+    } catch {
+    }
+    callbacks.onStart(startCoord, activePointerType);
+  };
+  const onPointerMove = (e) => {
+    if (e.pointerId !== activePointerId) return;
+    const coord = coordOf(e);
+    const rawDelta = coord - startCoord;
+    const delta = rawDelta * sign;
+    lastCoord = coord;
+    samples.push(e.timeStamp, coord);
+    const cutoff = e.timeStamp - VELOCITY_WINDOW_MS(activePointerType);
+    samples.pruneBefore(cutoff, 2);
+    callbacks.onMove(delta);
+  };
+  const finishGesture = (e) => {
+    if (e.pointerId !== activePointerId) return;
+    const rawDelta = lastCoord - startCoord;
+    const delta = rawDelta * sign;
+    let velocity = 0;
+    if (samples.length >= 3) {
+      const first = samples.oldest();
+      const last = samples.newest();
+      const dt = last.t - first.t;
+      if (dt > 0) velocity = (last.v - first.v) / dt * sign;
+    }
+    const finishedKind = activePointerType;
+    activePointerId = null;
+    samples.reset();
+    try {
+      if (handle.hasPointerCapture(e.pointerId)) {
+        handle.releasePointerCapture(e.pointerId);
+      }
+    } catch {
+    }
+    callbacks.onEnd(delta, velocity, finishedKind);
+  };
+  const onPointerCancel = (e) => {
+    if (e.pointerId !== activePointerId) return;
+    activePointerId = null;
+    samples.reset();
+    callbacks.onCancel?.();
+  };
+  handle.addEventListener("pointerdown", onPointerDown);
+  handle.addEventListener("pointermove", onPointerMove);
+  handle.addEventListener("pointerup", finishGesture);
+  handle.addEventListener("pointercancel", onPointerCancel);
+  handle.style.touchAction = isAxisVertical(mode) ? "pan-x" : "pan-y";
+  return () => {
+    handle.removeEventListener("pointerdown", onPointerDown);
+    handle.removeEventListener("pointermove", onPointerMove);
+    handle.removeEventListener("pointerup", finishGesture);
+    handle.removeEventListener("pointercancel", onPointerCancel);
+    if (activePointerId !== null && handle.hasPointerCapture(activePointerId)) {
+      handle.releasePointerCapture(activePointerId);
+    }
+  };
+};
+
+// src/core/primitives/rubber-band.ts
+function rubberBand(overshoot, maxAxisSize) {
+  const cap = Math.min(maxAxisSize * 0.15, 80);
+  if (cap <= 0) return 0;
+  const abs = Math.abs(overshoot);
+  return Math.sign(overshoot) * (cap * abs / (abs + cap));
+}
+
+// src/core/features/soft-keyboard.ts
+function dismissSoftKeyboardIfFocused(root) {
+  if (typeof document === "undefined") return false;
+  const active = document.activeElement;
+  if (!active) return false;
+  if (!root.contains(active)) return false;
+  const tag = active.tagName;
+  const isEditable = tag === "INPUT" || tag === "TEXTAREA" || active.isContentEditable === true;
+  if (!isEditable) return false;
+  try {
+    active.blur();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/controllers/gesture-controller.ts
+var GestureController = class {
+  constructor(deps) {
+    __publicField(this, "deps");
+    __publicField(this, "detach", null);
+    __publicField(this, "isDragging_", false);
+    __publicField(this, "dragStartSize", 0);
+    __publicField(this, "currentPointerKind", "touch");
+    __publicField(this, "keyboardDismissed", false);
+    __publicField(this, "dragPayload", { size: 0, delta: 0 });
+    this.deps = deps;
+  }
+  get isDragging() {
+    return this.isDragging_;
+  }
+  install() {
+    if (this.detach) return this.detach;
+    this.detach = installGestures(this.deps.handle, this.deps.mode, {
+      onStart: (_coord, kind) => {
+        this.deps.cancelAnimation();
+        this.isDragging_ = true;
+        this.dragStartSize = this.deps.getDragContext().size;
+        this.currentPointerKind = kind;
+        this.keyboardDismissed = false;
+        this.deps.getRoot()?.setAttribute("data-dragging", "true");
+        this.deps.element.style.willChange = "transform";
+        this.deps.emit("dragstart", { size: this.dragStartSize });
+      },
+      onMove: (delta) => {
+        const ctx = this.deps.getDragContext();
+        const { min, max } = ctx.range;
+        const maxAxis = ctx.maxAxisSize;
+        const rubberOn = ctx.rubberBandEnabled;
+        let next = this.dragStartSize + delta;
+        if (next > max) {
+          next = rubberOn ? max + rubberBand(next - max, maxAxis) : max;
+        } else if (next < min) {
+          next = rubberOn ? min - rubberBand(min - next, maxAxis) : min;
+        }
+        this.deps.applySize(next);
+        if (!this.keyboardDismissed && this.currentPointerKind === "touch" && this.deps.mode === "bottom" && next < this.dragStartSize) {
+          if (dismissSoftKeyboardIfFocused(this.deps.element)) {
+            this.keyboardDismissed = true;
+          }
+        }
+        if (this.deps.listenerCount("drag") > 0) {
+          this.dragPayload.size = next;
+          this.dragPayload.delta = delta;
+          this.deps.emit("drag", this.dragPayload);
+        }
+      },
+      onEnd: (delta, velocity, kind) => {
+        this.isDragging_ = false;
+        this.keyboardDismissed = false;
+        this.deps.getRoot()?.removeAttribute("data-dragging");
+        this.deps.emit("dragend", {
+          size: this.deps.getDragContext().size,
+          velocity
+        });
+        this.deps.settleAfterDrag(delta, velocity, kind);
+      },
+      onCancel: () => {
+        this.isDragging_ = false;
+        this.keyboardDismissed = false;
+        this.deps.getRoot()?.removeAttribute("data-dragging");
+        this.deps.emit("dragend", {
+          size: this.deps.getDragContext().size,
+          velocity: 0
+        });
+        const restoreTo = this.dragStartSize;
+        void this.deps.animateTo(restoreTo, 0);
+      }
+    });
+    return this.detach;
+  }
+  forceClearDragState() {
+    if (!this.isDragging_) return;
+    this.isDragging_ = false;
+    this.keyboardDismissed = false;
+    this.deps.getRoot()?.removeAttribute("data-dragging");
+    this.deps.element.style.willChange = "auto";
+  }
+};
+
+// src/core/primitives/aria-slider-writer.ts
+var AriaSliderWriter = class {
+  constructor(handle, mode) {
+    __publicField(this, "handle", handle);
+    handle.setAttribute(
+      "aria-orientation",
+      mode === "bottom" || mode === "top" ? "vertical" : "horizontal"
+    );
+  }
+  setValue(allowedIds, activeId) {
+    if (allowedIds.length === 0) {
+      this.handle.removeAttribute("aria-valuemin");
+      this.handle.removeAttribute("aria-valuemax");
+      this.handle.removeAttribute("aria-valuenow");
+      this.handle.removeAttribute("aria-valuetext");
+      return;
+    }
+    const max = Math.max(allowedIds.length - 1, 0);
+    const idx = Math.max(allowedIds.indexOf(activeId), 0);
+    this.handle.setAttribute("aria-valuemin", "0");
+    this.handle.setAttribute("aria-valuemax", String(max));
+    this.handle.setAttribute("aria-valuenow", String(idx));
+    this.handle.setAttribute("aria-valuetext", activeId);
+  }
+};
+
+// src/core/features/scroll-cache.ts
+function createScrollCache(deps) {
+  const positions = /* @__PURE__ */ new Map();
+  const isSmallSize = (size) => {
+    const max = deps.getMaxAxisSize();
+    if (max <= 0) return false;
+    return size < max / 2;
+  };
+  return {
+    cache(fromId, prevSize, nextSize) {
+      const container = deps.scrollContainer;
+      if (!container) return;
+      if (isSmallSize(prevSize)) return;
+      if (!isSmallSize(nextSize)) return;
+      positions.set(fromId, container.scrollTop);
+    },
+    restore(toId, prevSize, nextSize) {
+      const container = deps.scrollContainer;
+      if (!container) return;
+      if (isSmallSize(nextSize)) return;
+      if (!isSmallSize(prevSize)) return;
+      const cached = positions.get(toId);
+      if (cached === void 0) return;
+      container.scrollTop = cached;
+      positions.delete(toId);
+    },
+    clear() {
+      positions.clear();
+    }
+  };
+}
+
+// src/core/primitives/anchor-animations.ts
+var DEFAULT_DURATION3 = 200;
+var DEFAULT_EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
+var PRESET_FRAMES = {
+  fade: {
+    enter: [{ opacity: 0 }, { opacity: 1 }],
+    exit: [{ opacity: 1 }, { opacity: 0 }]
+  },
+  scale: {
+    enter: [
+      { opacity: 0, transform: "scale(0.85)" },
+      { opacity: 1, transform: "scale(1)" }
+    ],
+    exit: [
+      { opacity: 1, transform: "scale(1)" },
+      { opacity: 0, transform: "scale(0.85)" }
+    ]
+  },
+  slide: {
+    enter: [
+      { opacity: 0, transform: "translateY(10px)" },
+      { opacity: 1, transform: "translateY(0)" }
+    ],
+    exit: [
+      { opacity: 1, transform: "translateY(0)" },
+      { opacity: 0, transform: "translateY(10px)" }
+    ]
+  },
+  pop: {
+    enter: [
+      { opacity: 0, transform: "scale(0.6)", offset: 0 },
+      { opacity: 1, transform: "scale(1.06)", offset: 0.7 },
+      { opacity: 1, transform: "scale(1)", offset: 1 }
+    ],
+    exit: [
+      { opacity: 1, transform: "scale(1)" },
+      { opacity: 0, transform: "scale(0.6)" }
+    ]
+  }
+};
+var INSTANT = {
+  finished: Promise.resolve(),
+  cancel: () => {
+  }
+};
+function resolveTransitionFrames(spec, phase) {
+  const fallback = { frames: null, duration: 0, easing: DEFAULT_EASING };
+  if (spec === "none") return fallback;
+  if (spec === void 0 || typeof spec === "string") {
+    const preset2 = PRESET_FRAMES[spec ?? "fade"];
+    return {
+      frames: preset2[phase],
+      duration: DEFAULT_DURATION3,
+      easing: DEFAULT_EASING
+    };
+  }
+  const custom = phase === "enter" ? spec.enter : spec.exit;
+  if (custom) {
+    return {
+      frames: custom,
+      duration: spec.duration ?? DEFAULT_DURATION3,
+      easing: spec.easing ?? DEFAULT_EASING
+    };
+  }
+  if (spec.preset === "none") return fallback;
+  const preset = PRESET_FRAMES[spec.preset ?? "fade"];
+  return {
+    frames: preset[phase],
+    duration: spec.duration ?? DEFAULT_DURATION3,
+    easing: spec.easing ?? DEFAULT_EASING
+  };
+}
+function runAnchorTransition(el, spec, phase) {
+  const respectReduced = typeof spec === "object" ? spec.respectReducedMotion !== false : true;
+  if (respectReduced && prefersReducedMotion()) return INSTANT;
+  const { frames, duration, easing } = resolveTransitionFrames(spec, phase);
+  if (!frames || duration <= 0) return INSTANT;
+  if (typeof el.animate !== "function") return INSTANT;
+  const animation = el.animate(frames, {
+    duration,
+    easing,
+    fill: "both"
+  });
+  const finished = animation.finished.then(() => void 0).catch(() => void 0);
+  return {
+    finished,
+    cancel: () => {
+      try {
+        animation.cancel();
+      } catch {
+        return;
+      }
+    }
+  };
+}
+
+// src/core/features/sheet-anchors.ts
+function attachAnchor(deps, opts) {
+  const doc = deps.host.ownerDocument;
+  const wrapper = doc.createElement("div");
+  wrapper.className = "bs-anchor";
+  const interactive = opts.interactive ?? true;
+  const position = opts.position ?? "sheet-top-right";
+  const isDock = position === "dock-bottom" || position === "dock-top";
+  const ws = wrapper.style;
+  ws.position = "fixed";
+  if (isDock) {
+    ws.left = "0";
+    ws.right = "0";
+    if (position === "dock-bottom") {
+      ws.bottom = "0";
+    } else {
+      ws.top = "0";
+    }
+  } else {
+    applyOverlayPosition(ws, deps.mode, position, opts.inset ?? "16px");
+  }
+  if (opts.fadeRange) {
+    const [r0, r1] = opts.fadeRange;
+    const span = Math.max(r1 - r0, 1e-4);
+    ws.opacity = `clamp(0, calc((var(--bs-progress, 0) - ${r0}) / ${span}), 1)`;
+  }
+  wrapper.appendChild(opts.element);
+  deps.host.appendChild(wrapper);
+  let visible = null;
+  let inFlight = null;
+  const shouldShow = (state) => {
+    if (typeof opts.showOn === "function") return opts.showOn(state);
+    if (Array.isArray(opts.showOn)) return opts.showOn.includes(state.activeId);
+    return isDock || state.size > 0;
+  };
+  const applyVisibility = (next, animate) => {
+    if (next === visible) return;
+    visible = next;
+    inFlight?.cancel();
+    inFlight = null;
+    wrapper.style.pointerEvents = next && interactive ? "auto" : "none";
+    if (next) {
+      wrapper.style.visibility = "";
+      if (animate) {
+        inFlight = runAnchorTransition(opts.element, opts.animation, "enter");
+      }
+      return;
+    }
+    if (!animate) {
+      wrapper.style.visibility = "hidden";
+      return;
+    }
+    const handle = runAnchorTransition(opts.element, opts.animation, "exit");
+    inFlight = handle;
+    void handle.finished.then(() => {
+      if (inFlight === handle && visible === false) {
+        wrapper.style.visibility = "hidden";
+      }
+    });
+  };
+  const evaluate = (animate) => {
+    if (deps.isDestroyed()) return;
+    applyVisibility(shouldShow(deps.getState()), animate);
+  };
+  const offs = [
+    deps.on("snap", () => evaluate(true)),
+    deps.on("open", () => evaluate(true)),
+    deps.on("close", () => evaluate(true))
+  ];
+  evaluate(false);
+  return {
+    wrapper,
+    detach: () => {
+      offs.forEach((off) => off());
+      inFlight?.cancel();
+      inFlight = null;
+      if (wrapper.parentNode) wrapper.parentNode.removeChild(wrapper);
+    },
+    syncZ: (z) => {
+      wrapper.style.zIndex = String(z);
+    }
+  };
+}
+
+// src/core/features/scrim-stages.ts
+var matchesId = (def, activeId) => {
+  if (def.for === void 0) return false;
+  return Array.isArray(def.for) ? def.for.includes(activeId) : def.for === activeId;
+};
+var matchesRange = (def, progress) => {
+  if (!def.forRange) return false;
+  const [from, to] = def.forRange;
+  return progress >= from && progress <= to;
+};
+function installScrimStages(deps, opts) {
+  const doc = deps.host.ownerDocument;
+  const entries = opts.stages.map((def) => {
+    const wrapper = doc.createElement("div");
+    wrapper.className = "bs-scrim-stage";
+    const ws = wrapper.style;
+    ws.position = "absolute";
+    applyOverlayPosition(
+      ws,
+      deps.mode,
+      def.position ?? opts.position ?? "center",
+      def.inset ?? opts.inset ?? "16px"
+    );
+    ws.visibility = "hidden";
+    ws.pointerEvents = "none";
+    wrapper.appendChild(def.element);
+    deps.host.appendChild(wrapper);
+    return { def, wrapper, inFlight: null };
+  });
+  let active = null;
+  const resolveActive = () => {
+    const state = deps.getState();
+    if (state.size === 0) {
+      return entries.find((e) => matchesId(e.def, state.activeId)) ?? null;
+    }
+    return entries.find((e) => matchesId(e.def, state.activeId)) ?? entries.find((e) => matchesRange(e.def, state.progress)) ?? null;
+  };
+  const hide = (entry, animate) => {
+    entry.inFlight?.cancel();
+    entry.wrapper.style.pointerEvents = "none";
+    if (!animate) {
+      entry.inFlight = null;
+      entry.wrapper.style.visibility = "hidden";
+      return;
+    }
+    const handle = runAnchorTransition(
+      entry.def.element,
+      entry.def.animation ?? opts.animation,
+      "exit"
+    );
+    entry.inFlight = handle;
+    void handle.finished.then(() => {
+      if (entry.inFlight === handle && active !== entry) {
+        entry.wrapper.style.visibility = "hidden";
+      }
+    });
+  };
+  const show = (entry, animate) => {
+    entry.inFlight?.cancel();
+    entry.inFlight = null;
+    entry.wrapper.style.visibility = "";
+    entry.wrapper.style.pointerEvents = entry.def.interactive ?? opts.interactive ?? false ? "auto" : "none";
+    if (animate) {
+      entry.inFlight = runAnchorTransition(
+        entry.def.element,
+        entry.def.animation ?? opts.animation,
+        "enter"
+      );
+    }
+  };
+  const update = (animate) => {
+    if (deps.isDestroyed()) return;
+    const next = resolveActive();
+    if (next === active) return;
+    const prev = active;
+    active = next;
+    if (prev) hide(prev, animate);
+    if (next) show(next, animate);
+  };
+  const offs = [
+    deps.on("snap", () => update(true)),
+    deps.on("open", () => update(true)),
+    deps.on("close", () => update(true))
+  ];
+  if (entries.some((e) => e.def.forRange)) {
+    offs.push(deps.on("progress", () => update(true)));
+  }
+  update(false);
+  return () => {
+    offs.forEach((off) => off());
+    for (const entry of entries) {
+      entry.inFlight?.cancel();
+      entry.inFlight = null;
+      if (entry.wrapper.parentNode) {
+        entry.wrapper.parentNode.removeChild(entry.wrapper);
+      }
+    }
+    active = null;
+  };
+}
+
+// src/core/primitives/engine-options.ts
+var DEFAULT_FLICK_VELOCITY = 0.65;
+var DEFAULT_DRAG_THRESHOLD = 18;
+function resolveEngineOptions(opts, extras) {
+  const initialAllowed = opts.allowed ?? opts.snapPoints.map((p) => p.id);
+  let initialId = opts.initial ?? initialAllowed[0] ?? opts.snapPoints[0]?.id ?? "default";
+  if (opts.persistKey) {
+    const restored = readPersistedId(opts.persistKey);
+    if (restored && initialAllowed.includes(restored)) {
+      initialId = restored;
+    }
+  }
+  return {
+    mode: opts.mode ?? "bottom",
+    flickVelocity: opts.flickVelocity ?? DEFAULT_FLICK_VELOCITY,
+    dragThreshold: opts.dragThreshold ?? DEFAULT_DRAG_THRESHOLD,
+    rubberBandEnabled: opts.rubberBand ?? true,
+    closeOnBack: opts.closeOnBack ?? false,
+    initialAllowed,
+    initialId,
+    scrim: {
+      scrimMode: opts.scrimMode,
+      scrimColor: opts.scrimColor,
+      scrimBlur: opts.scrimBlur,
+      scrimInteractive: opts.scrimInteractive ?? (opts.scrimTapToClose ? true : void 0),
+      scrimTapToClose: opts.scrimTapToClose,
+      scrimPreset: opts.scrimPreset,
+      screenRange: opts.screenRange,
+      backdropRange: opts.backdropRange
+    },
+    animation: {
+      animation: opts.animation,
+      duration: opts.duration,
+      easing: opts.easing,
+      spring: opts.spring,
+      respectReducedMotion: opts.respectReducedMotion,
+      viewTransitions: opts.viewTransitions
+    },
+    lifecycle: {
+      focusTrap: opts.focusTrap,
+      initialFocus: opts.initialFocus,
+      closeOnEscape: opts.closeOnEscape,
+      lockBodyScroll: opts.lockBodyScroll,
+      inertSiblings: opts.inertSiblings,
+      shouldApplyInertSiblings: extras?.shouldApplyInertSiblings
+    }
+  };
+}
+
+// src/core/BottomSheetEngine.ts
+var HAPTIC_DURATION_MS = 8;
+var TeardownStack = class {
+  constructor() {
+    __publicField(this, "fns", []);
+  }
+  add(fn) {
+    if (fn) this.fns.push(fn);
+  }
+  drain() {
+    while (this.fns.length) {
+      try {
+        this.fns.pop()();
+      } catch (err) {
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+    }
+  }
+};
+var BottomSheetEngine = class {
+  constructor(opts) {
+    __publicField(this, "id", nextInstanceId("bs"));
+    __publicField(this, "element");
+    __publicField(this, "handle");
+    __publicField(this, "scrollContainer");
+    __publicField(this, "backdrop");
+    __publicField(this, "screenComponent");
+    __publicField(this, "scrimParent", null);
+    __publicField(this, "mode");
+    __publicField(this, "flickVelocity");
+    __publicField(this, "dragThreshold");
+    __publicField(this, "rubberBandEnabled");
+    __publicField(this, "scrim");
+    __publicField(this, "aria");
+    __publicField(this, "animation");
+    __publicField(this, "lifecycle");
+    __publicField(this, "closeOnBack");
+    __publicField(this, "routedTo");
+    __publicField(this, "snapPointsRaw");
+    __publicField(this, "snaps");
+    __publicField(this, "activeId");
+    __publicField(this, "size", 0);
+    __publicField(this, "gesture");
+    __publicField(this, "rootEl", null);
+    __publicField(this, "destroyed", false);
+    __publicField(this, "currentViewTransition", null);
+    __publicField(this, "currentAbort", new AbortController());
+    __publicField(this, "sizeWriteSentinel", new WriteSentinel());
+    __publicField(this, "progressWriteSentinel", new WriteSentinel());
+    __publicField(this, "isTopSheet", true);
+    __publicField(this, "progressPayload", {
+      value: 0,
+      size: 0
+    });
+    __publicField(this, "dragContextBuf", {
+      size: 0,
+      maxAxisSize: 0,
+      range: { min: 0, max: 0 },
+      rubberBandEnabled: false
+    });
+    __publicField(this, "bus", createEventBus());
+    __publicField(this, "persistKey");
+    __publicField(this, "linkedSheets", []);
+    __publicField(this, "scrollCache");
+    __publicField(this, "teardowns", new TeardownStack());
+    __publicField(this, "anchors", []);
+    __publicField(this, "anchorHost", null);
+    __publicField(this, "stackZ", 100);
+    __publicField(this, "detachScrimStages", null);
+    __publicField(this, "stackEffectEnabled", false);
+    __publicField(this, "stackEffectPrimed", false);
+    __publicField(this, "transformTemplate");
+    const resolved = resolveEngineOptions(opts, {
+      shouldApplyInertSiblings: () => {
+        if (typeof document === "undefined") return false;
+        const bodyChildren = Array.from(document.body.children);
+        return bodyChildren.some(
+          (c) => c === opts.element || c.contains(opts.element)
+        );
+      }
+    });
+    this.element = opts.element;
+    this.handle = opts.handle ?? opts.element;
+    this.scrollContainer = opts.scrollContainer;
+    this.backdrop = opts.backdrop;
+    this.screenComponent = opts.scrim ?? opts.screenComponent;
+    this.scrimParent = this.screenComponent?.parentElement ?? null;
+    this.mode = resolved.mode;
+    this.transformTemplate = buildTransformTemplate(this.mode);
+    this.aria = new AriaSliderWriter(this.handle, this.mode);
+    this.flickVelocity = resolved.flickVelocity;
+    this.dragThreshold = resolved.dragThreshold;
+    this.rubberBandEnabled = resolved.rubberBandEnabled;
+    this.scrim = new ScrimController(
+      {
+        mode: this.mode,
+        screenComponent: this.screenComponent,
+        backdrop: this.backdrop,
+        isDestroyed: () => this.destroyed,
+        isTopSheet: () => this.isTopSheet,
+        getAllowedIds: () => this.snaps.getAllowedIds().slice(),
+        getResolvedSnaps: () => this.snaps.getResolvedSnaps().slice(),
+        snapTo: (id) => {
+          void this.snapTo(id);
+        },
+        close: () => {
+          void this.close();
+        }
+      },
+      resolved.scrim
+    );
+    this.animation = new AnimationRunner(
+      {
+        element: this.element,
+        getRootEl: () => this.rootEl,
+        applySize: (size) => this.applySize(size),
+        getSize: () => this.size,
+        isDragging: () => this.gesture?.isDragging ?? false
+      },
+      resolved.animation
+    );
+    this.lifecycle = new LifecycleController(
+      {
+        element: this.element,
+        close: () => this.close()
+      },
+      resolved.lifecycle
+    );
+    this.closeOnBack = resolved.closeOnBack;
+    this.routedTo = opts.routedTo;
+    this.stackEffectEnabled = opts.stackEffect ?? false;
+    this.snapPointsRaw = opts.snapPoints;
+    this.persistKey = opts.persistKey;
+    if (opts.linkedSheets) {
+      this.linkedSheets = opts.linkedSheets;
+    }
+    this.activeId = resolved.initialId;
+    auditVhUsage(this.snapPointsRaw);
+    this.rootEl = this.element.closest(".bs-root");
+    this.snaps = new SnapResolver(
+      this.snapPointsRaw,
+      resolved.initialAllowed,
+      this.mode,
+      () => layoutAxis(this.mode) === "width" ? this.handle.offsetWidth : this.handle.offsetHeight,
+      (maxAxisSize) => {
+        this.element.style[layoutAxis(this.mode)] = `${maxAxisSize}px`;
+      }
+    );
+    const initial = this.snaps.findById(this.activeId);
+    if (initial) this.size = initial.size;
+    this.applySize(this.size);
+    this.updateAriaSlider();
+    this.scrollCache = createScrollCache({
+      scrollContainer: this.scrollContainer,
+      getMaxAxisSize: () => this.snaps.getMaxAxisSize()
+    });
+    this.attach();
+    this.registerInStack();
+    if (this.snaps.getMaxAxisSize() === 0 && typeof IntersectionObserver !== "undefined" && typeof document !== "undefined") {
+      const io = new IntersectionObserver((entries) => {
+        for (const entry of entries) {
+          if (!entry.isIntersecting) continue;
+          if (this.destroyed) return;
+          this.snaps.recompute();
+          const current = this.snaps.findById(this.activeId);
+          if (current) {
+            this.size = current.size;
+            this.applySize(this.size);
+            this.updateAriaSlider();
+          }
+          io.disconnect();
+          return;
+        }
+      });
+      io.observe(this.element);
+      this.teardowns.add(() => io.disconnect());
+    }
+    if (this.persistKey) {
+      this.teardowns.add(installPersist(this, this.persistKey));
+    }
+    this.teardowns.add(
+      installAutoCollapse({
+        ms: opts.autoCollapseAfter,
+        isDestroyed: () => this.destroyed,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        getAllowedIds: () => this.snaps.getAllowedIds().slice(),
+        getActiveId: () => this.activeId,
+        resolveSnap: (id) => this.snaps.findById(id),
+        snapTo: (id) => {
+          void this.snapTo(id);
+        },
+        on: (event, fn) => this.on(event, fn)
+      })
+    );
+    this.teardowns.add(
+      installRoute({
+        routedTo: this.routedTo,
+        closeOnBack: this.closeOnBack,
+        isTopSheet: () => this.isTopSheet,
+        getSize: () => this.size,
+        isDestroyed: () => this.destroyed,
+        close: () => this.close(),
+        on: (event, fn) => this.on(event, fn),
+        sheetId: this.id
+      })
+    );
+    if (this.size > 0) {
+      this.handleOpen();
+    }
+  }
+  get state() {
+    return {
+      size: this.size,
+      activeId: this.activeId,
+      isDragging: this.gesture?.isDragging ?? false,
+      isAnimating: this.animation.isAnimating,
+      progress: this.computeProgress(this.size)
+    };
+  }
+  on(event, fn) {
+    return this.bus.on(event, fn);
+  }
+  use(plugin) {
+    if (this.destroyed) {
+      console.warn(
+        `[BottomSheet] use("${plugin.name}") called on destroyed engine \u2014 ignored.`
+      );
+      return this;
+    }
+    const scoped = [];
+    const scope = {
+      add: (fn) => {
+        if (typeof fn === "function") scoped.push(fn);
+      }
+    };
+    let teardown;
+    try {
+      teardown = plugin.install(this, scope);
+    } catch (err) {
+      for (let i = scoped.length - 1; i >= 0; i--) {
+        try {
+          scoped[i]();
+        } catch (cleanupErr) {
+          queueMicrotask(() => {
+            throw cleanupErr;
+          });
+        }
+      }
+      queueMicrotask(() => {
+        throw err;
+      });
+      return this;
+    }
+    for (const fn of scoped) this.teardowns.add(fn);
+    if (typeof teardown === "function") {
+      this.teardowns.add(teardown);
+    }
+    return this;
+  }
+  setLinkedSheets(sheets) {
+    if (this.destroyed) return;
+    this.linkedSheets = sheets;
+  }
+  getAllowedIds() {
+    return this.snaps.getAllowedIds().slice();
+  }
+  async snapTo(id, velocityOrOpts = 0, _skipBeforeSnap = false) {
+    if (this.destroyed) return;
+    const opts = typeof velocityOrOpts === "object" ? velocityOrOpts : { velocity: velocityOrOpts };
+    const velocityPxPerMs = opts.velocity ?? 0;
+    const externalSignal = opts.signal;
+    if (externalSignal?.aborted) return;
+    const target = this.snaps.findById(id);
+    if (!target) {
+      console.warn(`[BottomSheet] unknown snap id: ${id}`);
+      return;
+    }
+    if (!this.snaps.getAllowedIds().includes(id)) {
+      console.warn(`[BottomSheet] snap "${id}" is not in allowed list`);
+      return;
+    }
+    if (!_skipBeforeSnap && this.emitBeforeSnap(target, this.activeId)) {
+      return;
+    }
+    const signal = this.newCycle();
+    const onExternalAbort = () => {
+      this.animation.cancel();
+      this.newCycle();
+    };
+    externalSignal?.addEventListener("abort", onExternalAbort, { once: true });
+    const wasClosed = this.size === 0;
+    const previousId = this.activeId;
+    const previousSize = this.size;
+    this.scrollCache.cache(previousId, previousSize, target.size);
+    this.activeId = id;
+    if (this.animation.viewTransitionsAvailable) {
+      this.currentViewTransition?.skipTransition?.();
+      const vt = document.startViewTransition(() => {
+        this.applySize(target.size);
+      });
+      this.currentViewTransition = vt;
+      try {
+        await vt.finished;
+      } catch {
+      }
+      if (this.currentViewTransition === vt) this.currentViewTransition = null;
+    } else {
+      await this.animation.animateTo(target.size, velocityPxPerMs);
+    }
+    externalSignal?.removeEventListener("abort", onExternalAbort);
+    if (signal.aborted) return;
+    this.scrollCache.restore(id, previousSize, target.size);
+    this.updateAriaSlider();
+    this.emit("snap", { id, size: target.size });
+    if (wasClosed && target.size > 0) {
+      this.emit("open", { id });
+      this.handleOpen();
+      notifyLinkedSheets(this.linkedSheets, this);
+    }
+    if (target.size === 0) {
+      this.emit("close", void 0);
+      this.handleClose();
+    }
+  }
+  async dragTo(targetSize, velocityOrOpts = 0) {
+    if (this.destroyed) return;
+    const opts = typeof velocityOrOpts === "object" ? velocityOrOpts : { velocity: velocityOrOpts };
+    const velocityPxPerMs = opts.velocity ?? 0;
+    const externalSignal = opts.signal;
+    if (externalSignal?.aborted) return;
+    this.newCycle();
+    const onExternalAbort = () => {
+      this.animation.cancel();
+      this.newCycle();
+    };
+    externalSignal?.addEventListener("abort", onExternalAbort, { once: true });
+    const clamped = Math.max(0, Math.min(targetSize, this.snaps.getMaxAxisSize()));
+    await this.animation.animateTo(clamped, velocityPxPerMs);
+    externalSignal?.removeEventListener("abort", onExternalAbort);
+    if (this.destroyed || externalSignal?.aborted) return;
+  }
+  open(id) {
+    if (this.destroyed) return Promise.resolve();
+    const target = id ?? this.snaps.getAllowedIds().find((a) => a !== "closed") ?? this.activeId;
+    return this.snapTo(target);
+  }
+  close() {
+    if (this.destroyed) return Promise.resolve();
+    const closedId = this.snapPointsRaw.find((p) => p.id === "closed")?.id ?? this.snaps.getAllowedIds()[0];
+    return this.snapTo(closedId ?? this.activeId);
+  }
+  setAllowed(ids, snap) {
+    if (this.destroyed) return;
+    this.snaps.setAllowedIds(ids);
+    this.updateAriaSlider();
+    if (snap && ids.includes(snap)) {
+      void this.snapTo(snap, 0, true);
+    } else if (!ids.includes(this.activeId)) {
+      const fallback = ids[0];
+      if (fallback) void this.snapTo(fallback, 0, true);
+    }
+  }
+  setBackdropRange(range) {
+    this.scrim.setBackdropRange(range, () => this.applySize(this.size));
+  }
+  setScreenRange(range) {
+    this.scrim.setScreenRange(range, () => this.applySize(this.size));
+  }
+  setScrimColor(color) {
+    this.scrim.setScrimColor(color);
+  }
+  setScrimBlur(blur) {
+    this.scrim.setScrimBlur(blur);
+  }
+  setScrimInteractive(interactive) {
+    this.scrim.setScrimInteractive(interactive);
+  }
+  setScrim(opts) {
+    this.scrim.setScrim(opts, () => this.applySize(this.size));
+  }
+  setScrimMode(mode) {
+    this.scrim.setScrimMode(mode, () => this.applySize(this.size));
+  }
+  setScrimTapToClose(enabled) {
+    this.scrim.setScrimTapToClose(enabled);
+  }
+  setScrimEnabled(enabled) {
+    this.scrim.setScrimEnabled(enabled, () => this.applySize(this.size));
+  }
+  setScrimOverlay(opts) {
+    return this.scrim.setScrimOverlay(opts);
+  }
+  addAnchor(opts) {
+    if (this.destroyed || typeof document === "undefined") return () => {
+    };
+    if (!this.anchorHost) {
+      this.anchorHost = this.rootEl ?? this.element.parentElement ?? document.body;
+      this.anchorHost.style.setProperty("--bs-size", `${this.size}px`);
+      this.anchorHost.style.setProperty(
+        "--bs-progress",
+        String(this.computeProgress(this.size))
+      );
+    }
+    const handle = attachAnchor(
+      {
+        mode: this.mode,
+        host: this.anchorHost,
+        getState: () => ({
+          activeId: this.activeId,
+          size: this.size,
+          progress: this.computeProgress(this.size)
+        }),
+        on: (event, fn) => this.on(event, fn),
+        isDestroyed: () => this.destroyed
+      },
+      opts
+    );
+    handle.syncZ(this.stackZ + 1);
+    this.anchors.push(handle);
+    const detach = () => {
+      const idx = this.anchors.indexOf(handle);
+      if (idx === -1) return;
+      this.anchors.splice(idx, 1);
+      handle.detach();
+    };
+    this.teardowns.add(detach);
+    return detach;
+  }
+  setScrimStages(opts) {
+    if (this.destroyed || typeof document === "undefined") return () => {
+    };
+    this.detachScrimStages?.();
+    this.detachScrimStages = null;
+    if (!opts) return () => {
+    };
+    const host = this.screenComponent?.parentElement;
+    if (!host) {
+      console.warn(
+        "[BottomSheet] setScrimStages: no scrim element mounted \u2014 pass `scrim` to the engine first."
+      );
+      return () => {
+      };
+    }
+    const detachInstalled = installScrimStages(
+      {
+        mode: this.mode,
+        host,
+        getState: () => ({
+          activeId: this.activeId,
+          size: this.size,
+          progress: this.computeProgress(this.size)
+        }),
+        on: (event, fn) => this.on(event, fn),
+        isDestroyed: () => this.destroyed
+      },
+      opts
+    );
+    const detach = () => {
+      if (this.detachScrimStages === detach) this.detachScrimStages = null;
+      detachInstalled();
+    };
+    this.detachScrimStages = detach;
+    this.teardowns.add(() => this.detachScrimStages?.());
+    return detach;
+  }
+  getScrimState() {
+    return { mode: this.scrim.scrimMode, enabled: this.scrim.scrimEnabled };
+  }
+  setSnapPoints(points, allowed) {
+    if (this.destroyed) return;
+    this.animation.cancel();
+    this.newCycle();
+    this.snapPointsRaw = points;
+    auditVhUsage(points);
+    this.snaps.setRaw(points);
+    if (allowed) this.snaps.setAllowedIds(allowed);
+    this.scrollCache.clear();
+    this.scrim.invalidateOpacityCache();
+    const current = this.snaps.findById(this.activeId);
+    if (current) {
+      this.applySize(current.size);
+    }
+    this.updateAriaSlider();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.currentAbort.abort();
+    this.currentViewTransition?.skipTransition?.();
+    this.currentViewTransition = null;
+    this.bus.clear();
+    this.animation.cancel();
+    this.gesture?.forceClearDragState();
+    this.teardowns.drain();
+    this.scrim.destroy();
+    this.animation.destroy();
+    this.lifecycle.destroy();
+    if (this.backdrop) {
+      this.backdrop.style.opacity = "";
+      this.backdrop.style.pointerEvents = "";
+    }
+    if (this.screenComponent) {
+      this.screenComponent.style.opacity = "";
+      this.screenComponent.style.display = "";
+    }
+    this.sizeWriteSentinel.invalidate();
+    this.progressWriteSentinel.invalidate();
+  }
+  emit(event, payload) {
+    this.bus.emit(event, payload);
+  }
+  newCycle() {
+    this.currentAbort.abort();
+    this.currentAbort = new AbortController();
+    return this.currentAbort.signal;
+  }
+  emitBeforeSnap(target, previousId) {
+    let cancelled = false;
+    let frozen = false;
+    this.emit("before-snap", {
+      id: target.id,
+      size: target.size,
+      previousId,
+      cancel: () => {
+        if (frozen) {
+          console.warn(
+            "[BottomSheet] before-snap.cancel() called asynchronously \u2014 ignored. cancel() must be invoked synchronously inside the listener."
+          );
+          return;
+        }
+        cancelled = true;
+      }
+    });
+    frozen = true;
+    return cancelled;
+  }
+  recomputeSnaps() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of this.snapPointsRaw) {
+      if (seen.has(p.id)) {
+        console.warn(
+          `[BottomSheet] duplicate snap id "${p.id}" \u2014 only the first occurrence is reachable.`
+        );
+      }
+      seen.add(p.id);
+    }
+    this.snaps.setRaw(this.snapPointsRaw);
+    this.scrim.invalidateOpacityCache();
+  }
+  getAllowedRange() {
+    return this.snaps.getAllowedRange();
+  }
+  allowedIdsBySize() {
+    return this.snaps.getAllowedIds().slice().sort(
+      (a, b) => (this.snaps.findById(a)?.size ?? 0) - (this.snaps.findById(b)?.size ?? 0)
+    );
+  }
+  updateAriaSlider() {
+    this.aria.setValue(this.allowedIdsBySize(), this.activeId);
+  }
+  registerInStack() {
+    this.teardowns.add(sheetStack.push({
+      id: this.id,
+      setZIndex: (z) => {
+        this.stackZ = z;
+        this.element.style.zIndex = String(z);
+        if (this.backdrop) this.backdrop.style.zIndex = String(z - 1);
+        for (const anchor of this.anchors) anchor.syncZ(z + 1);
+      },
+      setIsTop: (isTop) => {
+        this.isTopSheet = isTop;
+        if (this.backdrop) {
+          this.backdrop.style.display = isTop ? "" : "none";
+        }
+      },
+      isOpen: () => this.size > 0,
+      setDepth: (depth) => this.applyStackDepth(depth)
+    }));
+  }
+  applyStackDepth(depth) {
+    if (!this.stackEffectEnabled) return;
+    this.element.setAttribute("data-stack-depth", String(depth));
+    if (!this.stackEffectPrimed) {
+      this.stackEffectPrimed = true;
+      const isVertical = this.mode === "bottom" || this.mode === "top";
+      this.element.style.transformOrigin = isVertical ? "50% 100%" : "0% 50%";
+      this.element.style.transition = "scale 320ms cubic-bezier(0.29, 1.04, 0.84, 0.99)";
+    }
+    const scale = Math.max(1 - depth * 0.04, 0.86);
+    this.element.style.scale = scale === 1 ? "" : String(scale);
+  }
+  attach() {
+    this.gesture = new GestureController({
+      handle: this.handle,
+      element: this.element,
+      mode: this.mode,
+      getRoot: () => this.rootEl,
+      getDragContext: () => {
+        const buf = this.dragContextBuf;
+        const r = this.getAllowedRange();
+        buf.size = this.size;
+        buf.maxAxisSize = this.snaps.getMaxAxisSize();
+        buf.range.min = r.min;
+        buf.range.max = r.max;
+        buf.rubberBandEnabled = this.rubberBandEnabled;
+        return buf;
+      },
+      cancelAnimation: () => this.animation.cancel(),
+      applySize: (size) => this.applySize(size),
+      animateTo: (size, velocity) => this.animation.animateTo(size, velocity),
+      settleAfterDrag: (delta, velocity, kind) => this.settleAfterDrag(delta, velocity, kind),
+      emit: (event, payload) => this.emit(event, payload),
+      listenerCount: (event) => this.bus.listenerCount(event)
+    });
+    this.teardowns.add(this.gesture.install());
+    try {
+      this.attachFeatures();
+    } catch (err) {
+      this.teardowns.drain();
+      try {
+        this.scrim.destroy();
+      } catch (destroyErr) {
+        queueMicrotask(() => {
+          throw destroyErr;
+        });
+      }
+      try {
+        this.animation.destroy();
+      } catch (destroyErr) {
+        queueMicrotask(() => {
+          throw destroyErr;
+        });
+      }
+      try {
+        this.lifecycle.destroy();
+      } catch (destroyErr) {
+        queueMicrotask(() => {
+          throw destroyErr;
+        });
+      }
+      this.destroyed = true;
+      throw err;
+    }
+  }
+  attachFeatures() {
+    if (this.scrollContainer) {
+      this.teardowns.add(installContentSwipe({
+        container: this.scrollContainer,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        isAnimating: () => this.animation.isAnimating,
+        getAllowedIds: () => this.allowedIdsBySize(),
+        getActiveId: () => this.activeId,
+        snapTo: (id) => {
+          void this.snapTo(id);
+        }
+      }));
+    }
+    if (typeof window !== "undefined") {
+      this.teardowns.add(installResizeObserver({
+        element: this.element,
+        getMode: () => this.mode,
+        isDestroyed: () => this.destroyed,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        resolveActiveSnap: () => this.snaps.findById(this.activeId),
+        getMaxAxisSize: () => this.snaps.getMaxAxisSize(),
+        getSize: () => this.size,
+        setMaxAxisSize: (size) => {
+          this.snaps.setMaxAxisSize(size);
+        },
+        setSize: (size) => {
+          this.size = size;
+        },
+        recomputeSnaps: () => this.recomputeSnaps(),
+        applySize: (size) => this.applySize(size),
+        cancelInFlight: () => {
+          this.animation.cancel();
+        },
+        newCycle: () => {
+          this.newCycle();
+        },
+        isAnimating: () => this.animation.isAnimating,
+        resyncAfterCancel: () => this.resyncAfterResize()
+      }));
+      if (this.lifecycle.closeOnEscape) {
+        const onKey = (e) => {
+          if (this.destroyed || e.defaultPrevented) return;
+          if (e.key === "Escape" && this.isTopSheet && this.size > 0) {
+            void this.close();
+          }
+        };
+        document.addEventListener("keydown", onKey);
+        this.teardowns.add(
+          () => document.removeEventListener("keydown", onKey)
+        );
+      }
+      this.teardowns.add(installVisualViewport({
+        element: this.element,
+        isVerticalAxis: () => this.mode === "bottom" || this.mode === "top",
+        isDestroyed: () => this.destroyed,
+        isDragging: () => this.gesture?.isDragging ?? false,
+        recomputeSnaps: () => this.recomputeSnaps(),
+        resolveActiveSnap: () => this.snaps.findById(this.activeId),
+        getMaxAxisSize: () => this.snaps.getMaxAxisSize(),
+        getSize: () => this.size,
+        setMaxAxisSize: (size) => {
+          this.snaps.setMaxAxisSize(size);
+        },
+        setSize: (size) => {
+          this.size = size;
+        },
+        applySize: (size) => this.applySize(size)
+      }));
+    }
+    this.teardowns.add(installSliderKeyboard({
+      handle: this.handle,
+      mode: this.mode,
+      isDestroyed: () => this.destroyed,
+      getAllowedIds: () => this.allowedIdsBySize(),
+      getActiveId: () => this.activeId,
+      snapTo: (id) => {
+        void this.snapTo(id);
+      }
+    }));
+    this.scrim.attach();
+  }
+  settleAfterDrag(delta, velocity, kind = "touch") {
+    const signal = this.newCycle();
+    const target = this.snaps.findDragSettleTarget({
+      delta,
+      velocity,
+      pointerKind: kind,
+      size: this.size,
+      activeId: this.activeId,
+      flickVelocity: this.flickVelocity,
+      dragThreshold: this.dragThreshold
+    });
+    if (!target) return;
+    const previousId = this.activeId;
+    if (target.id === previousId && target.size === this.size) return;
+    if (this.emitBeforeSnap(target, previousId)) {
+      const restore = this.snaps.findById(previousId);
+      if (restore) {
+        void this.animation.animateTo(restore.size, 0);
+      }
+      return;
+    }
+    const previousSize = this.size;
+    const previousSnapSize = this.snaps.findById(previousId)?.size;
+    this.scrollCache.cache(previousId, previousSize, target.size);
+    this.activeId = target.id;
+    void this.animation.animateTo(target.size, velocity).then(() => {
+      if (signal.aborted) return;
+      this.scrollCache.restore(target.id, previousSize, target.size);
+      this.updateAriaSlider();
+      this.emit("snap", { id: target.id, size: target.size });
+      this.haptic();
+      if (previousSnapSize === 0 && target.size > 0) {
+        this.emit("open", { id: target.id });
+        this.handleOpen();
+        notifyLinkedSheets(this.linkedSheets, this);
+      }
+      if (target.size === 0) {
+        this.emit("close", void 0);
+        this.handleClose();
+      }
+    });
+  }
+  haptic() {
+    if (typeof navigator !== "undefined" && "vibrate" in navigator) {
+      try {
+        navigator.vibrate(HAPTIC_DURATION_MS);
+      } catch {
+      }
+    }
+  }
+  applySize(size) {
+    this.size = size;
+    const offset = this.snaps.getMaxAxisSize() - size;
+    const style = this.element.style;
+    style.transform = this.transformTemplate(offset);
+    if (this.sizeWriteSentinel.shouldWrite(size, SIZE_WRITE_EPSILON)) {
+      style.setProperty("--bs-size", `${size}px`);
+      if (this.scrimParent) {
+        this.scrimParent.style.setProperty("--bs-size", `${size}px`);
+      }
+      if (this.anchorHost && this.anchorHost !== this.scrimParent) {
+        this.anchorHost.style.setProperty("--bs-size", `${size}px`);
+      }
+    }
+    const progress = this.computeProgress(size);
+    const progressChanged = this.progressWriteSentinel.shouldWrite(
+      progress,
+      OPACITY_WRITE_EPSILON
+    );
+    if (progressChanged) {
+      style.setProperty("--bs-progress", String(progress));
+      if (this.anchorHost) {
+        this.anchorHost.style.setProperty("--bs-progress", String(progress));
+      }
+    }
+    this.scrim.applyOpacity(progress, progressChanged);
+    if (progressChanged && this.bus.listenerCount("progress") > 0) {
+      this.progressPayload.value = progress;
+      this.progressPayload.size = size;
+      this.emit("progress", this.progressPayload);
+    }
+  }
+  computeProgress(size) {
+    const { min, max } = this.getAllowedRange();
+    if (max <= min) return 0;
+    return Math.min(Math.max((size - min) / (max - min), 0), 1);
+  }
+  handleOpen() {
+    sheetStack.promote(this.id);
+    try {
+      this.lifecycle.install();
+    } catch (err) {
+      if (!this.destroyed) this.newCycle();
+      this.handleClose();
+      this.applySize(0);
+      this.activeId = this.snapPointsRaw.find((p) => p.id === "closed")?.id ?? this.activeId;
+      this.size = 0;
+      queueMicrotask(() => {
+        throw err;
+      });
+    }
+  }
+  resyncAfterResize() {
+    if (this.destroyed) return;
+    const target = this.snaps.findById(this.activeId);
+    if (!target) return;
+    this.updateAriaSlider();
+    this.emit("snap", { id: target.id, size: target.size });
+    if (target.size > 0 && !this.lifecycle.isInstalled) {
+      this.emit("open", { id: target.id });
+      this.handleOpen();
+      notifyLinkedSheets(this.linkedSheets, this);
+    } else if (target.size === 0 && this.lifecycle.isInstalled) {
+      this.emit("close", void 0);
+      this.handleClose();
+    }
+  }
+  handleClose() {
+    this.lifecycle.release();
+    sheetStack.update();
+  }
+};
+
+// src/svelte/useBottomSheet.svelte.ts
+var SSR_STATE = Object.freeze({
+  size: 0,
+  activeId: "",
+  isDragging: false,
+  isAnimating: false,
+  progress: 0
+});
+function createBottomSheet(opts) {
+  let engine = null;
+  const pending = [];
+  const attach = (refs) => {
+    if (engine) engine.destroy();
+    const { onSnap, ...engineOpts } = opts;
+    const created = new BottomSheetEngine({ ...engineOpts, ...refs });
+    engine = created;
+    if (onSnap) {
+      created.on("snap", (payload) => onSnap(payload.id));
+    }
+    for (const entry of pending) {
+      entry.engineUnsub = created.on(entry.event, entry.fn);
+    }
+    pending.length = 0;
+    return () => {
+      created.destroy();
+      if (engine === created) engine = null;
+    };
+  };
+  return {
+    attach,
+    state: () => engine?.state ?? SSR_STATE,
+    on: (event, fn) => {
+      if (engine) return engine.on(event, fn);
+      const entry = { event, fn, engineUnsub: null };
+      pending.push(entry);
+      return () => {
+        if (entry.engineUnsub) {
+          entry.engineUnsub();
+          entry.engineUnsub = null;
+        } else {
+          const idx = pending.indexOf(entry);
+          if (idx !== -1) pending.splice(idx, 1);
+        }
+      };
+    },
+    snapTo: (id) => engine?.snapTo(id) ?? Promise.resolve(),
+    open: (id) => engine?.open(id) ?? Promise.resolve(),
+    close: () => engine?.close() ?? Promise.resolve(),
+    setAllowed: (ids, snap) => engine?.setAllowed(ids, snap),
+    setSnapPoints: (points, allowed) => engine?.setSnapPoints(points, allowed),
+    setScrim: (scrimOpts) => engine?.setScrim(scrimOpts),
+    setScrimOverlay: (overlayOpts) => engine?.setScrimOverlay(overlayOpts) ?? (() => {
+    }),
+    addAnchor: (anchorOpts) => engine?.addAnchor(anchorOpts) ?? (() => {
+    }),
+    setScrimStages: (stagesOpts) => engine?.setScrimStages(stagesOpts) ?? (() => {
+    }),
+    destroy: () => {
+      engine?.destroy();
+      engine = null;
+    },
+    getEngine: () => engine
+  };
+}
+
+export { createBottomSheet };
+//# sourceMappingURL=svelte-core.js.map
+//# sourceMappingURL=svelte-core.js.map