@capgo/capacitor-sheets 8.0.2

package/dist/solid/index.js

@@ -0,0 +1,1890 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solid/index.ts
+var index_exports = {};
+__export(index_exports, {
+  setupSheet: () => setupSheet
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/utils.ts
+var focusableSelector = [
+  "a[href]",
+  "area[href]",
+  "button:not([disabled])",
+  'input:not([disabled]):not([type="hidden"])',
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "iframe",
+  "object",
+  "embed",
+  "[contenteditable]",
+  '[tabindex]:not([tabindex="-1"])',
+  "cap-sheet-handle",
+  "cap-sheet-trigger"
+].join(",");
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function parseBoolean(value, defaultValue) {
+  if (value === null) return defaultValue;
+  if (value === "" || value === "true") return true;
+  if (value === "false") return false;
+  return defaultValue;
+}
+function parseList(value) {
+  return value ? value.split(/[,\s]+/).map((item) => item.trim()).filter(Boolean) : [];
+}
+function parseTracks(value, fallback) {
+  const tracks = parseList(value).filter(
+    (item) => ["top", "bottom", "left", "right"].includes(item)
+  );
+  return tracks.length > 0 ? tracks : [fallback];
+}
+function parsePlacement(value) {
+  return ["top", "bottom", "left", "right", "center"].includes(value || "") ? value : "bottom";
+}
+function trackForPlacement(placement, tracks) {
+  if (placement !== "center" && tracks.includes(placement)) return placement;
+  return tracks[0] || (placement === "center" ? "bottom" : placement);
+}
+function isVerticalTrack(track) {
+  return track === "top" || track === "bottom";
+}
+function trackSign(track) {
+  return track === "bottom" || track === "right" ? 1 : -1;
+}
+function getEmPx(element) {
+  if (!element?.ownerDocument.defaultView) return 16;
+  const fontSize = element.ownerDocument.defaultView.getComputedStyle(element).fontSize;
+  const parsed = Number.parseFloat(fontSize);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 16;
+}
+function toEm(element, value) {
+  return value / getEmPx(element);
+}
+function measureCssLength(length, context, axis) {
+  const doc = context.ownerDocument;
+  const probe = doc.createElement("div");
+  probe.style.position = "absolute";
+  probe.style.visibility = "hidden";
+  probe.style.pointerEvents = "none";
+  probe.style.inset = "0";
+  if (axis === "x") {
+    probe.style.width = length;
+    probe.style.height = "0";
+  } else {
+    probe.style.height = length;
+    probe.style.width = "0";
+  }
+  context.appendChild(probe);
+  const rect = probe.getBoundingClientRect();
+  probe.remove();
+  return axis === "x" ? rect.width : rect.height;
+}
+function getFocusable(container) {
+  return Array.from(container.querySelectorAll(focusableSelector)).filter((element) => {
+    if (element.hasAttribute("disabled")) return false;
+    if (element.getAttribute("aria-hidden") === "true") return false;
+    const rects = element.getClientRects();
+    return rects.length > 0;
+  });
+}
+function dispatch(target, type, detail) {
+  target.dispatchEvent(new CustomEvent(type, { bubbles: true, composed: true, detail }));
+}
+function defineElement(name, constructor) {
+  if (typeof customElements === "undefined") return;
+  if (!customElements.get(name)) {
+    customElements.define(name, constructor);
+  }
+}
+function shouldSkipMotion(settingsSkip) {
+  if (settingsSkip === true) return true;
+  if (settingsSkip === "auto" && typeof matchMedia !== "undefined") {
+    return matchMedia("(prefers-reduced-motion: reduce)").matches;
+  }
+  return false;
+}
+function createId(prefix) {
+  return `${prefix}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/core/styles.ts
+var STYLE_ID = "capgo-capacitor-sheets-styles";
+var CSS = `
+:root {
+  --cap-sheet-100-lvh-dvh-pct: max(100%, 100vh);
+  --cap-sheet-backdrop-color: rgb(0 0 0);
+  --cap-sheet-backdrop-opacity: 0.44;
+  --cap-sheet-radius: 1.5em;
+  --cap-sheet-handle-color: rgb(115 115 115);
+  --cap-sheet-surface: Canvas;
+  --cap-sheet-shadow: 0 0.5em 2.5em rgb(0 0 0 / 0.18);
+  --cap-sheet-z-index: 1000;
+  --cap-sheet-safe-area-top: max(env(safe-area-inset-top, 0em), var(--safe-area-inset-top, 0em));
+  --cap-sheet-safe-area-bottom: max(env(safe-area-inset-bottom, 0em), var(--safe-area-inset-bottom, 0em));
+  --cap-sheet-safe-area-left: max(env(safe-area-inset-left, 0em), var(--safe-area-inset-left, 0em));
+  --cap-sheet-safe-area-right: max(env(safe-area-inset-right, 0em), var(--safe-area-inset-right, 0em));
+  --cap-sheet-applied-safe-area-top: var(--cap-sheet-safe-area-top);
+  --cap-sheet-applied-safe-area-bottom: var(--cap-sheet-safe-area-bottom);
+  --cap-sheet-applied-safe-area-left: var(--cap-sheet-safe-area-left);
+  --cap-sheet-applied-safe-area-right: var(--cap-sheet-safe-area-right);
+}
+
+@supports (height: 1dvh) {
+  :root {
+    --cap-sheet-100-lvh-dvh-pct: max(100dvh, 100lvh);
+  }
+}
+
+cap-sheet,
+cap-sheet-portal,
+cap-sheet-special-wrapper,
+cap-sheet-special-wrapper-content,
+cap-sheet-stack {
+  display: contents;
+}
+
+cap-sheet-view {
+  position: fixed;
+  inset: 0;
+  display: grid;
+  width: 100%;
+  height: var(--cap-sheet-100-lvh-dvh-pct);
+  z-index: var(--cap-sheet-z-index);
+  pointer-events: none;
+  touch-action: none;
+  overscroll-behavior: none;
+  contain: layout style;
+  box-sizing: border-box;
+  padding-block-start: var(--cap-sheet-applied-safe-area-top, 0em);
+  padding-block-end: calc(var(--cap-sheet-applied-safe-area-bottom, 0em) + var(--cap-sheet-keyboard-offset, 0em));
+  padding-inline-start: var(--cap-sheet-applied-safe-area-left, 0em);
+  padding-inline-end: var(--cap-sheet-applied-safe-area-right, 0em);
+}
+
+cap-sheet-view[hidden] {
+  display: none !important;
+}
+
+cap-sheet-view[content-placement="top"] {
+  align-items: start;
+  justify-items: center;
+}
+
+cap-sheet-view[content-placement="bottom"],
+cap-sheet-view:not([content-placement]) {
+  align-items: end;
+  justify-items: center;
+}
+
+cap-sheet-view[content-placement="left"] {
+  align-items: center;
+  justify-items: start;
+}
+
+cap-sheet-view[content-placement="right"] {
+  align-items: center;
+  justify-items: end;
+}
+
+cap-sheet-view[content-placement="center"] {
+  align-items: center;
+  justify-items: center;
+}
+
+cap-sheet-backdrop {
+  position: absolute;
+  inset: 0;
+  display: block;
+  background: var(--cap-sheet-backdrop-color);
+  opacity: 0;
+  pointer-events: none;
+  touch-action: none;
+  will-change: opacity;
+}
+
+cap-sheet-content {
+  box-sizing: border-box;
+  position: relative;
+  display: block;
+  width: min(100%, 34em);
+  max-height: 100%;
+  color: CanvasText;
+  background: var(--cap-sheet-surface);
+  border-radius: var(--cap-sheet-radius) var(--cap-sheet-radius) 0 0;
+  box-shadow: var(--cap-sheet-shadow);
+  overflow: auto;
+  overscroll-behavior: contain;
+  pointer-events: auto;
+  touch-action: pan-x pan-y;
+  will-change: transform, opacity;
+  -webkit-overflow-scrolling: touch;
+}
+
+cap-sheet-view[content-placement="top"] cap-sheet-content {
+  border-radius: 0 0 var(--cap-sheet-radius) var(--cap-sheet-radius);
+}
+
+cap-sheet-view[content-placement="left"] cap-sheet-content {
+  width: min(88%, 28em);
+  height: 100%;
+  max-height: 100%;
+  border-radius: 0 var(--cap-sheet-radius) var(--cap-sheet-radius) 0;
+}
+
+cap-sheet-view[content-placement="right"] cap-sheet-content {
+  width: min(88%, 28em);
+  height: 100%;
+  max-height: 100%;
+  border-radius: var(--cap-sheet-radius) 0 0 var(--cap-sheet-radius);
+}
+
+cap-sheet-view[content-placement="center"] cap-sheet-content {
+  width: min(90%, 30em);
+  max-height: min(90%, 42em);
+  border-radius: var(--cap-sheet-radius);
+}
+
+cap-sheet-bleeding-background {
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  display: block;
+  background: var(--cap-sheet-surface);
+  border-radius: inherit;
+  pointer-events: none;
+}
+
+cap-sheet-view[content-placement="bottom"] cap-sheet-bleeding-background,
+cap-sheet-view:not([content-placement]) cap-sheet-bleeding-background {
+  inset-block-end: -8em;
+}
+
+cap-sheet-view[content-placement="top"] cap-sheet-bleeding-background {
+  inset-block-start: -8em;
+}
+
+cap-sheet-view[content-placement="left"] cap-sheet-bleeding-background {
+  inset-inline-start: -8em;
+}
+
+cap-sheet-view[content-placement="right"] cap-sheet-bleeding-background {
+  inset-inline-end: -8em;
+}
+
+cap-sheet-handle {
+  box-sizing: border-box;
+  display: grid;
+  place-items: center;
+  width: 100%;
+  height: 2.25em;
+  cursor: grab;
+  touch-action: none;
+}
+
+cap-sheet-handle::before {
+  content: "";
+  display: block;
+  width: 2.75em;
+  height: 0.3125em;
+  border-radius: 999em;
+  background: var(--cap-sheet-handle-color);
+  opacity: 0.65;
+}
+
+cap-sheet-handle:active {
+  cursor: grabbing;
+}
+
+cap-sheet-title,
+cap-sheet-description {
+  display: block;
+}
+
+cap-sheet-outlet {
+  display: block;
+  transform-origin: center;
+  will-change: transform, opacity, filter;
+}
+
+cap-scroll {
+  display: block;
+  overflow: auto;
+  overscroll-behavior: contain;
+  -webkit-overflow-scrolling: touch;
+  scroll-behavior: smooth;
+}
+
+cap-scroll[axis="x"] {
+  overflow-x: auto;
+  overflow-y: hidden;
+}
+
+cap-scroll[axis="y"],
+cap-scroll:not([axis]) {
+  overflow-x: hidden;
+  overflow-y: auto;
+}
+
+cap-scroll-content {
+  display: block;
+  min-width: 100%;
+  min-height: 100%;
+}
+
+cap-fixed {
+  position: fixed;
+  inset-inline: 0;
+  z-index: calc(var(--cap-sheet-z-index) + 1);
+}
+
+cap-island,
+cap-external-overlay {
+  display: contents;
+}
+
+cap-visually-hidden,
+cap-auto-focus-target[hidden-target] {
+  position: absolute;
+  width: 0.0625em;
+  height: 0.0625em;
+  margin: -0.0625em;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  white-space: nowrap;
+  border: 0;
+  padding: 0;
+}
+`;
+function injectCapSheetStyles(root = document) {
+  if (root.getElementById(STYLE_ID)) return;
+  const style = root.createElement("style");
+  style.id = STYLE_ID;
+  style.textContent = CSS;
+  root.head.appendChild(style);
+}
+
+// src/components/cap-scroll.ts
+var CapScroll = class extends HTMLElement {
+  scrollTarget = this;
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.scrollTarget = this;
+    this.addEventListener("scroll", this.handleScroll, { passive: true });
+  }
+  disconnectedCallback() {
+    this.removeEventListener("scroll", this.handleScroll);
+  }
+  /** Return scroll progress from `0` to `1`. */
+  getProgress() {
+    return this.getAvailableDistance() === 0 ? 0 : clamp(this.getDistance() / this.getAvailableDistance(), 0, 1);
+  }
+  /** Return traveled distance in CSS pixels. */
+  getDistance() {
+    return this.axis === "x" ? this.scrollTarget.scrollLeft : this.scrollTarget.scrollTop;
+  }
+  /** Return available travel distance in CSS pixels. */
+  getAvailableDistance() {
+    return this.axis === "x" ? Math.max(0, this.scrollTarget.scrollWidth - this.scrollTarget.clientWidth) : Math.max(0, this.scrollTarget.scrollHeight - this.scrollTarget.clientHeight);
+  }
+  scrollTo(optionsOrX, y) {
+    if (typeof optionsOrX === "number") {
+      super.scrollTo(optionsOrX, y ?? 0);
+      return;
+    }
+    if (!optionsOrX || "top" in optionsOrX || "left" in optionsOrX) {
+      super.scrollTo(optionsOrX);
+      return;
+    }
+    const travelOptions = optionsOrX;
+    const distance = this.resolveDistance(travelOptions.progress, travelOptions.distance);
+    this.scrollTarget.scrollTo({
+      left: this.axis === "x" ? distance : void 0,
+      top: this.axis === "y" ? distance : void 0,
+      behavior: travelOptions.behavior
+    });
+  }
+  scrollBy(optionsOrX, y) {
+    if (typeof optionsOrX === "number") {
+      super.scrollBy(optionsOrX, y ?? 0);
+      return;
+    }
+    if (!optionsOrX || "top" in optionsOrX || "left" in optionsOrX) {
+      super.scrollBy(optionsOrX);
+      return;
+    }
+    const travelOptions = optionsOrX;
+    const distance = this.resolveDistance(travelOptions.progress, travelOptions.distance);
+    this.scrollTarget.scrollBy({
+      left: this.axis === "x" ? distance : void 0,
+      top: this.axis === "y" ? distance : void 0,
+      behavior: travelOptions.behavior
+    });
+  }
+  get axis() {
+    return this.getAttribute("axis") === "x" ? "x" : "y";
+  }
+  resolveDistance(progress, distance) {
+    if (distance !== void 0) return distance;
+    return clamp(progress ?? 0, 0, 1) * this.getAvailableDistance();
+  }
+  handleScroll = () => {
+    dispatch(this, "cap-scroll", {
+      progress: this.getProgress(),
+      distance: this.getDistance(),
+      availableDistance: this.getAvailableDistance()
+    });
+  };
+};
+var CapScrollContent = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+  }
+};
+
+// src/core/theme-color.ts
+var baseThemeColor = null;
+var activeDimmerCount = 0;
+function getThemeMeta(documentRef) {
+  return documentRef.querySelector('meta[name="theme-color"]');
+}
+function parseHexColor(color) {
+  const normalized = color.trim().replace("#", "");
+  if (![3, 6].includes(normalized.length)) return null;
+  const expanded = normalized.length === 3 ? normalized.split("").map((char) => `${char}${char}`).join("") : normalized;
+  const value = Number.parseInt(expanded, 16);
+  if (!Number.isFinite(value)) return null;
+  return [value >> 16 & 255, value >> 8 & 255, value & 255];
+}
+function parseRgbColor(color) {
+  const match = color.match(/rgba?\(([^)]+)\)/i);
+  if (!match) return null;
+  const values = match[1].split(/[\s,/]+/).map((item) => Number.parseFloat(item)).filter((item) => Number.isFinite(item));
+  if (values.length < 3) return null;
+  return [values[0], values[1], values[2]];
+}
+function toHex(channel) {
+  return Math.round(channel).toString(16).padStart(2, "0");
+}
+function blend(base, overlay, alpha) {
+  const baseRgb = parseHexColor(base) || parseRgbColor(base);
+  const overlayRgb = parseHexColor(overlay) || parseRgbColor(overlay);
+  if (!baseRgb || !overlayRgb) return null;
+  const [r, g, b] = baseRgb.map((channel, index) => channel * (1 - alpha) + overlayRgb[index] * alpha);
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function setThemeColorDimming(documentRef, alpha, overlayColor = "rgb(0 0 0)") {
+  const meta = getThemeMeta(documentRef);
+  if (!meta) return;
+  if (baseThemeColor === null) {
+    baseThemeColor = meta.content;
+  }
+  const next = blend(baseThemeColor, overlayColor, alpha);
+  if (next) {
+    meta.content = next;
+  }
+}
+function retainThemeColorDimmer() {
+  activeDimmerCount += 1;
+}
+function releaseThemeColorDimmer(documentRef) {
+  activeDimmerCount = Math.max(0, activeDimmerCount - 1);
+  if (activeDimmerCount === 0 && baseThemeColor !== null) {
+    const meta = getThemeMeta(documentRef);
+    if (meta) {
+      meta.content = baseThemeColor;
+    }
+    baseThemeColor = null;
+  }
+}
+
+// src/core/sheet-controller.ts
+var defaultOptions = {
+  contentPlacement: "bottom",
+  sheetRole: "dialog",
+  safeArea: "auto",
+  swipe: true,
+  swipeDismissal: true,
+  swipeOvershoot: true,
+  swipeTrap: true,
+  inertOutside: true,
+  nativeEdgeSwipePrevention: true,
+  nativeFocusScrollPrevention: true,
+  closeOnOutsideClick: true,
+  closeOnEscape: true,
+  focusTrap: true,
+  restoreFocus: true,
+  themeColorDimming: "auto"
+};
+var defaultAnimation = {
+  duration: 420,
+  easing: "cubic-bezier(0.22, 1, 0.36, 1)",
+  skip: "auto",
+  contentMove: true
+};
+var stackRegistry = /* @__PURE__ */ new Map();
+function parseNumber(value) {
+  if (value === null) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeDetents(value) {
+  if (Array.isArray(value)) return value.filter(Boolean);
+  return parseList(value || null);
+}
+var safeAreaEdges = ["top", "bottom", "left", "right"];
+function parseSafeArea(value) {
+  if (value === null) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized || normalized === "true" || normalized === "auto" || normalized === "all") return "auto";
+  if (normalized === "false" || normalized === "none" || normalized === "off") return "none";
+  const edges = parseList(normalized).filter(
+    (edge) => safeAreaEdges.includes(edge)
+  );
+  return edges.length > 0 ? edges : "auto";
+}
+function resolveSafeAreaEdges(value) {
+  if (value === false || value === "none") return [];
+  if (Array.isArray(value)) return value.filter((edge) => safeAreaEdges.includes(edge));
+  return safeAreaEdges;
+}
+function readOptionsFromElement(root) {
+  const placement = parsePlacement(root.getAttribute("content-placement"));
+  const defaultActiveDetent = parseNumber(root.getAttribute("default-active-detent"));
+  const activeDetent = parseNumber(root.getAttribute("active-detent"));
+  return {
+    componentId: root.getAttribute("component-id") || root.id || void 0,
+    stack: root.getAttribute("stack") || void 0,
+    defaultPresented: parseBoolean(root.getAttribute("default-presented"), false),
+    presented: root.hasAttribute("presented") ? parseBoolean(root.getAttribute("presented"), true) : void 0,
+    defaultActiveDetent,
+    activeDetent,
+    detents: normalizeDetents(root.getAttribute("detents") || void 0),
+    sheetRole: root.getAttribute("sheet-role") || defaultOptions.sheetRole,
+    contentPlacement: placement,
+    safeArea: parseSafeArea(root.getAttribute("safe-area")),
+    tracks: parseTracks(root.getAttribute("tracks"), placement === "center" ? "bottom" : placement),
+    swipe: parseBoolean(root.getAttribute("swipe"), defaultOptions.swipe),
+    swipeDismissal: parseBoolean(root.getAttribute("swipe-dismissal"), defaultOptions.swipeDismissal),
+    swipeOvershoot: parseBoolean(root.getAttribute("swipe-overshoot"), defaultOptions.swipeOvershoot),
+    swipeTrap: parseBoolean(root.getAttribute("swipe-trap"), defaultOptions.swipeTrap),
+    inertOutside: parseBoolean(root.getAttribute("inert-outside"), defaultOptions.inertOutside),
+    nativeEdgeSwipePrevention: parseBoolean(
+      root.getAttribute("native-edge-swipe-prevention"),
+      defaultOptions.nativeEdgeSwipePrevention
+    ),
+    nativeFocusScrollPrevention: parseBoolean(
+      root.getAttribute("native-focus-scroll-prevention"),
+      defaultOptions.nativeFocusScrollPrevention
+    ),
+    closeOnOutsideClick: parseBoolean(root.getAttribute("close-on-outside-click"), defaultOptions.closeOnOutsideClick),
+    closeOnEscape: parseBoolean(root.getAttribute("close-on-escape"), defaultOptions.closeOnEscape),
+    focusTrap: parseBoolean(root.getAttribute("focus-trap"), defaultOptions.focusTrap),
+    restoreFocus: parseBoolean(root.getAttribute("restore-focus"), defaultOptions.restoreFocus),
+    themeColorDimming: root.getAttribute("theme-color-dimming") === "false" ? false : root.getAttribute("theme-color-dimming") === "auto" ? "auto" : defaultOptions.themeColorDimming
+  };
+}
+function resolveAnimation(settings) {
+  const preset = settings?.preset || "smooth";
+  const presetDefaults = {
+    gentle: { duration: 520, easing: "cubic-bezier(0.16, 1, 0.3, 1)" },
+    smooth: { duration: defaultAnimation.duration, easing: defaultAnimation.easing },
+    snappy: { duration: 260, easing: "cubic-bezier(0.2, 0, 0, 1)" }
+  };
+  return {
+    ...defaultAnimation,
+    ...presetDefaults[preset],
+    duration: settings?.duration ?? presetDefaults[preset]?.duration ?? defaultAnimation.duration,
+    easing: settings?.easing ?? presetDefaults[preset]?.easing ?? defaultAnimation.easing,
+    skip: settings?.skip ?? defaultAnimation.skip,
+    contentMove: settings?.contentMove ?? defaultAnimation.contentMove
+  };
+}
+function attributeBoolean(value) {
+  return value ? "true" : "false";
+}
+var SheetController = class {
+  root;
+  id;
+  parts = {
+    outlets: /* @__PURE__ */ new Set(),
+    islands: /* @__PURE__ */ new Set(),
+    externalOverlays: /* @__PURE__ */ new Set()
+  };
+  options;
+  presented = false;
+  activeDetent = 0;
+  status = "idle";
+  detentOffsetsPx = [0, 0];
+  hiddenOffsetPx = 0;
+  currentOffsetPx = 0;
+  activeTrack = "bottom";
+  pointerTravel = null;
+  connected = false;
+  lockedScroll = false;
+  previousBodyOverflow = "";
+  previousBodyTouchAction = "";
+  inertedElements = /* @__PURE__ */ new Map();
+  previousFocus = null;
+  hasThemeDimmer = false;
+  stackId = null;
+  documentListenersAttached = false;
+  viewListenersElement = null;
+  visualViewportListenersAttached = false;
+  handleVisualViewportResize = () => {
+    const view = this.parts.view;
+    const visualViewport = this.root.ownerDocument.defaultView?.visualViewport;
+    if (!view) return;
+    if (!visualViewport || this.options.nativeFocusScrollPrevention === false) {
+      view.style.setProperty("--cap-sheet-keyboard-offset", "0em");
+      return;
+    }
+    const layoutHeight = this.root.ownerDocument.documentElement.clientHeight;
+    const keyboardOffset = Math.max(0, layoutHeight - visualViewport.height - visualViewport.offsetTop);
+    view.style.setProperty("--cap-sheet-keyboard-offset", `${toEm(view, keyboardOffset)}em`);
+  };
+  handleDocumentKeyDown = (event) => {
+    if (!this.presented) return;
+    if (event.key === "Escape" && this.options.closeOnEscape !== false) {
+      event.preventDefault();
+      void this.dismiss({ source: "escape" });
+      return;
+    }
+    if (event.key === "Tab" && this.options.focusTrap !== false) {
+      this.trapFocus(event);
+    }
+  };
+  handleViewClick = (event) => {
+    if (!this.presented || this.options.closeOnOutsideClick === false) return;
+    if (event.target === this.parts.view || event.target === this.parts.backdrop) {
+      void this.dismiss({ source: "outside" });
+    }
+  };
+  handlePointerDown = (event) => {
+    if (!this.presented || this.options.swipe === false || this.options.contentPlacement === "center") return;
+    if (!(event.target instanceof Element)) return;
+    if (!this.parts.content?.contains(event.target) && event.target !== this.parts.backdrop) return;
+    if (this.options.nativeEdgeSwipePrevention !== false && this.isNativeEdgePointer(event)) {
+      event.preventDefault();
+    }
+    this.remeasure();
+    this.pointerTravel = {
+      id: event.pointerId,
+      startOffsetPx: this.currentOffsetPx,
+      startX: event.clientX,
+      startY: event.clientY,
+      lastX: event.clientX,
+      lastY: event.clientY,
+      lastTime: performance.now(),
+      velocity: 0,
+      dragging: false
+    };
+  };
+  handlePointerMove = (event) => {
+    const travel = this.pointerTravel;
+    if (travel?.id !== event.pointerId) return;
+    const axis = isVerticalTrack(this.activeTrack) ? "y" : "x";
+    const current = axis === "y" ? event.clientY : event.clientX;
+    const start = axis === "y" ? travel.startY : travel.startX;
+    const delta = current - start;
+    const crossDelta = axis === "y" ? event.clientX - travel.startX : event.clientY - travel.startY;
+    if (!travel.dragging) {
+      if (Math.abs(delta) < 6 || Math.abs(crossDelta) > Math.abs(delta) * 1.25) return;
+      travel.dragging = true;
+      event.currentTarget?.setPointerCapture?.(event.pointerId);
+      this.setStatus("dragging");
+      dispatch(this.root, "cap-sheet-drag-start", this.getTravelEvent());
+    }
+    if (this.options.swipeTrap !== false) {
+      event.preventDefault();
+    }
+    const now = performance.now();
+    const previous = axis === "y" ? travel.lastY : travel.lastX;
+    const elapsed = Math.max(now - travel.lastTime, 1);
+    travel.velocity = (current - previous) / elapsed * 1e3;
+    travel.lastX = event.clientX;
+    travel.lastY = event.clientY;
+    travel.lastTime = now;
+    const nextOffset = this.limitOffset(travel.startOffsetPx + delta);
+    this.applyOffset(nextOffset, "dragging");
+  };
+  handlePointerUp = (event) => {
+    const travel = this.pointerTravel;
+    if (travel?.id !== event.pointerId) return;
+    const currentTarget = event.currentTarget;
+    if (currentTarget?.hasPointerCapture?.(event.pointerId)) {
+      currentTarget.releasePointerCapture(event.pointerId);
+    }
+    this.pointerTravel = null;
+    if (!travel.dragging) return;
+    const nearest = this.nearestDetentForOffset(this.currentOffsetPx, travel.velocity);
+    dispatch(this.root, "cap-sheet-drag-end", this.getTravelEvent());
+    if (nearest === 0 && this.options.swipeDismissal !== false) {
+      void this.dismiss({ source: "gesture" });
+      return;
+    }
+    void this.stepTo(nearest, { source: "gesture" });
+  };
+  handleWheel = (event) => {
+    if (!this.presented || this.options.swipe === false || this.options.contentPlacement === "center") return;
+    if (!(event.target instanceof Element)) return;
+    if (!this.parts.content?.contains(event.target) && event.target !== this.parts.backdrop) return;
+    const delta = isVerticalTrack(this.activeTrack) ? event.deltaY : event.deltaX;
+    if (Math.abs(delta) < 1) return;
+    const nextOffset = this.limitOffset(this.currentOffsetPx + delta);
+    if (Math.abs(nextOffset - this.currentOffsetPx) < 0.5) return;
+    event.preventDefault();
+    this.applyOffset(nextOffset, "dragging");
+    window.clearTimeout(this.root.__capWheelSettle);
+    this.root.__capWheelSettle = window.setTimeout(() => {
+      const nearest = this.nearestDetentForOffset(this.currentOffsetPx, delta * 10);
+      if (nearest === 0 && this.options.swipeDismissal !== false) {
+        void this.dismiss({ source: "gesture" });
+      } else {
+        void this.stepTo(nearest, { source: "gesture" });
+      }
+    }, 120);
+  };
+  constructor(root) {
+    this.root = root;
+    this.options = readOptionsFromElement(root);
+    this.id = this.options.componentId || root.id || createId("cap-sheet");
+    if (!root.id) root.id = this.id;
+  }
+  /** Connect the controller to the DOM and initialize current state. */
+  connect() {
+    if (this.connected) return;
+    this.connected = true;
+    this.configure(readOptionsFromElement(this.root));
+    const nextPresented = this.options.presented ?? this.options.defaultPresented ?? false;
+    this.activeDetent = this.resolveInitialDetent();
+    this.presented = nextPresented;
+    this.setStatus("idle");
+    this.remeasure();
+    this.applyOffset(
+      nextPresented ? this.detentOffsetsPx[this.activeDetent] || 0 : this.detentOffsetsPx[0] || 0,
+      "idle"
+    );
+    this.updateDomState(false);
+    this.addGlobalListeners();
+    this.registerStack();
+  }
+  /** Disconnect listeners and restore outside DOM state. */
+  disconnect() {
+    this.connected = false;
+    this.removeGlobalListeners();
+    this.unlockPage();
+    this.clearInert();
+    this.releaseThemeDimmer();
+    this.unregisterStack();
+  }
+  /** Update options from attributes or setup helpers. */
+  configure(options) {
+    this.options = {
+      ...defaultOptions,
+      ...this.options,
+      ...options,
+      detents: normalizeDetents(options.detents ?? this.options.detents)
+    };
+    const placement = this.options.contentPlacement || defaultOptions.contentPlacement;
+    const tracks = Array.isArray(this.options.tracks) ? this.options.tracks : this.options.tracks ? [this.options.tracks] : [placement === "center" ? "bottom" : placement];
+    this.activeTrack = trackForPlacement(placement, tracks);
+    this.parts.view?.setAttribute("content-placement", placement);
+    this.parts.view?.setAttribute("role", this.options.sheetRole || "dialog");
+    this.applySafeArea();
+    this.handleVisualViewportResize();
+    if (this.parts.content) {
+      this.parts.content.setAttribute("aria-modal", attributeBoolean(this.options.inertOutside !== false));
+    }
+    this.linkAccessibleNames();
+    this.registerStack();
+  }
+  /** Register a view, backdrop, content, or semantic part. */
+  registerPart(part, element) {
+    this.parts[part] = element;
+    this.configure(this.options);
+    if (this.connected && part === "view") {
+      this.addViewListeners();
+      this.addVisualViewportListeners();
+      this.handleVisualViewportResize();
+    }
+    this.remeasure();
+    this.applyOffset(
+      this.presented ? this.detentOffsetsPx[this.activeDetent] || 0 : this.detentOffsetsPx[0] || this.hiddenOffsetPx,
+      this.status
+    );
+    this.updateDomState(this.presented);
+  }
+  /** Unregister a view, backdrop, content, or semantic part. */
+  unregisterPart(part, element) {
+    if (this.parts[part] === element) {
+      if (part === "view") this.removeViewListeners();
+      this.parts[part] = void 0;
+    }
+  }
+  /** Register an outlet animated by sheet progress. */
+  registerOutlet(element) {
+    this.parts.outlets.add(element);
+    this.updateOutletProgress();
+  }
+  /** Unregister an outlet. */
+  unregisterOutlet(element) {
+    this.parts.outlets.delete(element);
+  }
+  /** Register an outside island that remains interactive with inert outside enabled. */
+  registerIsland(element) {
+    this.parts.islands.add(element);
+    if (this.presented) this.applyInert();
+  }
+  /** Unregister an outside island. */
+  unregisterIsland(element) {
+    this.parts.islands.delete(element);
+    if (this.presented) this.applyInert();
+  }
+  /** Present the sheet. */
+  async present(options = {}) {
+    this.remeasure();
+    if (this.presented) {
+      await this.stepTo(options.detent ?? this.activeDetent, options);
+      return;
+    }
+    this.previousFocus = this.root.ownerDocument.activeElement;
+    this.presented = true;
+    this.activeDetent = clamp(options.detent ?? this.resolveInitialDetent(), 1, this.detentOffsetsPx.length - 1);
+    this.updateDomState(true);
+    this.lockPage();
+    this.applyInert();
+    this.retainThemeDimmer();
+    this.setStatus("entering");
+    dispatch(this.root, "cap-sheet-present", this.getTravelEvent());
+    await this.animateTo(this.detentOffsetsPx[this.activeDetent] || 0, {
+      ...this.options.enteringAnimationSettings || {},
+      ...options.animation || {}
+    });
+    this.setStatus("idle");
+    this.focusInitialElement();
+    this.emitPresentedChange(true, options.source || "programmatic");
+    this.emitActiveDetentChange(this.activeDetent, 0);
+    this.updateStack();
+  }
+  /** Dismiss the sheet. */
+  async dismiss(options = {}) {
+    if (!this.presented) return;
+    this.remeasure();
+    const previous = this.activeDetent;
+    this.presented = false;
+    this.activeDetent = 0;
+    this.setStatus("exiting");
+    dispatch(this.root, "cap-sheet-dismiss", this.getTravelEvent());
+    await this.animateTo(this.detentOffsetsPx[0] || this.hiddenOffsetPx, {
+      ...this.options.exitingAnimationSettings || {},
+      ...options.animation || {}
+    });
+    this.setStatus("idle");
+    this.updateDomState(false);
+    this.unlockPage();
+    this.clearInert();
+    this.releaseThemeDimmer();
+    this.restoreFocus();
+    this.emitPresentedChange(false, options.source || "programmatic");
+    this.emitActiveDetentChange(0, previous);
+    this.updateStack();
+  }
+  /** Toggle presentation state. */
+  async toggle(options = {}) {
+    if (this.presented) {
+      await this.dismiss(options);
+    } else {
+      await this.present(options);
+    }
+  }
+  /** Step to a specific detent index. */
+  async stepTo(detent, options = {}) {
+    this.remeasure();
+    const target = clamp(detent, this.options.swipeDismissal === false ? 1 : 0, this.detentOffsetsPx.length - 1);
+    if (target === 0) {
+      await this.dismiss(options);
+      return;
+    }
+    if (!this.presented) {
+      await this.present({ ...options, detent: target });
+      return;
+    }
+    const previous = this.activeDetent;
+    this.activeDetent = target;
+    this.setStatus("settling");
+    await this.animateTo(this.detentOffsetsPx[target] || 0, {
+      ...this.options.steppingAnimationSettings || {},
+      ...options.animation || {}
+    });
+    this.setStatus("idle");
+    if (previous !== target) {
+      this.emitActiveDetentChange(target, previous);
+    }
+  }
+  /** Step up or down one detent. */
+  async step(direction = "up", options = {}) {
+    const delta = direction === "up" ? 1 : -1;
+    await this.stepTo(this.activeDetent + delta, options);
+  }
+  /** Recalculate content size and detent offsets. */
+  remeasure() {
+    const content = this.parts.content;
+    if (!content) return;
+    const placement = this.options.contentPlacement || "bottom";
+    if (placement === "center") {
+      this.hiddenOffsetPx = 0;
+      this.detentOffsetsPx = [0, 0];
+      return;
+    }
+    const view = this.parts.view;
+    const shouldMeasureHiddenView = Boolean(view?.hidden);
+    const previousVisibility = view?.style.visibility || "";
+    const previousPointerEvents = view?.style.pointerEvents || "";
+    if (view && shouldMeasureHiddenView) {
+      view.hidden = false;
+      view.style.visibility = "hidden";
+      view.style.pointerEvents = "none";
+    }
+    try {
+      const track = this.activeTrack;
+      const sign = trackSign(track);
+      const axis = isVerticalTrack(track) ? "y" : "x";
+      const rect = content.getBoundingClientRect();
+      const size = axis === "y" ? rect.height : rect.width;
+      this.hiddenOffsetPx = Math.max(size, 1) * sign;
+      const detents = normalizeDetents(this.options.detents);
+      const offsets = [this.hiddenOffsetPx];
+      for (const detent of detents) {
+        const visible = measureCssLength(detent, content, axis);
+        const offset = Math.max(Math.abs(this.hiddenOffsetPx) - visible, 0) * sign;
+        offsets.push(offset);
+      }
+      offsets.push(0);
+      this.detentOffsetsPx = offsets;
+      this.activeDetent = clamp(this.activeDetent, this.options.swipeDismissal === false ? 1 : 0, offsets.length - 1);
+      dispatch(this.root, "cap-sheet-travel-range-change", {
+        offsets: offsets.map((offset) => toEm(content, offset)),
+        count: offsets.length
+      });
+    } finally {
+      if (view && shouldMeasureHiddenView) {
+        view.hidden = true;
+        view.style.visibility = previousVisibility;
+        view.style.pointerEvents = previousPointerEvents;
+      }
+    }
+  }
+  /** Read current normalized travel details. */
+  getTravelEvent() {
+    const progress = this.getProgressForOffset(this.currentOffsetPx);
+    return {
+      progress,
+      activeDetent: this.activeDetent,
+      offset: toEm(this.parts.content || this.root, this.currentOffsetPx),
+      status: this.status
+    };
+  }
+  resolveInitialDetent() {
+    const detents = normalizeDetents(this.options.detents);
+    const last = detents.length + 1;
+    const configured = this.options.activeDetent ?? this.options.defaultActiveDetent;
+    if (configured !== void 0) return clamp(configured, 1, last);
+    return detents.length > 0 ? 1 : last;
+  }
+  applyOffset(offsetPx, status) {
+    this.currentOffsetPx = offsetPx;
+    this.setStatus(status);
+    const content = this.parts.content;
+    const backdrop = this.parts.backdrop;
+    const view = this.parts.view;
+    const placement = this.options.contentPlacement || "bottom";
+    const progress = this.getProgressForOffset(offsetPx);
+    if (content) {
+      if (placement === "center") {
+        const scale = 0.96 + progress * 0.04;
+        content.style.transform = `translate3d(0, 0, 0) scale(${scale})`;
+        content.style.opacity = String(progress);
+      } else {
+        const offsetEm = toEm(content, offsetPx);
+        const x = isVerticalTrack(this.activeTrack) ? "0" : `${offsetEm}em`;
+        const y = isVerticalTrack(this.activeTrack) ? `${offsetEm}em` : "0";
+        content.style.transform = `translate3d(${x}, ${y}, 0)`;
+        content.style.opacity = "1";
+      }
+    }
+    if (backdrop) {
+      backdrop.style.opacity = String(
+        progress * Number.parseFloat(getComputedStyle(backdrop).getPropertyValue("--cap-sheet-backdrop-opacity") || "0.44")
+      );
+      backdrop.style.pointerEvents = progress > 0.01 && !this.hasInteractiveOutside() ? "auto" : "none";
+    }
+    if (view) {
+      view.style.pointerEvents = progress > 0.01 && !this.hasInteractiveOutside() ? "auto" : "none";
+      view.dataset.presented = this.presented ? "true" : "false";
+      view.dataset.status = status;
+      view.dataset.outsideInteractive = this.hasInteractiveOutside() ? "true" : "false";
+    }
+    this.applyOutletAnimations(progress);
+    this.updateThemeDimming(progress);
+    dispatch(this.root, "cap-sheet-travel", this.getTravelEvent());
+  }
+  async animateTo(targetOffsetPx, settings) {
+    const content = this.parts.content;
+    const backdrop = this.parts.backdrop;
+    const resolved = resolveAnimation(settings);
+    if (!content || shouldSkipMotion(resolved.skip)) {
+      this.applyOffset(targetOffsetPx, "idle");
+      return;
+    }
+    const startOffset = this.currentOffsetPx;
+    const fromProgress = this.getProgressForOffset(startOffset);
+    const toProgress = this.getProgressForOffset(targetOffsetPx);
+    const duration = Math.max(0, resolved.duration);
+    const axis = isVerticalTrack(this.activeTrack) ? "y" : "x";
+    const fromEm = toEm(content, startOffset);
+    const targetEm = toEm(content, targetOffsetPx);
+    const fromTransform = this.options.contentPlacement === "center" ? `translate3d(0, 0, 0) scale(${0.96 + fromProgress * 0.04})` : axis === "y" ? `translate3d(0, ${fromEm}em, 0)` : `translate3d(${fromEm}em, 0, 0)`;
+    const toTransform = this.options.contentPlacement === "center" ? `translate3d(0, 0, 0) scale(${0.96 + toProgress * 0.04})` : axis === "y" ? `translate3d(0, ${targetEm}em, 0)` : `translate3d(${targetEm}em, 0, 0)`;
+    const contentAnimation = resolved.contentMove ? content.animate(
+      [
+        { transform: fromTransform, opacity: this.options.contentPlacement === "center" ? fromProgress : 1 },
+        { transform: toTransform, opacity: this.options.contentPlacement === "center" ? toProgress : 1 }
+      ],
+      { duration, easing: resolved.easing, fill: "both" }
+    ) : null;
+    const backdropOpacity = backdrop ? Number.parseFloat(getComputedStyle(backdrop).getPropertyValue("--cap-sheet-backdrop-opacity") || "0.44") : 0;
+    const backdropAnimation = backdrop?.animate(
+      [{ opacity: fromProgress * backdropOpacity }, { opacity: toProgress * backdropOpacity }],
+      { duration, easing: resolved.easing, fill: "both" }
+    );
+    const started = performance.now();
+    let frame;
+    const tick = () => {
+      const progress = duration === 0 ? 1 : clamp((performance.now() - started) / duration, 0, 1);
+      const offset = startOffset + (targetOffsetPx - startOffset) * progress;
+      this.currentOffsetPx = offset;
+      this.applyOutletAnimations(this.getProgressForOffset(offset));
+      this.updateThemeDimming(this.getProgressForOffset(offset));
+      dispatch(this.root, "cap-sheet-travel", this.getTravelEvent());
+      if (progress < 1) frame = requestAnimationFrame(tick);
+    };
+    frame = requestAnimationFrame(tick);
+    await Promise.allSettled([
+      contentAnimation?.finished,
+      backdropAnimation ? backdropAnimation.finished : Promise.resolve()
+    ]);
+    cancelAnimationFrame(frame);
+    contentAnimation?.cancel();
+    backdropAnimation?.cancel();
+    this.applyOffset(targetOffsetPx, "idle");
+  }
+  getProgressForOffset(offsetPx) {
+    if (this.options.contentPlacement === "center") {
+      return this.presented ? 1 : 0;
+    }
+    const hidden = Math.abs(this.hiddenOffsetPx) || 1;
+    return clamp(1 - Math.abs(offsetPx) / hidden, 0, 1);
+  }
+  limitOffset(offsetPx) {
+    const sign = trackSign(this.activeTrack);
+    const maxAbs = Math.abs(this.hiddenOffsetPx);
+    const min = sign < 0 ? -maxAbs : 0;
+    const max = sign < 0 ? 0 : maxAbs;
+    if (this.options.swipeOvershoot === false) return clamp(offsetPx, min, max);
+    if (offsetPx < min) return min + (offsetPx - min) * 0.18;
+    if (offsetPx > max) return max + (offsetPx - max) * 0.18;
+    return offsetPx;
+  }
+  nearestDetentForOffset(offsetPx, velocity) {
+    const sign = trackSign(this.activeTrack);
+    const fling = Math.abs(velocity) > 700 ? Math.sign(velocity) * sign : 0;
+    if (fling > 0) return Math.max(0, this.activeDetent - 1);
+    if (fling < 0) return Math.min(this.detentOffsetsPx.length - 1, this.activeDetent + 1);
+    let nearest = 0;
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    this.detentOffsetsPx.forEach((offset, index) => {
+      if (index === 0 && this.options.swipeDismissal === false) return;
+      const distance = Math.abs(offset - offsetPx);
+      if (distance < nearestDistance) {
+        nearest = index;
+        nearestDistance = distance;
+      }
+    });
+    return nearest;
+  }
+  hasInteractiveOutside() {
+    return this.options.inertOutside === false && this.options.closeOnOutsideClick === false;
+  }
+  isNativeEdgePointer(event) {
+    const view = this.parts.view;
+    if (!view) return false;
+    const rect = view.getBoundingClientRect();
+    const edgeSize = Math.max(20, rect.width * 0.04);
+    return event.clientX - rect.left <= edgeSize || rect.right - event.clientX <= edgeSize || event.clientY - rect.top <= edgeSize || rect.bottom - event.clientY <= edgeSize;
+  }
+  applySafeArea() {
+    const view = this.parts.view;
+    if (!view) return;
+    const edges = new Set(resolveSafeAreaEdges(this.options.safeArea));
+    view.dataset.safeArea = edges.size > 0 ? Array.from(edges).join(" ") : "none";
+    for (const edge of safeAreaEdges) {
+      view.style.setProperty(
+        `--cap-sheet-applied-safe-area-${edge}`,
+        edges.has(edge) ? `var(--cap-sheet-safe-area-${edge})` : "0em"
+      );
+    }
+  }
+  addGlobalListeners() {
+    const doc = this.root.ownerDocument;
+    if (!this.documentListenersAttached) {
+      doc.addEventListener("keydown", this.handleDocumentKeyDown);
+      this.documentListenersAttached = true;
+    }
+    this.addViewListeners();
+    this.addVisualViewportListeners();
+  }
+  removeGlobalListeners() {
+    const doc = this.root.ownerDocument;
+    if (this.documentListenersAttached) {
+      doc.removeEventListener("keydown", this.handleDocumentKeyDown);
+      this.documentListenersAttached = false;
+    }
+    this.removeViewListeners();
+    this.removeVisualViewportListeners();
+  }
+  addViewListeners() {
+    const view = this.parts.view;
+    if (!view || this.viewListenersElement === view) return;
+    this.removeViewListeners();
+    view.addEventListener("click", this.handleViewClick);
+    view.addEventListener("pointerdown", this.handlePointerDown);
+    view.addEventListener("pointermove", this.handlePointerMove, { passive: false });
+    view.addEventListener("pointerup", this.handlePointerUp);
+    view.addEventListener("pointercancel", this.handlePointerUp);
+    view.addEventListener("wheel", this.handleWheel, { passive: false });
+    this.viewListenersElement = view;
+  }
+  removeViewListeners() {
+    const view = this.viewListenersElement;
+    if (!view) return;
+    view.removeEventListener("click", this.handleViewClick);
+    view.removeEventListener("pointerdown", this.handlePointerDown);
+    view.removeEventListener("pointermove", this.handlePointerMove);
+    view.removeEventListener("pointerup", this.handlePointerUp);
+    view.removeEventListener("pointercancel", this.handlePointerUp);
+    view.removeEventListener("wheel", this.handleWheel);
+    this.viewListenersElement = null;
+  }
+  addVisualViewportListeners() {
+    const visualViewport = this.root.ownerDocument.defaultView?.visualViewport;
+    if (!visualViewport || this.visualViewportListenersAttached) return;
+    visualViewport.addEventListener("resize", this.handleVisualViewportResize);
+    visualViewport.addEventListener("scroll", this.handleVisualViewportResize);
+    this.visualViewportListenersAttached = true;
+    this.handleVisualViewportResize();
+  }
+  removeVisualViewportListeners() {
+    const visualViewport = this.root.ownerDocument.defaultView?.visualViewport;
+    if (!visualViewport || !this.visualViewportListenersAttached) return;
+    visualViewport.removeEventListener("resize", this.handleVisualViewportResize);
+    visualViewport.removeEventListener("scroll", this.handleVisualViewportResize);
+    this.visualViewportListenersAttached = false;
+  }
+  updateDomState(presented) {
+    const view = this.parts.view;
+    const content = this.parts.content;
+    if (view) {
+      view.hidden = !presented && Math.abs(this.currentOffsetPx) === Math.abs(this.detentOffsetsPx[0] || 0);
+      view.dataset.presented = presented ? "true" : "false";
+      view.dataset.status = this.status;
+      view.style.setProperty("--cap-sheet-z-index", String(this.getStackZIndex()));
+    }
+    if (content) {
+      content.setAttribute("aria-hidden", attributeBoolean(!presented));
+      content.setAttribute("tabindex", content.getAttribute("tabindex") || "-1");
+    }
+    this.root.toggleAttribute("presented", presented);
+  }
+  linkAccessibleNames() {
+    if (!this.parts.content) return;
+    if (this.parts.title) {
+      if (!this.parts.title.id) this.parts.title.id = createId("cap-sheet-title");
+      this.parts.content.setAttribute("aria-labelledby", this.parts.title.id);
+    }
+    if (this.parts.description) {
+      if (!this.parts.description.id) this.parts.description.id = createId("cap-sheet-description");
+      this.parts.content.setAttribute("aria-describedby", this.parts.description.id);
+    }
+  }
+  focusInitialElement() {
+    const content = this.parts.content;
+    if (!content) return;
+    const target = this.parts.autoFocusTarget || content.querySelector("cap-auto-focus-target, [autofocus]");
+    const focusable = target || getFocusable(content)[0] || content;
+    requestAnimationFrame(() => focusable.focus({ preventScroll: this.options.nativeFocusScrollPrevention !== false }));
+  }
+  restoreFocus() {
+    if (this.options.restoreFocus === false) return;
+    if (this.previousFocus instanceof HTMLElement && this.previousFocus.isConnected) {
+      this.previousFocus.focus({ preventScroll: true });
+    }
+    this.previousFocus = null;
+  }
+  trapFocus(event) {
+    const content = this.parts.content;
+    if (!content) return;
+    const focusable = getFocusable(content);
+    if (focusable.length === 0) {
+      event.preventDefault();
+      content.focus({ preventScroll: true });
+      return;
+    }
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    const active = this.root.ownerDocument.activeElement;
+    if (event.shiftKey && active === first) {
+      event.preventDefault();
+      last.focus({ preventScroll: true });
+    } else if (!event.shiftKey && active === last) {
+      event.preventDefault();
+      first.focus({ preventScroll: true });
+    }
+  }
+  lockPage() {
+    if (this.lockedScroll) return;
+    const body = this.root.ownerDocument.body;
+    this.previousBodyOverflow = body.style.overflow;
+    this.previousBodyTouchAction = body.style.touchAction;
+    body.dataset.capSheetScrollLocked = "true";
+    body.style.overflow = "hidden";
+    body.style.touchAction = "none";
+    this.lockedScroll = true;
+  }
+  unlockPage() {
+    if (!this.lockedScroll) return;
+    const body = this.root.ownerDocument.body;
+    delete body.dataset.capSheetScrollLocked;
+    body.style.overflow = this.previousBodyOverflow;
+    body.style.touchAction = this.previousBodyTouchAction;
+    this.previousBodyOverflow = "";
+    this.previousBodyTouchAction = "";
+    this.lockedScroll = false;
+  }
+  applyInert() {
+    if (this.options.inertOutside === false || !this.parts.view) return;
+    const body = this.root.ownerDocument.body;
+    const allowed = /* @__PURE__ */ new Set([this.parts.view, ...this.parts.islands, ...this.parts.externalOverlays]);
+    this.clearInert();
+    for (const child of Array.from(body.children)) {
+      if (!(child instanceof HTMLElement)) continue;
+      const isAllowed = Array.from(allowed).some((element) => child === element || child.contains(element));
+      if (isAllowed) continue;
+      this.inertedElements.set(child, child.getAttribute("aria-hidden"));
+      child.inert = true;
+      child.setAttribute("aria-hidden", "true");
+    }
+  }
+  clearInert() {
+    for (const [element, ariaHidden] of this.inertedElements) {
+      element.inert = false;
+      if (ariaHidden === null) {
+        element.removeAttribute("aria-hidden");
+      } else {
+        element.setAttribute("aria-hidden", ariaHidden);
+      }
+    }
+    this.inertedElements.clear();
+  }
+  retainThemeDimmer() {
+    if (this.hasThemeDimmer || this.options.themeColorDimming !== "auto") return;
+    this.hasThemeDimmer = true;
+    retainThemeColorDimmer();
+  }
+  releaseThemeDimmer() {
+    if (!this.hasThemeDimmer) return;
+    this.hasThemeDimmer = false;
+    releaseThemeColorDimmer(this.root.ownerDocument);
+  }
+  updateThemeDimming(progress) {
+    if (!this.hasThemeDimmer || this.options.themeColorDimming !== "auto") return;
+    const color = this.parts.backdrop ? getComputedStyle(this.parts.backdrop).getPropertyValue("--cap-sheet-backdrop-color") || "rgb(0 0 0)" : "rgb(0 0 0)";
+    setThemeColorDimming(this.root.ownerDocument, clamp(progress * 0.44, 0, 0.7), color);
+  }
+  applyOutletAnimations(progress) {
+    this.updateOutletProgress();
+    for (const outlet of this.parts.outlets) {
+      const animation = outlet.travelAnimation;
+      if (!animation) continue;
+      for (const [property, value] of Object.entries(animation)) {
+        if (value === null || value === void 0) continue;
+        if (Array.isArray(value)) {
+          outlet.style.setProperty(property, tween(value[0], value[1], progress));
+        } else if (typeof value === "function") {
+          const next = value({ progress, tween: (start, end) => tween(start, end, progress) });
+          if (next !== null && next !== void 0) outlet.style.setProperty(property, String(next));
+        } else {
+          outlet.style.setProperty(property, String(value));
+        }
+      }
+    }
+  }
+  updateOutletProgress() {
+    const travel = this.getTravelEvent();
+    for (const outlet of this.parts.outlets) {
+      outlet.style.setProperty("--cap-sheet-progress", String(travel.progress));
+      outlet.style.setProperty("--cap-sheet-offset", `${travel.offset}em`);
+      outlet.dataset.sheetStatus = travel.status;
+    }
+  }
+  emitPresentedChange(presented, source) {
+    const detail = { presented, source };
+    dispatch(this.root, "cap-sheet-presented-change", detail);
+  }
+  emitActiveDetentChange(activeDetent, previousActiveDetent) {
+    const detail = { activeDetent, previousActiveDetent };
+    dispatch(this.root, "cap-sheet-active-detent-change", detail);
+  }
+  registerStack() {
+    const nextStack = this.options.stack || this.root.closest("cap-sheet-stack")?.id || null;
+    if (this.stackId === nextStack) return;
+    this.unregisterStack();
+    this.stackId = nextStack;
+    if (!nextStack) return;
+    const stack = stackRegistry.get(nextStack) || /* @__PURE__ */ new Set();
+    stack.add(this);
+    stackRegistry.set(nextStack, stack);
+    this.updateStack();
+  }
+  unregisterStack() {
+    if (!this.stackId) return;
+    const stack = stackRegistry.get(this.stackId);
+    stack?.delete(this);
+    if (stack?.size === 0) stackRegistry.delete(this.stackId);
+    this.stackId = null;
+  }
+  getStackZIndex() {
+    if (!this.stackId) return 1e3;
+    const stack = Array.from(stackRegistry.get(this.stackId) || []);
+    const index = stack.indexOf(this);
+    return 1e3 + Math.max(index, 0) * 2;
+  }
+  updateStack() {
+    if (!this.stackId) return;
+    const stack = Array.from(stackRegistry.get(this.stackId) || []);
+    const presented = stack.filter((controller) => controller.presented);
+    stack.forEach((controller, index) => {
+      controller.parts.view?.style.setProperty("--cap-sheet-z-index", String(1e3 + index * 2));
+      const depth = presented.length - presented.indexOf(controller) - 1;
+      const stackDepth = Math.max(depth, 0);
+      controller.parts.content?.style.setProperty("--cap-sheet-stack-depth", String(stackDepth));
+      controller.applyStackingAnimations(stackDepth);
+    });
+  }
+  applyStackingAnimations(depth) {
+    const progress = clamp(depth, 0, 4) / 4;
+    for (const outlet of this.parts.outlets) {
+      const animation = outlet.stackingAnimation;
+      if (!animation) continue;
+      for (const [property, value] of Object.entries(animation)) {
+        if (value === null || value === void 0) continue;
+        if (Array.isArray(value)) {
+          outlet.style.setProperty(property, tween(value[0], value[1], progress));
+        } else if (typeof value === "function") {
+          const next = value({ progress, tween: (start, end) => tween(start, end, progress) });
+          if (next !== null && next !== void 0) outlet.style.setProperty(property, String(next));
+        } else {
+          outlet.style.setProperty(property, String(value));
+        }
+      }
+    }
+  }
+  setStatus(status) {
+    if (this.status === status) return;
+    const previousStatus = this.status;
+    this.status = status;
+    dispatch(this.root, "cap-sheet-travel-status-change", { previousStatus, status });
+  }
+};
+function tween(start, end, progress) {
+  const startString = String(start);
+  const endString = String(end);
+  const startValue = Number.parseFloat(startString);
+  const endValue = Number.parseFloat(endString);
+  if (!Number.isFinite(startValue) || !Number.isFinite(endValue)) return progress < 1 ? startString : endString;
+  const unit = endString.replace(String(endValue), "") || startString.replace(String(startValue), "");
+  const next = startValue + (endValue - startValue) * progress;
+  return `${next}${unit}`;
+}
+
+// src/components/cap-sheet.ts
+var observed = [
+  "active-detent",
+  "close-on-escape",
+  "close-on-outside-click",
+  "content-placement",
+  "default-active-detent",
+  "default-presented",
+  "detents",
+  "focus-trap",
+  "inert-outside",
+  "native-edge-swipe-prevention",
+  "native-focus-scroll-prevention",
+  "presented",
+  "restore-focus",
+  "safe-area",
+  "sheet-role",
+  "stack",
+  "swipe",
+  "swipe-dismissal",
+  "swipe-overshoot",
+  "swipe-trap",
+  "theme-color-dimming",
+  "tracks"
+];
+var CapSheet = class extends HTMLElement {
+  controller = new SheetController(this);
+  syncingAttribute = false;
+  static get observedAttributes() {
+    return observed;
+  }
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.style.display ||= "contents";
+    this.controller.connect();
+  }
+  disconnectedCallback() {
+    this.controller.disconnect();
+  }
+  attributeChangedCallback() {
+    if (this.syncingAttribute) return;
+    this.controller.configure({});
+    if (this.isConnected) {
+      if (this.hasAttribute("presented") && !this.controller.presented) {
+        void this.present({ source: "programmatic" });
+      } else if (!this.hasAttribute("presented") && this.controller.presented) {
+        void this.dismiss({ source: "programmatic" });
+      }
+    }
+  }
+  /** True when the sheet is currently presented. */
+  get presented() {
+    return this.controller.presented;
+  }
+  set presented(value) {
+    if (value) {
+      void this.present();
+    } else {
+      void this.dismiss();
+    }
+  }
+  /** Current active detent index. */
+  get activeDetent() {
+    return this.controller.activeDetent;
+  }
+  set activeDetent(value) {
+    void this.stepTo(value);
+  }
+  /** Configure the sheet imperatively without depending on a framework adapter. */
+  configure(options) {
+    this.controller.configure(options);
+  }
+  /** Present the sheet. */
+  async present(options = {}) {
+    await this.controller.present(options);
+    this.syncAttribute("presented", true);
+  }
+  /** Dismiss the sheet. */
+  async dismiss(options = {}) {
+    await this.controller.dismiss(options);
+    this.syncAttribute("presented", false);
+  }
+  /** Toggle presentation state. */
+  async toggle(options = {}) {
+    if (this.presented) {
+      await this.dismiss(options);
+    } else {
+      await this.present(options);
+    }
+  }
+  /** Step to a specific detent index. */
+  async stepTo(detent, options = {}) {
+    await this.controller.stepTo(detent, options);
+    if (this.controller.presented) this.syncAttribute("presented", true);
+  }
+  /** Step one detent up or down. */
+  async step(direction = "up", options = {}) {
+    await this.controller.step(direction, options);
+  }
+  syncAttribute(name, enabled) {
+    this.syncingAttribute = true;
+    this.toggleAttribute(name, enabled);
+    this.syncingAttribute = false;
+  }
+};
+function getSheetFromElement(element) {
+  const explicitTarget = element.getAttribute("for");
+  if (explicitTarget) {
+    const found = element.ownerDocument.getElementById(explicitTarget);
+    return isCapSheetElement(found) ? found : null;
+  }
+  const nearest = element.closest("cap-sheet");
+  return isCapSheetElement(nearest) ? nearest : null;
+}
+function isCapSheetElement(element) {
+  if (element?.localName !== "cap-sheet") return false;
+  const candidate = element;
+  return typeof candidate.present === "function" && typeof candidate.dismiss === "function";
+}
+function applySheetOptions(element, options) {
+  if (options.contentPlacement) element.setAttribute("content-placement", options.contentPlacement);
+  if (options.detents !== void 0) {
+    element.setAttribute("detents", Array.isArray(options.detents) ? options.detents.join(" ") : options.detents);
+  }
+  if (options.activeDetent !== void 0) element.setAttribute("active-detent", String(options.activeDetent));
+  if (options.defaultActiveDetent !== void 0) {
+    element.setAttribute("default-active-detent", String(options.defaultActiveDetent));
+  }
+  if (options.defaultPresented !== void 0)
+    element.setAttribute("default-presented", String(options.defaultPresented));
+  if (options.presented !== void 0) element.toggleAttribute("presented", options.presented);
+  if (options.sheetRole) element.setAttribute("sheet-role", options.sheetRole);
+  if (options.safeArea !== void 0) {
+    element.setAttribute(
+      "safe-area",
+      Array.isArray(options.safeArea) ? options.safeArea.join(" ") : String(options.safeArea)
+    );
+  }
+  if (options.stack) element.setAttribute("stack", options.stack);
+  if (options.tracks)
+    element.setAttribute("tracks", Array.isArray(options.tracks) ? options.tracks.join(" ") : options.tracks);
+  for (const [key, attr] of [
+    ["swipe", "swipe"],
+    ["swipeDismissal", "swipe-dismissal"],
+    ["swipeOvershoot", "swipe-overshoot"],
+    ["swipeTrap", "swipe-trap"],
+    ["inertOutside", "inert-outside"],
+    ["nativeEdgeSwipePrevention", "native-edge-swipe-prevention"],
+    ["nativeFocusScrollPrevention", "native-focus-scroll-prevention"],
+    ["closeOnOutsideClick", "close-on-outside-click"],
+    ["closeOnEscape", "close-on-escape"],
+    ["focusTrap", "focus-trap"],
+    ["restoreFocus", "restore-focus"]
+  ]) {
+    const value = options[key];
+    if (typeof value === "boolean") element.setAttribute(attr, String(value));
+  }
+  if (options.themeColorDimming !== void 0) {
+    element.setAttribute("theme-color-dimming", options.themeColorDimming === false ? "false" : "auto");
+  }
+}
+
+// src/components/sheet-actions.ts
+function normalizeAction(value, fallback) {
+  return ["present", "dismiss", "toggle", "step"].includes(value || "") ? value : fallback;
+}
+async function runAction(element, fallback) {
+  const sheet = getSheetFromElement(element);
+  if (!sheet) return;
+  const action = normalizeAction(element.getAttribute("action"), fallback);
+  if (action === "present") {
+    await sheet.present({ source: "trigger" });
+  } else if (action === "dismiss") {
+    await sheet.dismiss({ source: "trigger" });
+  } else if (action === "step") {
+    const detent = Number.parseInt(element.getAttribute("detent") || "", 10);
+    if (Number.isFinite(detent)) {
+      await sheet.stepTo(detent, { source: "trigger" });
+    } else {
+      await sheet.step(element.getAttribute("direction") || "up", { source: "trigger" });
+    }
+  } else {
+    await sheet.toggle({ source: "trigger" });
+  }
+}
+var CapSheetTrigger = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.role ||= "button";
+    if (!this.hasAttribute("tabindex")) this.tabIndex = 0;
+    this.addEventListener("click", this.handleClick);
+    this.addEventListener("keydown", this.handleKeyDown);
+  }
+  disconnectedCallback() {
+    this.removeEventListener("click", this.handleClick);
+    this.removeEventListener("keydown", this.handleKeyDown);
+  }
+  handleClick = () => {
+    void runAction(this, "toggle");
+  };
+  handleKeyDown = (event) => {
+    if (event.key !== "Enter" && event.key !== " ") return;
+    event.preventDefault();
+    void runAction(this, "toggle");
+  };
+};
+var CapSheetHandle = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.role ||= "button";
+    if (!this.hasAttribute("tabindex")) this.tabIndex = 0;
+    this.setAttribute("aria-label", this.getAttribute("aria-label") || "Move sheet");
+    this.addEventListener("click", this.handleClick);
+    this.addEventListener("keydown", this.handleKeyDown);
+  }
+  disconnectedCallback() {
+    this.removeEventListener("click", this.handleClick);
+    this.removeEventListener("keydown", this.handleKeyDown);
+  }
+  handleClick = () => {
+    void runAction(this, "step");
+  };
+  handleKeyDown = (event) => {
+    if (event.key === "ArrowUp") {
+      event.preventDefault();
+      this.setAttribute("direction", "up");
+      void runAction(this, "step");
+    }
+    if (event.key === "ArrowDown") {
+      event.preventDefault();
+      this.setAttribute("direction", "down");
+      void runAction(this, "step");
+    }
+  };
+};
+
+// src/components/sheet-context.ts
+var CapSheetStack = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.style.display ||= "contents";
+    if (!this.id) this.id = `cap-sheet-stack-${Math.random().toString(36).slice(2, 10)}`;
+  }
+};
+var CapSheetOutlet = class extends HTMLElement {
+  travelAnimation;
+  stackingAnimation;
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    getSheetFromElement(this)?.controller.registerOutlet(this);
+  }
+  disconnectedCallback() {
+    getSheetFromElement(this)?.controller.unregisterOutlet(this);
+  }
+};
+var CapSheetSpecialWrapper = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.style.display ||= "contents";
+  }
+};
+var CapSheetSpecialWrapperContent = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.style.display ||= "contents";
+  }
+};
+var CapIsland = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    getSheetFromElement(this)?.controller.registerIsland(this);
+  }
+  disconnectedCallback() {
+    getSheetFromElement(this)?.controller.unregisterIsland(this);
+  }
+};
+var CapExternalOverlay = class extends HTMLElement {
+  registered = null;
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.register();
+  }
+  disconnectedCallback() {
+    this.unregister();
+  }
+  register() {
+    const sheet = getSheetFromElement(this);
+    if (!sheet) return;
+    const selector = this.getAttribute("content-getter");
+    const content = selector ? this.ownerDocument.querySelector(selector) : this;
+    if (!content) return;
+    this.registered = content;
+    sheet.controller.registerIsland(content);
+  }
+  unregister() {
+    const sheet = getSheetFromElement(this);
+    if (sheet && this.registered) {
+      sheet.controller.unregisterIsland(this.registered);
+    }
+    this.registered = null;
+  }
+};
+var CapFixed = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+  }
+};
+var CapVisuallyHidden = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+  }
+};
+
+// src/components/sheet-parts.ts
+var SheetPartElement = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    const sheet = getSheetFromElement(this);
+    sheet?.controller.registerPart(this.partName, this);
+  }
+  disconnectedCallback() {
+    const sheet = getSheetFromElement(this);
+    sheet?.controller.unregisterPart(this.partName, this);
+  }
+};
+var CapSheetView = class extends SheetPartElement {
+  partName = "view";
+  connectedCallback() {
+    super.connectedCallback();
+    const sheet = getSheetFromElement(this);
+    const placement = this.getAttribute("content-placement") || sheet?.controller.options.contentPlacement || "bottom";
+    this.setAttribute("content-placement", placement);
+  }
+};
+var CapSheetBackdrop = class extends SheetPartElement {
+  partName = "backdrop";
+};
+var CapSheetContent = class extends SheetPartElement {
+  partName = "content";
+  connectedCallback() {
+    super.connectedCallback();
+    if (!this.hasAttribute("tabindex")) this.tabIndex = -1;
+  }
+};
+var CapSheetBleedingBackground = class extends HTMLElement {
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+  }
+};
+var CapSheetTitle = class extends SheetPartElement {
+  partName = "title";
+  connectedCallback() {
+    if (!this.id) this.id = createId("cap-sheet-title");
+    super.connectedCallback();
+  }
+};
+var CapSheetDescription = class extends SheetPartElement {
+  partName = "description";
+  connectedCallback() {
+    if (!this.id) this.id = createId("cap-sheet-description");
+    super.connectedCallback();
+  }
+};
+var CapAutoFocusTarget = class extends SheetPartElement {
+  partName = "autoFocusTarget";
+  connectedCallback() {
+    if (!this.hasAttribute("tabindex")) this.tabIndex = -1;
+    super.connectedCallback();
+  }
+};
+
+// src/components/sheet-portal.ts
+var CapSheetPortal = class extends HTMLElement {
+  host = null;
+  connectedCallback() {
+    injectCapSheetStyles(this.ownerDocument);
+    this.style.display ||= "contents";
+    if (this.hasAttribute("disabled")) return;
+    const sheet = this.closest("cap-sheet");
+    if (!sheet) return;
+    if (!sheet.id) sheet.id = createId("cap-sheet");
+    this.host = this.ownerDocument.createElement("div");
+    this.host.dataset.capSheetPortal = sheet.id;
+    this.host.style.display = "contents";
+    for (const child of Array.from(this.children)) {
+      if (child instanceof HTMLElement && !child.hasAttribute("for")) {
+        child.setAttribute("for", sheet.id);
+        for (const descendant of Array.from(
+          child.querySelectorAll(
+            "cap-sheet-view, cap-sheet-backdrop, cap-sheet-content, cap-sheet-title, cap-sheet-description, cap-sheet-trigger, cap-sheet-handle, cap-auto-focus-target"
+          )
+        )) {
+          if (!descendant.hasAttribute("for")) descendant.setAttribute("for", sheet.id);
+        }
+      }
+      this.host.appendChild(child);
+    }
+    this.ownerDocument.body.appendChild(this.host);
+  }
+  disconnectedCallback() {
+    if (!this.host) return;
+    for (const child of Array.from(this.host.children)) {
+      this.appendChild(child);
+    }
+    this.host.remove();
+    this.host = null;
+  }
+};
+
+// src/components/index.ts
+defineElement("cap-sheet", CapSheet);
+defineElement("cap-sheet-trigger", CapSheetTrigger);
+defineElement("cap-sheet-portal", CapSheetPortal);
+defineElement("cap-sheet-view", CapSheetView);
+defineElement("cap-sheet-backdrop", CapSheetBackdrop);
+defineElement("cap-sheet-content", CapSheetContent);
+defineElement("cap-sheet-bleeding-background", CapSheetBleedingBackground);
+defineElement("cap-sheet-handle", CapSheetHandle);
+defineElement("cap-sheet-title", CapSheetTitle);
+defineElement("cap-sheet-description", CapSheetDescription);
+defineElement("cap-sheet-special-wrapper", CapSheetSpecialWrapper);
+defineElement("cap-sheet-special-wrapper-content", CapSheetSpecialWrapperContent);
+defineElement("cap-sheet-stack", CapSheetStack);
+defineElement("cap-sheet-outlet", CapSheetOutlet);
+defineElement("cap-scroll", CapScroll);
+defineElement("cap-scroll-content", CapScrollContent);
+defineElement("cap-fixed", CapFixed);
+defineElement("cap-island", CapIsland);
+defineElement("cap-external-overlay", CapExternalOverlay);
+defineElement("cap-visually-hidden", CapVisuallyHidden);
+defineElement("cap-auto-focus-target", CapAutoFocusTarget);
+
+// src/solid/index.ts
+function setupSheet(element, options = {}) {
+  applySheetOptions(element, options);
+  const presented = (event) => options.onPresentedChange?.(event.detail);
+  const detent = (event) => options.onActiveDetentChange?.(event.detail);
+  const travel = (event) => options.onTravel?.(event.detail);
+  element.addEventListener("cap-sheet-presented-change", presented);
+  element.addEventListener("cap-sheet-active-detent-change", detent);
+  element.addEventListener("cap-sheet-travel", travel);
+  return () => {
+    element.removeEventListener("cap-sheet-presented-change", presented);
+    element.removeEventListener("cap-sheet-active-detent-change", detent);
+    element.removeEventListener("cap-sheet-travel", travel);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupSheet
+});
+//# sourceMappingURL=index.js.map