@surdeddd/bottom-sheet 0.1.0

package/dist/element.cjs

@@ -0,0 +1,3442 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/lifecycle/sheetStack.ts
+var BASE_Z, STEP, SheetStack, sheetStack;
+var init_sheetStack = __esm({
+  "src/core/lifecycle/sheetStack.ts"() {
+    BASE_Z = 100;
+    STEP = 10;
+    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();
+      }
+      size() {
+        return this.entries.length;
+      }
+      clear() {
+        this.entries = [];
+      }
+      recompute() {
+        this.entries.forEach((entry, i) => {
+          entry.setZIndex(BASE_Z + i * STEP);
+          entry.setIsTop(i === this.entries.length - 1);
+        });
+      }
+    };
+    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;
+var init_transform = __esm({
+  "src/core/primitives/transform.ts"() {
+    layoutAxis = (axis) => axis === "left" || axis === "right" ? "width" : "height";
+  }
+});
+
+// src/core/primitives/instance-id.ts
+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]}`;
+}
+var counters;
+var init_instance_id = __esm({
+  "src/core/primitives/instance-id.ts"() {
+    counters = {};
+  }
+});
+
+// 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();
+    }
+  };
+}
+var init_event_bus = __esm({
+  "src/core/primitives/event-bus.ts"() {
+  }
+});
+
+// src/core/primitives/cssLength.ts
+var probe, PROBE_ATTR, ensureProbe, isViewportAxisVertical, viewportSize, PERCENT, resolveSnap;
+var init_cssLength = __esm({
+  "src/core/primitives/cssLength.ts"() {
+    probe = null;
+    PROBE_ATTR = "data-bs-probe";
+    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;
+    };
+    isViewportAxisVertical = (mode) => mode === "bottom" || mode === "top";
+    viewportSize = (mode) => {
+      if (typeof window === "undefined") return 0;
+      return isViewportAxisVertical(mode) ? window.innerHeight : window.innerWidth;
+    };
+    PERCENT = /^(-?\d+(?:\.\d+)?)%$/;
+    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, VH_NOT_DVH, auditVhUsage, findNearest, allowedRange, findById, MOUSE_FLICK_VELOCITY, MOUSE_DRAG_THRESHOLD, DIRECTIONAL_INTENT_VELOCITY, findDragSettleTarget;
+var init_snap_points = __esm({
+  "src/core/primitives/snap-points.ts"() {
+    init_cssLength();
+    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);
+    VH_NOT_DVH = /(^|[^a-z])vh\b/i;
+    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`
+        );
+      }
+    };
+    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;
+    };
+    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
+      };
+    };
+    findById = (id, resolved) => resolved.find((p) => p.id === id) ?? null;
+    MOUSE_FLICK_VELOCITY = 0.4;
+    MOUSE_DRAG_THRESHOLD = 12;
+    DIRECTIONAL_INTENT_VELOCITY = 0.15;
+    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;
+var init_snap_resolver = __esm({
+  "src/core/primitives/snap-resolver.ts"() {
+    init_snap_points();
+    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();
+      }
+      /**
+       * Re-resolve raw → resolved against the current viewport / fit-measure,
+       * recompute maxAxisSize, invalidate range cache, notify engine. Called on
+       * resize, orientationchange, visualViewport changes, and snap-list swaps.
+       */
+      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);
+      }
+      /** Replace the raw snap list and recompute. Engine calls on `setSnapPoints`. */
+      setRaw(raw) {
+        this.raw = raw;
+        this.recompute();
+      }
+      /**
+       * Replace the allow-list. Range cache depends on `(resolvedSnaps ×
+       * allowedIds)` so flipping ids alone invalidates without a full recompute.
+       */
+      setAllowedIds(ids) {
+        this.allowedIds = ids;
+        this.rangeCache = null;
+      }
+      findById(id) {
+        return findById(id, this.resolved);
+      }
+      /**
+       * Pure drag-settle target resolution. Engine passes the gesture-specific
+       * fields (delta, velocity, pointerKind, flickVelocity, dragThreshold) plus
+       * `size`/`activeId` since those are still engine-owned.
+       */
+      findDragSettleTarget(args) {
+        return findDragSettleTarget({
+          ...args,
+          resolved: this.resolved,
+          allowed: this.allowedIds,
+          maxAxisSize: this.maxAxisSize
+        });
+      }
+      /**
+       * Memoised allowed-range query. Twice-per-drag-frame (gesture onMove +
+       * applySize→computeProgress); cache collapses 2× iteration of resolvedSnaps
+       * to one recompute per geometry/allow-list change.
+       */
+      getAllowedRange() {
+        return this.rangeCache ?? (this.rangeCache = allowedRange(this.resolved, this.allowedIds));
+      }
+      /**
+       * Read-only view of resolved snaps. Returned as `readonly` to discourage
+       * accidental mutation by feature install sites that close over this list.
+       */
+      getResolvedSnaps() {
+        return this.resolved;
+      }
+      getAllowedIds() {
+        return this.allowedIds;
+      }
+      getMaxAxisSize() {
+        return this.maxAxisSize;
+      }
+      /**
+       * External clamp override. The resize-observer feature compares
+       * `getMaxAxisSize()` against the live viewport and shrinks if the largest
+       * resolved snap exceeds it (mobile address-bar collapse / soft-keyboard
+       * window resize). The next `recompute()` overwrites this clamp from the
+       * resolved-snap reduction.
+       *
+       * Does NOT invalidate the range cache — viewport clamping doesn't change
+       * `(resolvedSnaps × allowedIds) → range`. DOES fire `onMaxAxisSizeChange`
+       * so the resolver owns the layout-axis style write end-to-end (symmetric
+       * with `recompute()` — feature call sites no longer duplicate the write).
+       */
+      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;
+}
+var init_persist = __esm({
+  "src/core/features/persist.ts"() {
+  }
+});
+
+// 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 allowed = deps.getAllowedIds();
+    const target = allowed.find((id) => {
+      const snap = deps.resolveSnap(id);
+      return snap !== null && snap.size > 0;
+    });
+    if (!target) return;
+    if (target === deps.getActiveId()) return;
+    deps.snapTo(target);
+  };
+  const reset = () => {
+    clearTimer();
+    if (deps.isDestroyed()) return;
+    timer = setTimeout(() => {
+      timer = null;
+      fire();
+    }, ms);
+  };
+  const unsubscribe = deps.on("snap", () => reset());
+  return () => {
+    clearTimer();
+    unsubscribe();
+  };
+}
+var init_auto_collapse = __esm({
+  "src/core/features/auto-collapse.ts"() {
+  }
+});
+
+// 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 {
+      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;
+      });
+    }
+  }
+}
+var init_linked_sheets = __esm({
+  "src/core/features/linked-sheets.ts"() {
+  }
+});
+
+// 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);
+    }
+  };
+}
+var init_route = __esm({
+  "src/core/features/route.ts"() {
+  }
+});
+
+// src/core/features/content-swipe.ts
+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);
+  };
+}
+var CONTENT_PULL_THRESHOLD;
+var init_content_swipe = __esm({
+  "src/core/features/content-swipe.ts"() {
+    CONTENT_PULL_THRESHOLD = 60;
+  }
+});
+
+// src/core/features/visual-viewport.ts
+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);
+  };
+}
+var SAFETY_PAD;
+var init_visual_viewport = __esm({
+  "src/core/features/visual-viewport.ts"() {
+    SAFETY_PAD = 8;
+  }
+});
+
+// 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);
+    }
+    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);
+  };
+  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);
+  };
+}
+var init_resize_observer = __esm({
+  "src/core/features/resize-observer.ts"() {
+  }
+});
+
+// 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);
+}
+var init_slider_keyboard = __esm({
+  "src/core/features/slider-keyboard.ts"() {
+  }
+});
+
+// src/core/types.ts
+var SCRIM_PRESETS;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    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, OPACITY_WRITE_EPSILON, POINTER_EVENTS_OPACITY_THRESHOLD, RANGE_DIVISION_EPSILON;
+var init_hot_path_thresholds = __esm({
+  "src/core/primitives/hot-path-thresholds.ts"() {
+    SIZE_WRITE_EPSILON = 0.5;
+    OPACITY_WRITE_EPSILON = 5e-3;
+    POINTER_EVENTS_OPACITY_THRESHOLD = 0.05;
+    RANGE_DIVISION_EPSILON = 1e-4;
+  }
+});
+
+// src/core/primitives/opacity-dedup.ts
+var WriteSentinel;
+var init_opacity_dedup = __esm({
+  "src/core/primitives/opacity-dedup.ts"() {
+    WriteSentinel = class {
+      constructor() {
+        __publicField(this, "last", -1);
+      }
+      /**
+       * Returns `true` (and updates the cached value) if `next` differs from the
+       * cached `last` by more than `epsilon`. Returns `false` (and leaves the
+       * cache untouched) when the delta is within epsilon — caller skips the
+       * CSSOM write.
+       */
+      shouldWrite(next, epsilon) {
+        if (Math.abs(next - this.last) <= epsilon) return false;
+        this.last = next;
+        return true;
+      }
+      /**
+       * Force the next `shouldWrite` to pass. Resets the cache to `-1` so any
+       * non-negative `next` exceeds the epsilon comparison. Called from setters
+       * that mutate state under the cache (range/mode/enabled flips that change
+       * the progress→opacity mapping but don't move `progress` itself).
+       */
+      invalidate() {
+        this.last = -1;
+      }
+      /**
+       * Record `value` as the last-written without performing a write. Used
+       * when a setter writes a literal value through a different path (e.g.
+       * `setScrimMode("off")` writes `opacity: "0"` inline) and wants future
+       * `shouldWrite` calls to short-circuit against that known cached state.
+       */
+      setLastWritten(value) {
+        this.last = value;
+      }
+      /** Read-only accessor for diagnostic / dedup-aware peek. */
+      get value() {
+        return this.last;
+      }
+    };
+  }
+});
+
+// src/core/controllers/scrim-controller.ts
+var ScrimController;
+var init_scrim_controller = __esm({
+  "src/core/controllers/scrim-controller.ts"() {
+    init_types();
+    init_snap_points();
+    init_hot_path_thresholds();
+    init_opacity_dedup();
+    ScrimController = class {
+      constructor(deps, opts) {
+        // ── DOM refs (mirror engine's; cached for hot path) ─────────────────
+        __publicField(this, "screenComponent");
+        __publicField(this, "backdrop");
+        __publicField(this, "mode");
+        // ── Engine callbacks ────────────────────────────────────────────────
+        __publicField(this, "isDestroyed");
+        __publicField(this, "isTopSheet");
+        __publicField(this, "getAllowedIds");
+        __publicField(this, "getResolvedSnaps");
+        __publicField(this, "snapToFn");
+        // ── Mode + state ────────────────────────────────────────────────────
+        __publicField(this, "scrimMode");
+        __publicField(this, "backdropRange");
+        __publicField(this, "screenRange");
+        // setScrimEnabled toggle — gated through `scrimEnabled` rather than nuking
+        // ranges so re-enable can restore prior values without a remount. Public
+        // so tests / introspection can read it without an `as any` cast.
+        __publicField(this, "scrimEnabled", true);
+        __publicField(this, "savedScrimRanges", null);
+        // ── Tap-to-close ────────────────────────────────────────────────────
+        __publicField(this, "scrimTapToCloseEnabled", false);
+        __publicField(this, "detachScrimTap", null);
+        // ── Scrim overlay slot (positioned floating element) ────────────────
+        __publicField(this, "scrimOverlayTeardown", null);
+        // ── Hot-path opacity dedup caches (per-frame writes) ────────────────
+        // Numeric sentinels migrated to WriteSentinel primitive — single
+        // invalidation surface, shared with the engine's size/progress sentinels.
+        // The two string-typed sentinels (`Pointer`, `Display`) keep their inline
+        // pattern: equality on string union, no epsilon, different reset semantics.
+        __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.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";
+          }
+        }
+      }
+      /**
+       * Invalidate the opacity dedup caches. Called from any setter that mutates
+       * range/mode/enabled — opacity is a pure function of (progress, range,
+       * enabled), so a config change makes the cached values stale even if
+       * `progress` itself didn't move. Next `applyOpacity(progress, false)` call
+       * sees the -1 sentinel and re-runs the math instead of short-circuiting.
+       *
+       * Public for the engine: `setSnapPoints` mutates resolved geometry which
+       * shifts `progress→opacity` mapping under the cache; engine calls this to
+       * keep the next render frame correct on a static sheet.
+       * @internal
+       */
+      invalidateOpacityCache() {
+        this.backdropOpacitySentinel.invalidate();
+        this.screenOpacitySentinel.invalidate();
+      }
+      /** Engine calls this when its `attach()` runs — installs scrim-tap-click if requested. */
+      attach() {
+        if (this.scrimTapToCloseEnabled) {
+          this.setScrimTapToClose(true);
+        }
+      }
+      // ── Hot-path: opacity computation called per-frame from engine.applySize ──
+      /**
+       * Per-frame opacity writer. Computes backdrop + screen opacity from the
+       * sheet's progress (0..1 within allowed range), gated by sub-pixel dedup
+       * caches so steady-state frames don't trigger style recalc.
+       *
+       * `progressChanged` is the engine's already-computed dedup gate — when
+       * `false`, opacity is by construction a pure function of `progress` so
+       * cached values are still valid; we short-circuit the Math.min/max +
+       * division work entirely. Setters that mutate ranges/mode/enabled
+       * invalidate the cache by writing -1 sentinels so the next call re-runs
+       * the math.
+       */
+      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;
+          }
+        }
+      }
+      // ── Public setters (engine forwards these 1:1) ─────────────────────
+      /**
+       * Replace the [start, end] progress window in which the backdrop fades 0→1.
+       * @param range - Tuple of two progress values in 0..1 (start <= end).
+       * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+       * @example
+       *   // Backdrop only starts darkening after the sheet crosses 30% open.
+       *   engine.setBackdropRange([0.3, 1]);
+       */
+      setBackdropRange(range, applySize) {
+        if (this.isDestroyed()) return;
+        this.backdropRange = range;
+        this.invalidateOpacityCache();
+        applySize();
+      }
+      /**
+       * Replace the [start, end] progress window in which the screen scrim fades 0→1.
+       * @param range - Tuple of two progress values in 0..1 (start <= end).
+       * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+       * @example
+       *   // Scrim is fully opaque only when the sheet is past 50% — softer feel.
+       *   engine.setScreenRange([0, 0.5]);
+       */
+      setScreenRange(range, applySize) {
+        if (this.isDestroyed()) return;
+        this.screenRange = range;
+        this.invalidateOpacityCache();
+        applySize();
+      }
+      /**
+       * Set the scrim background color. Pass `null`/`undefined` to clear the
+       * inline write and let consumer CSS take over.
+       * @param color - Any valid CSS color string, or `null`/`undefined` to clear.
+       * @example
+       *   engine.setScrimColor("rgba(0, 0, 0, 0.6)");
+       *   engine.setScrimColor(null); // hand back to consumer CSS
+       */
+      setScrimColor(color) {
+        if (this.isDestroyed()) return;
+        this.applyScrimStyles({ color: color === void 0 ? null : color });
+      }
+      /**
+       * Set the scrim backdrop-filter blur radius. Pass `null`/`undefined` to clear.
+       * @param blur - CSS length (e.g. `"8px"`) consumed as `blur(<value>)`, or
+       *               `null`/`undefined` to remove the filter.
+       * @example
+       *   engine.setScrimBlur("12px"); // frosted-glass effect
+       *   engine.setScrimBlur(null);    // disable blur
+       */
+      setScrimBlur(blur) {
+        if (this.isDestroyed()) return;
+        this.applyScrimStyles({ blur: blur === void 0 ? null : blur });
+      }
+      /**
+       * Toggle whether the scrim layer captures pointer events.
+       * @param interactive - `true` → `pointer-events: auto`; `false` → `none`.
+       * @example
+       *   engine.setScrimInteractive(true);  // scrim swallows clicks
+       *   engine.setScrimInteractive(false); // clicks pass through to content below
+       */
+      setScrimInteractive(interactive) {
+        if (this.isDestroyed()) return;
+        this.applyScrimStyles({ interactive });
+      }
+      /**
+       * Switch scrim positioning at runtime.
+       * @param mode - `"full"` (consumer CSS), `"above-sheet"` (engine-pinned inset
+       *               so only the area NOT covered by the sheet is dimmed), or
+       *               `"off"` (display:none + opacity:0 — no remount needed).
+       * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+       * @example
+       *   engine.setScrimMode("above-sheet"); // dim only the area above the sheet
+       *   engine.setScrimMode("off");          // disable scrim layer
+       */
+      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();
+      }
+      /**
+       * Enable or disable click-on-scrim → snap to first non-zero allowed snap.
+       * Auto-promotes `pointer-events: auto` when scrim is non-interactive so the
+       * click listener actually fires.
+       * @param enabled - `true` installs the click listener; `false` removes it.
+       * @example
+       *   engine.setScrimTapToClose(true);  // tap outside sheet collapses it
+       *   engine.setScrimTapToClose(false); // require explicit close button
+       */
+      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;
+            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;
+        }
+      }
+      /**
+       * Toggle the scrim layer without remounting. Disabling stashes current
+       * `screenRange`/`backdropRange` and degenerates them to `[1, 1]` (opacity
+       * formula → 0 across the whole range); re-enabling restores the saved values.
+       * @param enabled - `false` hides scrim, `true` restores prior ranges.
+       * @param applySize - Engine-supplied recompute hook; runs one applyOpacity pass.
+       * @example
+       *   engine.setScrimEnabled(false); // hide scrim, ranges remembered
+       *   engine.setScrimEnabled(true);  // restore prior ranges (no remount)
+       */
+      setScrimEnabled(enabled, applySize) {
+        if (this.isDestroyed()) return;
+        if (enabled === this.scrimEnabled) return;
+        this.scrimEnabled = enabled;
+        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();
+      }
+      /**
+       * Batch-update multiple scrim fields with a single applySize() at the end.
+       * If `preset` is set, it seeds color/blur/interactive/range first; explicit
+       * fields override.
+       * @param opts - Partial scrim config: preset, mode, enabled, tapToClose,
+       *               color, blur, interactive, range.
+       * @param applySize - Engine-supplied recompute hook; runs ONCE per call.
+       * @example
+       *   engine.setScrim({
+       *     preset: "frosted",
+       *     mode: "above-sheet",
+       *     tapToClose: true,
+       *   });
+       */
+      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
+          });
+          this.screenRange = 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) {
+          this.screenRange = opts.range;
+        }
+        this.invalidateOpacityCache();
+        applySize();
+      }
+      /**
+       * Inject a positioned floating element into the scrim layer (e.g. a close
+       * button anchored top-right). Replaces any prior overlay so repeated calls
+       * (reactive effects re-running) don't accumulate wrappers.
+       * @param opts - Children element, optional `inset` (default `"16px"`),
+       *               `position` (9-way grid, default `"top-right"`), and
+       *               `interactive` flag (default `true`).
+       * @returns Teardown function that removes the wrapper from the DOM.
+       * @example
+       *   const teardown = engine.setScrimOverlay({
+       *     children: closeBtn,
+       *     position: "top-right",
+       *     inset: "20px",
+       *   });
+       *   // later: teardown(); // remove the floating button
+       */
+      setScrimOverlay(opts) {
+        if (this.isDestroyed()) return () => {
+        };
+        if (!this.screenComponent) return () => {
+        };
+        this.scrimOverlayTeardown?.();
+        const screen = this.screenComponent;
+        const inset = opts.inset ?? "16px";
+        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";
+        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;
+        }
+        if (interactive) {
+          ws.pointerEvents = "auto";
+        }
+        wrapper.appendChild(opts.children);
+        screen.appendChild(wrapper);
+        const teardown = () => {
+          if (wrapper.parentNode) wrapper.parentNode.removeChild(wrapper);
+          if (this.scrimOverlayTeardown === teardown) {
+            this.scrimOverlayTeardown = null;
+          }
+        };
+        this.scrimOverlayTeardown = teardown;
+        return teardown;
+      }
+      /** Tear down toggle-state listeners + remove any injected overlay wrapper. */
+      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 = "";
+      }
+      // ── Private helpers ────────────────────────────────────────────────
+      /** Centralized scrim style writer — atomic 3-property write across all setters. */
+      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) {
+          s.pointerEvents = opts.interactive ? "auto" : "none";
+        }
+      }
+      /** Pin the screen overlay to the area NOT occupied by the sheet. */
+      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 = "none";
+      }
+    };
+  }
+});
+
+// src/core/animation/animation.ts
+var easeOutBack, easeOutCubic, easeLinear, easeOutQuint, tween;
+var init_animation = __esm({
+  "src/core/animation/animation.ts"() {
+    easeOutBack = (t) => {
+      const c1 = 1.40158;
+      const c3 = c1 + 1;
+      return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+    };
+    easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+    easeLinear = (t) => t;
+    easeOutQuint = (t) => 1 - Math.pow(1 - t, 5);
+    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
+      };
+    };
+  }
+});
+
+// src/core/animation/spring.ts
+var DEFAULT_SPRING, MAX_DT, runSpring;
+var init_spring = __esm({
+  "src/core/animation/spring.ts"() {
+    DEFAULT_SPRING = {
+      stiffness: 220,
+      damping: 26,
+      mass: 1,
+      restDelta: 0.5,
+      restSpeed: 0.5
+    };
+    MAX_DT = 1 / 30;
+    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 subDt = Math.min(dt, 1 / 240);
+          let stepsLeft = Math.max(1, Math.ceil(dt / subDt));
+          while (stepsLeft-- > 0) {
+            const force = -cfg.stiffness * (x - to) - cfg.damping * v;
+            const accel = force / cfg.mass;
+            v += accel * subDt;
+            x += v * subDt;
+          }
+          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
+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" };
+  }
+}
+var DEFAULT_DURATION;
+var init_animation_presets = __esm({
+  "src/core/animation/animation-presets.ts"() {
+    init_animation();
+    DEFAULT_DURATION = 220;
+  }
+});
+
+// src/core/controllers/animation-runner.ts
+var DEFAULT_DURATION2, VELOCITY_PX_PER_S, AnimationRunner;
+var init_animation_runner = __esm({
+  "src/core/controllers/animation-runner.ts"() {
+    init_animation();
+    init_spring();
+    init_animation_presets();
+    DEFAULT_DURATION2 = 220;
+    VELOCITY_PX_PER_S = 1e3;
+    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");
+        /** Live-tracked via mq listener so animateTo skips matchMedia per snap. */
+        __publicField(this, "reducedMotion", false);
+        /** Disposes the matchMedia change listener — drained from destroy(). */
+        __publicField(this, "detachReducedMotion", null);
+        /** Computed once — both inputs (option + API presence) stable for life. */
+        __publicField(this, "viewTransitionsAvailable");
+        /** In-flight handles. Public for tests / debugging only — engine drives via cancel(). */
+        __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);
+          }
+        }
+      }
+      /**
+       * Live derived flag — `true` whenever a spring/tween handle is in flight.
+       * Reading the canonical handles (instead of mirroring into a separate
+       * boolean) eliminates the reduced-motion early-return latent bug where
+       * the flag stayed true forever, and removes the cross-controller
+       * setIsAnimating callback.
+       */
+      get isAnimating() {
+        return this.currentTween !== null || this.currentSpring !== null;
+      }
+      /** Cancel any in-flight tween/spring without touching engine state. */
+      cancel() {
+        this.currentTween?.cancel();
+        this.currentSpring?.cancel();
+      }
+      /**
+       * Animate from current size to `target`. Resolves when the animation
+       * completes; resolves early if cancelled mid-flight (caller checks an
+       * abort signal post-await for cycle-invariant correctness).
+       */
+      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";
+        }
+      }
+      /** Tear down the matchMedia listener. Engine calls from destroy(). */
+      destroy() {
+        this.detachReducedMotion?.();
+        this.detachReducedMotion = null;
+        this.currentTween = null;
+        this.currentSpring = null;
+      }
+    };
+  }
+});
+
+// src/core/lifecycle/focusTrap.ts
+var FOCUSABLE, isVisible, focusables, installFocusTrap;
+var init_focusTrap = __esm({
+  "src/core/lifecycle/focusTrap.ts"() {
+    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(",");
+    isVisible = (el) => {
+      if (typeof el.checkVisibility === "function") {
+        return el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true });
+      }
+      return el.offsetParent !== null;
+    };
+    focusables = (root) => Array.from(root.querySelectorAll(FOCUSABLE)).filter(
+      (el) => !el.hasAttribute("inert") && isVisible(el) && !el.matches("[aria-hidden='true']")
+    );
+    installFocusTrap = (container, options = {}) => {
+      if (typeof document === "undefined") return () => {
+      };
+      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 (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) => {
+        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;
+        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, savedStyles, lockBodyScroll;
+var init_scrollLock = __esm({
+  "src/core/lifecycle/scrollLock.ts"() {
+    lockCount = 0;
+    savedStyles = null;
+    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;
+      const root = rootProvider();
+      const parent = root.parentElement ?? document.body;
+      for (const child of Array.from(parent.children)) {
+        if (child === root) continue;
+        if (child.hasAttribute("inert")) continue;
+        child.setAttribute("inert", "");
+        tracked.push(child);
+      }
+    },
+    remove() {
+      for (const el of tracked) el.removeAttribute("inert");
+      tracked.length = 0;
+    }
+  };
+}
+var init_inert_siblings = __esm({
+  "src/core/features/inert-siblings.ts"() {
+  }
+});
+
+// src/core/controllers/lifecycle-controller.ts
+var LifecycleController;
+var init_lifecycle_controller = __esm({
+  "src/core/controllers/lifecycle-controller.ts"() {
+    init_focusTrap();
+    init_scrollLock();
+    init_inert_siblings();
+    LifecycleController = class {
+      constructor(deps, opts) {
+        __publicField(this, "element");
+        __publicField(this, "closeFn");
+        __publicField(this, "focusTrapEnabled");
+        __publicField(this, "initialFocus");
+        __publicField(this, "closeOnEscape");
+        __publicField(this, "bodyScrollLockEnabled");
+        __publicField(this, "inertSiblingsEnabled");
+        __publicField(this, "inertSiblings");
+        __publicField(this, "shouldApplyInertSiblings");
+        __publicField(this, "returnFocus");
+        /** Toggle-state teardowns — fire on close, NOT in destroy-only stack. */
+        __publicField(this, "releaseFocusTrap", null);
+        __publicField(this, "releaseScrollLock", null);
+        /** True between install() and release(). Guards release()/destroy() from
+         *  re-running side effects (notably `returnFocus.focus()`) on already-
+         *  released or never-installed instances. */
+        __publicField(this, "installed", false);
+        __publicField(this, "destroyed", false);
+        this.element = deps.element;
+        this.closeFn = deps.close;
+        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);
+      }
+      /**
+       * Run the open-time install steps. Idempotent: each step checks its
+       * existing teardown ref so a re-open during a half-cancelled close
+       * doesn't double-install. Sets `installed=true` BEFORE the first side
+       * effect so a partial throw (detached / shadow-DOM target) leaves the
+       * caller's `release()` rollback path armed to undo whatever did succeed.
+       * No-op when destroyed.
+       */
+      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,
+            onEscape: this.closeOnEscape ? () => void this.closeFn() : void 0
+          });
+        }
+        if (this.inertSiblingsEnabled && this.shouldApplyInertSiblings()) {
+          this.inertSiblings.apply();
+        }
+      }
+      /**
+       * Update the post-release focus target. Overlay re-binds this when the
+       * consumer changes `returnFocus` after construction; the new value applies
+       * on the next `release()`. No-op when destroyed.
+       */
+      setReturnFocus(target) {
+        if (this.destroyed) return;
+        this.returnFocus = target;
+      }
+      /**
+       * Release all install-time teardowns. Short-circuits when not installed,
+       * so `close() → destroy()` (each routing through here) only restores
+       * focus once. The `installed` guard lets `inertSiblings.remove()` and
+       * the focus-trap/scroll-lock teardown nullings stay simple — they were
+       * already idempotent, but `returnFocus.focus()` was firing on every call.
+       */
+      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?.();
+        }
+      }
+      /**
+       * Final teardown — releases any still-installed listeners and seals the
+       * controller. After destroy(), install() is a no-op and setReturnFocus()
+       * is rejected, so post-destroy mutations can't queue up a stale focus
+       * restore.
+       */
+      destroy() {
+        this.release();
+        this.destroyed = true;
+      }
+    };
+  }
+});
+
+// src/core/gestures.ts
+var isAxisVertical, SampleRing, installGestures;
+var init_gestures = __esm({
+  "src/core/gestures.ts"() {
+    isAxisVertical = (mode) => mode === "bottom" || mode === "top";
+    SampleRing = class {
+      // current count, ≤ capacity
+      constructor(capacity) {
+        __publicField(this, "slots");
+        __publicField(this, "capacity");
+        __publicField(this, "head", 0);
+        // next write index
+        __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++;
+      }
+      /**
+       * Drop oldest entries whose timestamp is below `cutoff`, but never shrink
+       * below `minKeep`. Mirrors the original
+       *   `while (samples.length > minKeep && samples[0].t < cutoff) samples.shift()`
+       * but without copying — just advances the logical tail.
+       */
+      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;
+      }
+    };
+    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);
+  return Math.sign(overshoot) * Math.pow(Math.abs(overshoot), RUBBER_BAND_FACTOR) * Math.min(6, cap / Math.max(Math.abs(overshoot), 1));
+}
+var RUBBER_BAND_FACTOR;
+var init_rubber_band = __esm({
+  "src/core/primitives/rubber-band.ts"() {
+    RUBBER_BAND_FACTOR = 0.55;
+  }
+});
+
+// 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;
+  }
+}
+var init_soft_keyboard = __esm({
+  "src/core/features/soft-keyboard.ts"() {
+  }
+});
+
+// src/core/controllers/gesture-controller.ts
+var GestureController;
+var init_gesture_controller = __esm({
+  "src/core/controllers/gesture-controller.ts"() {
+    init_gestures();
+    init_rubber_band();
+    init_soft_keyboard();
+    GestureController = class {
+      constructor(deps) {
+        __publicField(this, "deps");
+        __publicField(this, "detach", null);
+        __publicField(this, "isDragging_", false);
+        __publicField(this, "dragStartSize", 0);
+        // Only "touch" gestures are eligible for soft-keyboard dismissal —
+        // mouse/trackpad users don't have a keyboard to dismiss.
+        __publicField(this, "currentPointerKind", "touch");
+        // One blur per drag — flipping focus every move event races the keyboard's
+        // own animations on iOS and makes the page jitter.
+        __publicField(this, "keyboardDismissed", false);
+        // Reused payload object for the "drag" event — mutated each onMove instead
+        // of allocating a fresh `{size, delta}` per frame. At 60-120Hz a long drag
+        // would otherwise churn tens of KB through the GC. Mirrors browser
+        // PointerEvent semantics: consumers must NOT retain the reference across
+        // frames (clone if needed). See SheetEventMap.drag JSDoc.
+        __publicField(this, "dragPayload", { size: 0, delta: 0 });
+        this.deps = deps;
+      }
+      /** True between `dragstart` and `dragend`/`onCancel`. */
+      get isDragging() {
+        return this.isDragging_;
+      }
+      /**
+       * Bind pointer listeners on the handle and return a teardown. Engine pushes
+       * the teardown into its TeardownStack so destroy() drains it once.
+       */
+      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");
+            const restoreTo = this.dragStartSize;
+            void this.deps.animateTo(restoreTo, 0);
+          }
+        });
+        return this.detach;
+      }
+      /**
+       * Force-clear drag visual state. Engine calls from destroy() when destroyed
+       * mid-drag — gesture detach won't synthesize an onCancel, so we have to
+       * roll back the data-attribute + will-change ourselves.
+       */
+      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;
+var init_aria_slider_writer = __esm({
+  "src/core/primitives/aria-slider-writer.ts"() {
+    AriaSliderWriter = class {
+      constructor(handle, mode) {
+        __publicField(this, "handle", handle);
+        handle.setAttribute(
+          "aria-orientation",
+          mode === "bottom" || mode === "top" ? "vertical" : "horizontal"
+        );
+      }
+      /**
+       * Update slider position. `allowedIds` length determines `aria-valuemax`;
+       * `activeId` indexes into it for `aria-valuenow` + `aria-valuetext`.
+       * Empty list → strip every dynamic attr so AT skips the handle entirely.
+       */
+      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();
+    }
+  };
+}
+var init_scroll_cache = __esm({
+  "src/core/features/scroll-cache.ts"() {
+  }
+});
+
+// src/core/primitives/engine-options.ts
+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,
+      // Auto-promote pointer-events when tap-to-close is on so the click
+      // listener actually receives events. Caller can still force `false`
+      // explicitly to opt out — `??` only kicks in for `undefined`.
+      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,
+      // Folded in from `extras` so the lifecycle bag is fully assembled at
+      // the call site — engine no longer needs a spread+override at
+      // controller construction. When `extras` is omitted, the field stays
+      // undefined and the controller uses its own default predicate.
+      shouldApplyInertSiblings: extras?.shouldApplyInertSiblings
+    }
+  };
+}
+var DEFAULT_FLICK_VELOCITY, DEFAULT_DRAG_THRESHOLD;
+var init_engine_options = __esm({
+  "src/core/primitives/engine-options.ts"() {
+    init_persist();
+    DEFAULT_FLICK_VELOCITY = 0.65;
+    DEFAULT_DRAG_THRESHOLD = 18;
+  }
+});
+
+// src/core/BottomSheetEngine.ts
+var HAPTIC_DURATION_MS, TeardownStack, BottomSheetEngine;
+var init_BottomSheetEngine = __esm({
+  "src/core/BottomSheetEngine.ts"() {
+    init_sheetStack();
+    init_transform();
+    init_instance_id();
+    init_event_bus();
+    init_snap_points();
+    init_snap_resolver();
+    init_persist();
+    init_auto_collapse();
+    init_linked_sheets();
+    init_route();
+    init_content_swipe();
+    init_visual_viewport();
+    init_resize_observer();
+    init_slider_keyboard();
+    init_scrim_controller();
+    init_animation_runner();
+    init_lifecycle_controller();
+    init_gesture_controller();
+    init_aria_slider_writer();
+    init_hot_path_thresholds();
+    init_scroll_cache();
+    init_engine_options();
+    init_opacity_dedup();
+    HAPTIC_DURATION_MS = 8;
+    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;
+            });
+          }
+        }
+      }
+    };
+    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, "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");
+        // Engine retains `snapPointsRaw` for the "find a closed-id" query in
+        // close() (raw input, not resolved geometry). Resolver owns geometry.
+        __publicField(this, "snapPointsRaw");
+        __publicField(this, "snaps");
+        __publicField(this, "activeId");
+        __publicField(this, "size", 0);
+        // Constructed in attach(); a plugin's install() could read `state` before
+        // attach completes if the constructor throws partway through. State getter
+        // null-guards via `this.gesture?.isDragging ?? false`.
+        __publicField(this, "gesture");
+        __publicField(this, "rootEl", null);
+        __publicField(this, "destroyed", false);
+        // In-flight ViewTransition handle. A second snapTo while a VT is in flight
+        // would otherwise let Chromium reject the second's promise and flicker —
+        // newCycle() calls skipTransition() to abort cleanly.
+        __publicField(this, "currentViewTransition", null);
+        // Each cycle captures the signal at entry; when a newer cycle aborts the
+        // controller, the captured signal flips to `aborted=true` and post-await
+        // guards short-circuit (prevents stale snap/open/close emits).
+        __publicField(this, "currentAbort", new AbortController());
+        // Sub-pixel `--bs-size` deltas and <1% `--bs-progress` deltas are not
+        // visually distinguishable; gating CSSOM writes drops 30-50% of writes
+        // during the spring's settle tail.
+        __publicField(this, "sizeWriteSentinel", new WriteSentinel());
+        __publicField(this, "progressWriteSentinel", new WriteSentinel());
+        __publicField(this, "isTopSheet", true);
+        // Pooled payload — identity documented in SheetEventMap.progress JSDoc;
+        // consumers must not retain across frames.
+        __publicField(this, "progressPayload", {
+          value: 0,
+          size: 0
+        });
+        // Pooled buffer for `getDragContext()` — onMove calls this 60-120×/s.
+        // Inner `range` object identity is also stable (mutated in place).
+        __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");
+        // Single LIFO stack for ALL destroy-only teardowns. Plugins (added last)
+        // tear down first before the infrastructure they depend on. Toggle-semantic
+        // listeners (focus-trap / scroll-lock / scrim tap-to-close) stay as named
+        // fields on their controllers.
+        __publicField(this, "teardowns", new TeardownStack());
+        // Pre-computed transform template — built once per engine since `mode` is
+        // fixed for its lifetime. Avoids the 4-arm switch at 60-120 Hz.
+        __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.screenComponent;
+        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);
+            }
+          },
+          resolved.scrim
+        );
+        this.animation = new AnimationRunner(
+          {
+            element: this.element,
+            getRootEl: () => this.rootEl,
+            applySize: (size) => this.applySize(size),
+            getSize: () => this.size,
+            // Optional chain protects synthetic test paths that drive animateTo
+            // before attach() (gesture is constructed there).
+            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.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,
+          () => 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);
+      }
+      /**
+       * Register a plugin. `install` runs synchronously; if it returns a function,
+       * it's captured for teardown during `destroy()`. No-op if already destroyed
+       * — installing into a torn-down engine would leak listeners.
+       *
+       * Throws from `plugin.install` are caught and rethrown via `queueMicrotask`
+       * so a buggy plugin can't take the engine down with it: the engine stays
+       * usable, sibling plugins still install, and the error surfaces in dev tools
+       * on the next tick instead of being swallowed. Mirrors the per-fn isolation
+       * model used for teardowns.
+       *
+       * Plugins that accept the second `scope` argument get transactional cleanup:
+       * push partial-install cleanups via `scope.add(fn)` and the engine drains
+       * them on throw, OR merges them into destroy-time teardowns on success.
+       */
+      use(plugin) {
+        if (this.destroyed) {
+          console.warn(
+            `[BottomSheet] use("${plugin.name}") called on destroyed engine \u2014 ignored.`
+          );
+          return this;
+        }
+        const scoped = [];
+        const scope = {
+          // typeof check — not just truthiness — so a JS-only plugin pushing a
+          // bogus value is silently rejected instead of queueing a confusing
+          // TypeError on destroy() drain.
+          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;
+      }
+      /**
+       * Replace the linked-sheets list at runtime. Use when peer engines aren't
+       * available at construction time (mounted later in the tree). The wiring
+       * to the `open` event is independent of this list — it reads `linkedSheets`
+       * lazily on emit, so this setter is a simple field swap.
+       */
+      setLinkedSheets(sheets) {
+        if (this.destroyed) return;
+        this.linkedSheets = sheets;
+      }
+      /** Read-only view of the current allow-list, for cross-sheet target negotiation. */
+      getAllowedIds() {
+        return this.snaps.getAllowedIds().slice();
+      }
+      /**
+       * Animate to a snap point by id. Resolves when the animation completes.
+       *
+       * Two call shapes:
+       * ```ts
+       * engine.snapTo("full");                           // default velocity
+       * engine.snapTo("full", 0.5);                      // px/ms initial velocity
+       * engine.snapTo("full", { velocity: 0.5, signal }); // abortable
+       * ```
+       *
+       * When `opts.signal` is provided, calling `controller.abort()` cancels the
+       * in-flight tween/spring and the returned promise resolves without firing
+       * `snap`. The captured `AbortSignal` is checked after each await so external
+       * aborts ride the same cycle invariant as internal ones (resize, destroy,
+       * concurrent snapTo).
+       */
+      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();
+        }
+      }
+      /**
+       * Drive the sheet to an arbitrary px size, bypassing snap matching.
+       * Useful for preview scrubs, animation chaining, or programmatic gestures.
+       * Animates with the configured spring/tween. Resolves when the animation
+       * completes. Does NOT update `activeId` — call `snapTo(id)` after to commit.
+       *
+       * Unlike `snapTo`, this does not fire `before-snap` (it isn't a snap commit)
+       * nor `snap` (the sheet isn't settling to a known snap). `progress` events
+       * still fire via applySize. Target is clamped to `[0, maxAxisSize]`.
+       */
+      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;
+        const willSnap = snap !== void 0 && ids.includes(snap) || !ids.includes(this.activeId) && ids.length > 0;
+        if (!willSnap) {
+          this.animation.cancel();
+          this.newCycle();
+        }
+        this.snaps.setAllowedIds(ids);
+        this.updateAriaSlider();
+        if (snap && ids.includes(snap)) {
+          void this.snapTo(
+            snap,
+            0,
+            /* internal */
+            true
+          );
+        } else if (!ids.includes(this.activeId)) {
+          const fallback = ids[0];
+          if (fallback) void this.snapTo(
+            fallback,
+            0,
+            /* internal */
+            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);
+      }
+      /**
+       * Batch-update multiple scrim fields in one call. Apply order is:
+       *   1. `preset` — fills baseline color/blur/range/interactive.
+       *   2. `mode` — re-positions the scrim (fixed inset / clear / hide).
+       *   3. `enabled` — flips the opacity contribution on/off.
+       *   4. `tapToClose` — installs/tears the click listener.
+       *   5. `color` / `blur` / `interactive` / `range` — explicit overrides.
+       *   6. ONE `applySize` so the per-frame opacity stays consistent.
+       *
+       * Performance: collecting changes here (vs calling individual setters)
+       * avoids repeated `applySize` calls during a multi-field swap. Setters
+       * called here suppress their own internal `applySize` either by passing
+       * through fast-paths (mode/enabled no-op when value unchanged) or by
+       * being visual-only (color/blur/interactive don't influence opacity).
+       */
+      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);
+      }
+      /**
+       * Read-only snapshot of scrim state. Use the `setScrim*` setters to mutate.
+       * Stable public API — internals (e.g. cached opacity sentinels) are NOT
+       * exposed so consumers can't accidentally couple to ScrimController shape.
+       */
+      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);
+      }
+      /**
+       * Abort the current cycle's signal and replace the controller. Returns the
+       * fresh signal so the caller can capture it locally before any await — when
+       * a future newCycle() / destroy aborts our controller, the captured signal
+       * flips to aborted and post-await guards short-circuit.
+       */
+      newCycle() {
+        this.currentAbort.abort();
+        this.currentAbort = new AbortController();
+        return this.currentAbort.signal;
+      }
+      /**
+       * Fire `before-snap` and report whether a listener cancelled it. The
+       * `cancel()` callback exposed to listeners is frozen after the synchronous
+       * emit phase so async callers can't silently miss — they get a console
+       * warning. Returns `true` when cancelled so callers can early-return /
+       * spring-back without re-implementing the cancel/frozen pattern.
+       */
+      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();
+      }
+      /**
+       * Memoised `allowedRange()` — delegates to SnapResolver which owns the cache.
+       * Engine wrapper kept so existing call sites don't all need updating;
+       * resolver-level memoization survives across method invocations.
+       */
+      getAllowedRange() {
+        return this.snaps.getAllowedRange();
+      }
+      /**
+       * Write ARIA slider value attributes onto the handle so the engine itself
+       * is the source of truth for screen-reader announcements. Called from the
+       * constructor and from every code path that mutates `activeId` /
+       * `allowedIds`. WAI-ARIA 1.2 requires `aria-valuenow` for `role="slider"` —
+       * without it screen readers can't announce drag/snap progress to keyboard
+       * + AT users (WCAG 4.1.2 Name, Role, Value).
+       *
+       * Engine does NOT set `role="slider"` itself — that's the adapter's or
+       * consumer markup's responsibility. We only decorate with dynamic values.
+       *
+       * Empty allowed-list is malformed input (settable via `setAllowed([])`);
+       * short-circuit to remove ARIA value attributes so screen readers see a
+       * no-value slider rather than a degenerate `min=max=now=0` (WAI-ARIA 1.2
+       * requires `valuemax > valuemin` for `role="slider"`).
+       */
+      updateAriaSlider() {
+        this.aria.setValue(this.snaps.getAllowedIds(), this.activeId);
+      }
+      registerInStack() {
+        this.teardowns.add(sheetStack.push({
+          id: this.id,
+          setZIndex: (z) => {
+            this.element.style.zIndex = String(z);
+            if (this.backdrop) this.backdrop.style.zIndex = String(z - 1);
+          },
+          setIsTop: (isTop) => {
+            this.isTopSheet = isTop;
+            if (this.backdrop) {
+              this.backdrop.style.display = isTop ? "" : "none";
+            }
+          }
+        }));
+      }
+      attach() {
+        this.gesture = new GestureController({
+          handle: this.handle,
+          element: this.element,
+          mode: this.mode,
+          getRoot: () => this.rootEl,
+          // Single coalesced reader — narrows the DI surface and removes 3 getter
+          // dispatches per onMove frame at 60-120Hz. Returns a SHARED buffer
+          // (this.dragContextBuf) — see field JSDoc for the retention contract.
+          // Inner `range` object is mutated in place too so callers caching its
+          // identity between frames stay valid.
+          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.snaps.getAllowedIds(),
+            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();
+            }
+          }));
+          if (this.lifecycle.closeOnEscape) {
+            const onKey = (e) => {
+              if (this.destroyed) 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.snaps.getAllowedIds(),
+          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 (this.emitBeforeSnap(target, previousId)) {
+          const restore = this.snaps.findById(previousId);
+          if (restore) {
+            void this.animation.animateTo(restore.size, 0);
+          }
+          return;
+        }
+        const previousSize = this.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 (previousId === "closed" && target.size > 0) {
+            this.emit("open", { id: target.id });
+            this.handleOpen();
+          }
+          if (target.size === 0) {
+            this.emit("close", void 0);
+            this.handleClose();
+          }
+        });
+      }
+      /** Trigger a brief haptic tick (iOS Safari + Android Chrome support). */
+      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`);
+        }
+        const progress = this.computeProgress(size);
+        const progressChanged = this.progressWriteSentinel.shouldWrite(
+          progress,
+          OPACITY_WRITE_EPSILON
+        );
+        if (progressChanged) {
+          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() {
+        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;
+          });
+        }
+      }
+      handleClose() {
+        this.lifecycle.release();
+      }
+    };
+  }
+});
+
+// src/web-component/baseStyles.ts
+var baseStyles;
+var init_baseStyles = __esm({
+  "src/web-component/baseStyles.ts"() {
+    baseStyles = `:where(.bs-root){--bs-surface:#ffffff;--bs-surface-border:rgba(225,227,237,1);--bs-shadow:0 -3px 12px rgba(0,0,0,0.12);--bs-radius:20px;--bs-handle-color:#b5b3a8;--bs-handle-width:40px;--bs-handle-height:5px;--bs-z-backdrop:90;--bs-z-sheet:100;--bs-header-min-height:80px;--bs-backdrop-color:rgba(0,0,0,0.5);--bs-scrim-color:rgba(0,0,0,0.4);--bs-scrim-blur:0px;--bs-z-scrim:calc(var(--bs-z-sheet) - 1);--bs-size:0px;--bs-progress:0}.bs-backdrop{position:fixed;inset:0;background:var(--bs-backdrop-color);opacity:0;pointer-events:none;z-index:var(--bs-z-backdrop);transition:opacity 0.15s linear;will-change:opacity}.bs-root[data-dragging="true"] .bs-backdrop,.bs-root[data-animating="true"] .bs-backdrop{transition:none}.bs-sheet{position:fixed;background:var(--bs-surface);box-shadow:var(--bs-shadow);z-index:var(--bs-z-sheet);overflow:hidden;display:flex;flex-direction:column;-webkit-tap-highlight-color:transparent;user-select:none;overscroll-behavior:contain}.bs-sheet[data-mode="bottom"]{left:0;right:0;bottom:0;width:100%;border-top-left-radius:var(--bs-radius);border-top-right-radius:var(--bs-radius);border-top:1px solid var(--bs-surface-border);padding-bottom:env(safe-area-inset-bottom);box-shadow:0 calc(var(--bs-progress,0) * -2px - 3px) calc(var(--bs-progress,0) * 18px + 12px) rgba(0,0,0,calc(var(--bs-progress,0) * 0.15 + 0.12))}.bs-sheet[data-mode="top"]{left:0;right:0;top:0;width:100%;border-bottom-left-radius:var(--bs-radius);border-bottom-right-radius:var(--bs-radius);border-bottom:1px solid var(--bs-surface-border);flex-direction:column-reverse;box-shadow:0 3px 12px rgba(0,0,0,0.12);padding-top:env(safe-area-inset-top)}.bs-sheet[data-mode="left"]{top:0;bottom:0;left:0;height:100%;border-top-right-radius:var(--bs-radius);border-bottom-right-radius:var(--bs-radius);border-right:1px solid var(--bs-surface-border);box-shadow:3px 0 12px rgba(0,0,0,0.12)}.bs-sheet[data-mode="right"]{top:0;bottom:0;right:0;height:100%;border-top-left-radius:var(--bs-radius);border-bottom-left-radius:var(--bs-radius);border-left:1px solid var(--bs-surface-border);box-shadow:-3px 0 12px rgba(0,0,0,0.12)}.bs-sheet[data-mode="left"] .bs-content{padding-right:36px}.bs-sheet[data-mode="right"] .bs-content{padding-left:36px}.bs-handle{flex-shrink:0;min-height:44px;display:flex;flex-direction:column;justify-content:center;padding:8px 16px 4px;cursor:grab;touch-action:none;user-select:none;background:var(--bs-surface);-webkit-tap-highlight-color:transparent;outline:none;position:relative}.bs-handle:active{cursor:grabbing}.bs-handle:focus-visible{outline:2px solid currentColor;outline-offset:-2px;border-radius:var(--bs-radius)}.bs-handle::before{content:"";display:block;width:var(--bs-handle-width);height:var(--bs-handle-height);background:var(--bs-handle-color);border-radius:calc(var(--bs-handle-height) / 2);margin:0 auto 8px;transition:width 0.15s ease,background 0.15s ease,transform 0.15s ease;pointer-events:none}.bs-sheet[data-mode="left"] .bs-handle,.bs-sheet[data-mode="right"] .bs-handle{position:absolute;top:0;bottom:0;width:28px;min-width:0;min-height:0;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:0;background:var(--bs-surface);z-index:1;overflow:hidden}.bs-sheet[data-mode="left"] .bs-handle>*,.bs-sheet[data-mode="right"] .bs-handle>*{display:none}.bs-sheet[data-mode="left"] .bs-handle{right:0;border-left:1px solid var(--bs-surface-border)}.bs-sheet[data-mode="right"] .bs-handle{left:0;border-right:1px solid var(--bs-surface-border)}.bs-sheet[data-mode="left"] .bs-handle::before,.bs-sheet[data-mode="right"] .bs-handle::before{width:var(--bs-handle-height);height:var(--bs-handle-width);margin:0}.bs-sheet:hover .bs-handle::before{background:color-mix(in oklab,var(--bs-handle-color),#000 15%)}.bs-handle:active::before{background:color-mix(in oklab,var(--bs-handle-color),#000 35%);transform:scaleX(1.15)}.bs-handle.bs-handle--ticks::after{content:"";display:block;position:absolute;left:50%;bottom:6px;transform:translateX(-50%);width:calc(var(--bs-handle-width) * 2);height:3px;background-image:radial-gradient( circle,var(--bs-handle-color) 0 1.5px,transparent 1.6px );background-size:8px 3px;background-repeat:repeat-x;background-position:center;opacity:0;transition:opacity 0.18s ease-out;pointer-events:none}.bs-root[data-dragging="true"] .bs-handle.bs-handle--ticks::after{opacity:0.4}.bs-sheet[data-mode="top"] .bs-handle.bs-handle--ticks::after{bottom:auto;top:6px}.bs-sheet[data-mode="left"] .bs-handle.bs-handle--ticks::after,.bs-sheet[data-mode="right"] .bs-handle.bs-handle--ticks::after{left:50%;top:50%;bottom:auto;transform:translate(-50%,-50%);width:3px;height:calc(var(--bs-handle-width) * 2);background-size:3px 8px;background-repeat:repeat-y;margin-left:calc(var(--bs-handle-height) + 6px)}.bs-sheet[data-mode="right"] .bs-handle.bs-handle--ticks::after{margin-left:calc(-1 * (var(--bs-handle-height) + 6px))}.bs-content{flex:1;min-height:0;overflow-y:auto;-webkit-overflow-scrolling:touch;overscroll-behavior:contain;padding:0 16px 16px}.bs-screen{position:absolute;inset:0;pointer-events:none;display:none;z-index:var(--bs-z-scrim)}.bs-scrim{background:var(--bs-scrim-color);transition:opacity 0.15s linear;will-change:opacity}.bs-root[data-dragging="true"] .bs-scrim,.bs-root[data-animating="true"] .bs-scrim{transition:none}.bs-scrim{backdrop-filter:blur(var(--bs-scrim-blur));-webkit-backdrop-filter:blur(var(--bs-scrim-blur))}.bs-button-slot{position:absolute;z-index:calc(var(--bs-z-sheet) + 1);pointer-events:auto}.bs-button-slot[data-side="left"]{left:16px;bottom:calc(var(--bs-size,0px) + 12px);transition:bottom 0.15s ease}.bs-button-slot[data-side="right"]{right:16px;bottom:calc(var(--bs-size,0px) + 12px);transition:bottom 0.15s ease}@media (prefers-reduced-motion:reduce){.bs-backdrop,.bs-handle::before,.bs-button-slot[data-side="left"],.bs-button-slot[data-side="right"]{transition:none !important}}@media (prefers-color-scheme:dark){:where(.bs-root){--bs-surface:#1a1a1d;--bs-surface-border:rgba(255,255,255,0.08);--bs-handle-color:rgba(255,255,255,0.45);--bs-shadow:0 -3px 16px rgba(0,0,0,0.5)}}.bs-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}:where(.ovl-root){--ovl-surface:var(--bs-surface,#ffffff);--ovl-surface-border:var(--bs-surface-border,rgba(0,0,0,0.08));--ovl-shadow:0 -8px 40px rgba(0,0,0,0.35);--ovl-radius:var(--bs-radius,20px);--ovl-backdrop-color:rgba(0,0,0,0.5);--ovl-z-backdrop:200;--ovl-z-panel:201}.ovl-backdrop{position:fixed;inset:0;background:var(--ovl-backdrop-color);opacity:0;pointer-events:none;z-index:var(--ovl-z-backdrop)}.ovl-panel{position:fixed;background:var(--ovl-surface);box-shadow:var(--ovl-shadow);z-index:var(--ovl-z-panel);-webkit-tap-highlight-color:transparent;outline:none;transition:transform 0.32s cubic-bezier(0.29,1.24,0.84,0.99),opacity 0.32s ease-out}.ovl-panel[data-state="open"]{transform:translate3d(0,0,0);opacity:1}@starting-style{.ovl-panel[data-edge="bottom"][data-state="open"]{transform:translate3d(0,100%,0);opacity:0}.ovl-panel[data-edge="top"][data-state="open"]{transform:translate3d(0,-100%,0);opacity:0}.ovl-panel[data-edge="left"][data-state="open"]{transform:translate3d(-100%,0,0);opacity:0}.ovl-panel[data-edge="right"][data-state="open"]{transform:translate3d(100%,0,0);opacity:0}}.ovl-panel[data-edge="bottom"]{left:0;right:0;bottom:0;width:100%;border-top-left-radius:var(--ovl-radius);border-top-right-radius:var(--ovl-radius);border-top:1px solid var(--ovl-surface-border);padding-bottom:env(safe-area-inset-bottom)}.ovl-panel[data-edge="top"]{left:0;right:0;top:0;width:100%;border-bottom-left-radius:var(--ovl-radius);border-bottom-right-radius:var(--ovl-radius);border-bottom:1px solid var(--ovl-surface-border);padding-top:env(safe-area-inset-top)}.ovl-panel[data-edge="left"]{top:0;bottom:0;left:0;height:100%;border-top-right-radius:var(--ovl-radius);border-bottom-right-radius:var(--ovl-radius);border-right:1px solid var(--ovl-surface-border)}.ovl-panel[data-edge="right"]{top:0;bottom:0;right:0;height:100%;border-top-left-radius:var(--ovl-radius);border-bottom-left-radius:var(--ovl-radius);border-left:1px solid var(--ovl-surface-border)}@media (prefers-reduced-motion:reduce){.ovl-panel,.ovl-backdrop{transition:none !important}}`;
+  }
+});
+
+// src/web-component/BottomSheetElement.ts
+var BottomSheetElement_exports = {};
+__export(BottomSheetElement_exports, {
+  BottomSheetElement: () => exports.BottomSheetElement,
+  defineBottomSheet: () => exports.defineBottomSheet
+});
+var ATTR_SNAP_POINTS, ATTR_ALLOWED, ATTR_INITIAL, ATTR_MODE, ATTR_BACKDROP, ATTR_STYLESHEET, ATTR_ANIMATION, ATTR_FOCUS_TRAP, ATTR_CLOSE_ON_ESCAPE, ATTR_LOCK_BODY_SCROLL, isValidSnapPoint, DEFAULT_SNAP_POINTS, parseSnapPoints, VALID_MODES, VALID_ANIMATIONS, parseMode, parseAnimation, parseList, buildSlot, buildShadowTree; exports.BottomSheetElement = void 0; var registered; exports.defineBottomSheet = void 0;
+var init_BottomSheetElement = __esm({
+  "src/web-component/BottomSheetElement.ts"() {
+    init_BottomSheetEngine();
+    init_baseStyles();
+    ATTR_SNAP_POINTS = "snap-points";
+    ATTR_ALLOWED = "allowed";
+    ATTR_INITIAL = "initial";
+    ATTR_MODE = "mode";
+    ATTR_BACKDROP = "backdrop";
+    ATTR_STYLESHEET = "stylesheet";
+    ATTR_ANIMATION = "animation";
+    ATTR_FOCUS_TRAP = "focus-trap";
+    ATTR_CLOSE_ON_ESCAPE = "close-on-escape";
+    ATTR_LOCK_BODY_SCROLL = "lock-body-scroll";
+    isValidSnapPoint = (p) => !!p && typeof p === "object" && typeof p.id === "string" && (typeof p.size === "number" || typeof p.size === "string");
+    DEFAULT_SNAP_POINTS = [{ id: "full", size: "full" }];
+    parseSnapPoints = (raw) => {
+      if (!raw) return DEFAULT_SNAP_POINTS;
+      try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed) && parsed.length > 0 && parsed.every(isValidSnapPoint)) {
+          return parsed;
+        }
+        if (Array.isArray(parsed)) return DEFAULT_SNAP_POINTS;
+      } catch {
+      }
+      return raw.split(",").map((s) => s.trim()).filter(Boolean).map((part) => {
+        const [id, size] = part.split(":").map((s) => s.trim());
+        const numeric = Number(size);
+        const resolvedSize = Number.isFinite(numeric) ? numeric : size;
+        return { id: id ?? "default", size: resolvedSize };
+      });
+    };
+    VALID_MODES = [
+      "bottom",
+      "top",
+      "left",
+      "right"
+    ];
+    VALID_ANIMATIONS = ["spring", "tween", "ios-spring", "material-bounce", "linear", "snappy"];
+    parseMode = (raw) => raw && VALID_MODES.includes(raw) ? raw : "bottom";
+    parseAnimation = (raw) => raw && VALID_ANIMATIONS.includes(raw) ? raw : void 0;
+    parseList = (raw) => raw ? raw.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+    buildSlot = (name) => {
+      const slot = document.createElement("slot");
+      slot.name = name;
+      return slot;
+    };
+    buildShadowTree = () => {
+      const root = document.createElement("div");
+      root.className = "bs-root";
+      const backdrop = document.createElement("div");
+      backdrop.className = "bs-backdrop";
+      backdrop.setAttribute("part", "backdrop");
+      const screen = document.createElement("div");
+      screen.className = "bs-screen";
+      screen.setAttribute("part", "screen");
+      screen.appendChild(buildSlot("screen"));
+      const sheet = document.createElement("section");
+      sheet.className = "bs-sheet";
+      sheet.setAttribute("part", "sheet");
+      sheet.setAttribute("role", "dialog");
+      sheet.setAttribute("aria-modal", "false");
+      const leftButton = document.createElement("div");
+      leftButton.className = "bs-button-slot";
+      leftButton.setAttribute("data-side", "left");
+      leftButton.setAttribute("part", "left-button");
+      leftButton.appendChild(buildSlot("leftButton"));
+      const rightButton = document.createElement("div");
+      rightButton.className = "bs-button-slot";
+      rightButton.setAttribute("data-side", "right");
+      rightButton.setAttribute("part", "right-button");
+      rightButton.appendChild(buildSlot("rightButton"));
+      const handle = document.createElement("div");
+      handle.className = "bs-handle";
+      handle.setAttribute("part", "handle");
+      handle.setAttribute("role", "slider");
+      handle.setAttribute("tabindex", "0");
+      handle.setAttribute("aria-label", "Resize sheet");
+      handle.appendChild(buildSlot("header"));
+      const content = document.createElement("div");
+      content.className = "bs-content";
+      content.setAttribute("part", "content");
+      content.setAttribute("tabindex", "0");
+      content.setAttribute("role", "region");
+      content.setAttribute("aria-label", "Sheet content");
+      const defaultSlot = document.createElement("slot");
+      content.appendChild(defaultSlot);
+      const announcer = document.createElement("span");
+      announcer.className = "bs-sr-announce";
+      announcer.setAttribute("role", "status");
+      announcer.setAttribute("aria-live", "polite");
+      announcer.setAttribute("aria-atomic", "true");
+      announcer.style.cssText = "position:absolute;left:-10000px;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);";
+      sheet.append(leftButton, rightButton, handle, content);
+      root.append(backdrop, screen, sheet, announcer);
+      const fragment = document.createDocumentFragment();
+      fragment.appendChild(root);
+      return {
+        fragment,
+        refs: {
+          sheet,
+          handle,
+          content,
+          backdrop,
+          screen,
+          leftButton,
+          rightButton,
+          announcer
+        }
+      };
+    };
+    exports.BottomSheetElement = class extends HTMLElement {
+      constructor() {
+        super();
+        __publicField(this, "engine", null);
+        __publicField(this, "root");
+        __publicField(this, "offHandlers", []);
+        __publicField(this, "refs");
+        __publicField(this, "backdropClickHandler", null);
+        this.root = this.attachShadow({ mode: "open" });
+        const baseStyle = document.createElement("style");
+        baseStyle.textContent = baseStyles;
+        this.root.appendChild(baseStyle);
+        const stylesheet = this.getAttribute(ATTR_STYLESHEET);
+        if (stylesheet) {
+          const link = document.createElement("link");
+          link.rel = "stylesheet";
+          link.href = stylesheet;
+          this.root.appendChild(link);
+        }
+        const inlineStyle = document.createElement("style");
+        inlineStyle.textContent = [
+          ":host { display: contents; }",
+          ".bs-handle:focus-visible {",
+          "  outline: 2px solid currentColor;",
+          "  outline-offset: -2px;",
+          "  border-radius: var(--bs-radius, 20px);",
+          "}",
+          "@media (forced-colors: active) {",
+          "  .bs-handle:focus-visible { outline: 2px solid CanvasText; }",
+          "}"
+        ].join("\n");
+        this.root.appendChild(inlineStyle);
+        const { fragment, refs } = buildShadowTree();
+        this.refs = refs;
+        this.root.appendChild(fragment);
+      }
+      static get observedAttributes() {
+        return [
+          ATTR_SNAP_POINTS,
+          ATTR_ALLOWED,
+          ATTR_INITIAL,
+          ATTR_MODE,
+          ATTR_BACKDROP,
+          ATTR_ANIMATION,
+          ATTR_FOCUS_TRAP,
+          ATTR_CLOSE_ON_ESCAPE,
+          ATTR_LOCK_BODY_SCROLL
+        ];
+      }
+      connectedCallback() {
+        this.initEngine();
+      }
+      disconnectedCallback() {
+        this.teardownEngine();
+      }
+      attributeChangedCallback() {
+        if (!this.engine) return;
+        this.teardownEngine();
+        this.initEngine();
+      }
+      teardownEngine() {
+        this.offHandlers.forEach((off) => off());
+        this.offHandlers = [];
+        if (this.backdropClickHandler) {
+          this.refs.backdrop.removeEventListener("click", this.backdropClickHandler);
+          this.backdropClickHandler = null;
+        }
+        this.engine?.destroy();
+        this.engine = null;
+      }
+      initEngine() {
+        const { sheet, handle, content, backdrop, announcer } = this.refs;
+        const mode = parseMode(this.getAttribute(ATTR_MODE));
+        sheet.setAttribute("data-mode", mode);
+        const focusTrap = this.getAttribute(ATTR_FOCUS_TRAP) === "true";
+        if (focusTrap) {
+          sheet.setAttribute("aria-modal", "true");
+        } else {
+          sheet.removeAttribute("aria-modal");
+        }
+        const showBackdrop = this.getAttribute(ATTR_BACKDROP) !== "false";
+        backdrop.style.display = showBackdrop ? "" : "none";
+        if (showBackdrop) {
+          this.backdropClickHandler = () => void this.engine?.close();
+          backdrop.addEventListener("click", this.backdropClickHandler);
+        }
+        const opts = {
+          element: sheet,
+          handle,
+          scrollContainer: content,
+          backdrop: showBackdrop ? backdrop : void 0,
+          screenComponent: this.refs.screen,
+          mode,
+          snapPoints: parseSnapPoints(this.getAttribute(ATTR_SNAP_POINTS)),
+          allowed: parseList(this.getAttribute(ATTR_ALLOWED)),
+          initial: this.getAttribute(ATTR_INITIAL) ?? void 0,
+          animation: parseAnimation(this.getAttribute(ATTR_ANIMATION)),
+          focusTrap,
+          closeOnEscape: this.getAttribute(ATTR_CLOSE_ON_ESCAPE) !== "false",
+          lockBodyScroll: this.getAttribute(ATTR_LOCK_BODY_SCROLL) !== "false"
+        };
+        this.engine = new BottomSheetEngine(opts);
+        this.offHandlers = [
+          this.engine.on("snap", (payload) => {
+            announcer.textContent = payload.id;
+            this.dispatchEvent(new CustomEvent("snap", { detail: payload }));
+          }),
+          this.engine.on(
+            "open",
+            (payload) => this.dispatchEvent(new CustomEvent("open", { detail: payload }))
+          ),
+          this.engine.on(
+            "close",
+            () => this.dispatchEvent(new CustomEvent("close"))
+          ),
+          this.engine.on(
+            "progress",
+            (payload) => this.dispatchEvent(new CustomEvent("progress", { detail: payload }))
+          )
+        ];
+      }
+      snapTo(id) {
+        return this.engine?.snapTo(id) ?? Promise.resolve();
+      }
+      open(id) {
+        return this.engine?.open(id) ?? Promise.resolve();
+      }
+      close() {
+        return this.engine?.close() ?? Promise.resolve();
+      }
+      setAllowed(ids, snap) {
+        this.engine?.setAllowed(ids, snap);
+      }
+      get sheetState() {
+        return this.engine?.state ?? null;
+      }
+    };
+    registered = false;
+    exports.defineBottomSheet = (tag = "bottom-sheet") => {
+      if (registered || customElements.get(tag)) return;
+      customElements.define(tag, exports.BottomSheetElement);
+      registered = true;
+    };
+  }
+});
+
+// src/web-component/index.ts
+init_BottomSheetElement();
+if (typeof window !== "undefined" && typeof customElements !== "undefined") {
+  Promise.resolve().then(() => (init_BottomSheetElement(), BottomSheetElement_exports)).then(({ defineBottomSheet: defineBottomSheet2 }) => {
+    defineBottomSheet2();
+  });
+}
+//# sourceMappingURL=element.cjs.map
+//# sourceMappingURL=element.cjs.map