@capgo/capacitor-sheets 8.0.2

package/dist/index.js

@@ -0,0 +1,2069 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __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/core/utils.ts
+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)}`;
+}
+var focusableSelector;
+var init_utils = __esm({
+  "src/core/utils.ts"() {
+    "use strict";
+    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(",");
+  }
+});
+
+// src/core/styles.ts
+var styles_exports = {};
+__export(styles_exports, {
+  CAP_SHEETS_CSS: () => CSS,
+  injectCapSheetStyles: () => injectCapSheetStyles
+});
+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);
+}
+var STYLE_ID, CSS;
+var init_styles = __esm({
+  "src/core/styles.ts"() {
+    "use strict";
+    STYLE_ID = "capgo-capacitor-sheets-styles";
+    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;
+}
+`;
+  }
+});
+
+// src/components/cap-scroll.ts
+var CapScroll, CapScrollContent;
+var init_cap_scroll = __esm({
+  "src/components/cap-scroll.ts"() {
+    "use strict";
+    init_styles();
+    init_utils();
+    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()
+        });
+      };
+    };
+    CapScrollContent = class extends HTMLElement {
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+      }
+    };
+  }
+});
+
+// src/core/theme-color.ts
+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 updateThemeColor(color, documentRef = document) {
+  const meta = getThemeMeta(documentRef);
+  if (!meta) return;
+  if (activeDimmerCount > 0) {
+    baseThemeColor = color;
+    return;
+  }
+  meta.content = color;
+}
+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;
+  }
+}
+var baseThemeColor, activeDimmerCount;
+var init_theme_color = __esm({
+  "src/core/theme-color.ts"() {
+    "use strict";
+    baseThemeColor = null;
+    activeDimmerCount = 0;
+  }
+});
+
+// src/core/sheet-controller.ts
+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);
+}
+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";
+}
+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}`;
+}
+var defaultOptions, defaultAnimation, stackRegistry, safeAreaEdges, SheetController;
+var init_sheet_controller = __esm({
+  "src/core/sheet-controller.ts"() {
+    "use strict";
+    init_theme_color();
+    init_utils();
+    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"
+    };
+    defaultAnimation = {
+      duration: 420,
+      easing: "cubic-bezier(0.22, 1, 0.36, 1)",
+      skip: "auto",
+      contentMove: true
+    };
+    stackRegistry = /* @__PURE__ */ new Map();
+    safeAreaEdges = ["top", "bottom", "left", "right"];
+    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 });
+      }
+    };
+  }
+});
+
+// src/components/cap-sheet.ts
+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");
+  }
+}
+var observed, CapSheet;
+var init_cap_sheet = __esm({
+  "src/components/cap-sheet.ts"() {
+    "use strict";
+    init_sheet_controller();
+    init_styles();
+    init_utils();
+    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"
+    ];
+    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;
+      }
+    };
+  }
+});
+
+// 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, CapSheetHandle;
+var init_sheet_actions = __esm({
+  "src/components/sheet-actions.ts"() {
+    "use strict";
+    init_styles();
+    init_cap_sheet();
+    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");
+      };
+    };
+    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, CapSheetOutlet, CapSheetSpecialWrapper, CapSheetSpecialWrapperContent, CapIsland, CapExternalOverlay, CapFixed, CapVisuallyHidden;
+var init_sheet_context = __esm({
+  "src/components/sheet-context.ts"() {
+    "use strict";
+    init_styles();
+    init_cap_sheet();
+    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)}`;
+      }
+    };
+    CapSheetOutlet = class extends HTMLElement {
+      travelAnimation;
+      stackingAnimation;
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+        getSheetFromElement(this)?.controller.registerOutlet(this);
+      }
+      disconnectedCallback() {
+        getSheetFromElement(this)?.controller.unregisterOutlet(this);
+      }
+    };
+    CapSheetSpecialWrapper = class extends HTMLElement {
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+        this.style.display ||= "contents";
+      }
+    };
+    CapSheetSpecialWrapperContent = class extends HTMLElement {
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+        this.style.display ||= "contents";
+      }
+    };
+    CapIsland = class extends HTMLElement {
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+        getSheetFromElement(this)?.controller.registerIsland(this);
+      }
+      disconnectedCallback() {
+        getSheetFromElement(this)?.controller.unregisterIsland(this);
+      }
+    };
+    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;
+      }
+    };
+    CapFixed = class extends HTMLElement {
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+      }
+    };
+    CapVisuallyHidden = class extends HTMLElement {
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+      }
+    };
+  }
+});
+
+// src/components/sheet-parts.ts
+var SheetPartElement, CapSheetView, CapSheetBackdrop, CapSheetContent, CapSheetBleedingBackground, CapSheetTitle, CapSheetDescription, CapAutoFocusTarget;
+var init_sheet_parts = __esm({
+  "src/components/sheet-parts.ts"() {
+    "use strict";
+    init_styles();
+    init_utils();
+    init_cap_sheet();
+    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);
+      }
+    };
+    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);
+      }
+    };
+    CapSheetBackdrop = class extends SheetPartElement {
+      partName = "backdrop";
+    };
+    CapSheetContent = class extends SheetPartElement {
+      partName = "content";
+      connectedCallback() {
+        super.connectedCallback();
+        if (!this.hasAttribute("tabindex")) this.tabIndex = -1;
+      }
+    };
+    CapSheetBleedingBackground = class extends HTMLElement {
+      connectedCallback() {
+        injectCapSheetStyles(this.ownerDocument);
+      }
+    };
+    CapSheetTitle = class extends SheetPartElement {
+      partName = "title";
+      connectedCallback() {
+        if (!this.id) this.id = createId("cap-sheet-title");
+        super.connectedCallback();
+      }
+    };
+    CapSheetDescription = class extends SheetPartElement {
+      partName = "description";
+      connectedCallback() {
+        if (!this.id) this.id = createId("cap-sheet-description");
+        super.connectedCallback();
+      }
+    };
+    CapAutoFocusTarget = class extends SheetPartElement {
+      partName = "autoFocusTarget";
+      connectedCallback() {
+        if (!this.hasAttribute("tabindex")) this.tabIndex = -1;
+        super.connectedCallback();
+      }
+    };
+  }
+});
+
+// src/components/sheet-portal.ts
+var CapSheetPortal;
+var init_sheet_portal = __esm({
+  "src/components/sheet-portal.ts"() {
+    "use strict";
+    init_styles();
+    init_utils();
+    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
+var components_exports = {};
+__export(components_exports, {
+  CapAutoFocusTarget: () => CapAutoFocusTarget,
+  CapExternalOverlay: () => CapExternalOverlay,
+  CapFixed: () => CapFixed,
+  CapIsland: () => CapIsland,
+  CapScroll: () => CapScroll,
+  CapScrollContent: () => CapScrollContent,
+  CapSheet: () => CapSheet,
+  CapSheetBackdrop: () => CapSheetBackdrop,
+  CapSheetBleedingBackground: () => CapSheetBleedingBackground,
+  CapSheetContent: () => CapSheetContent,
+  CapSheetDescription: () => CapSheetDescription,
+  CapSheetHandle: () => CapSheetHandle,
+  CapSheetOutlet: () => CapSheetOutlet,
+  CapSheetPortal: () => CapSheetPortal,
+  CapSheetSpecialWrapper: () => CapSheetSpecialWrapper,
+  CapSheetSpecialWrapperContent: () => CapSheetSpecialWrapperContent,
+  CapSheetStack: () => CapSheetStack,
+  CapSheetTitle: () => CapSheetTitle,
+  CapSheetTrigger: () => CapSheetTrigger,
+  CapSheetView: () => CapSheetView,
+  CapVisuallyHidden: () => CapVisuallyHidden
+});
+var init_components = __esm({
+  "src/components/index.ts"() {
+    "use strict";
+    init_utils();
+    init_cap_scroll();
+    init_cap_sheet();
+    init_sheet_actions();
+    init_sheet_context();
+    init_sheet_parts();
+    init_sheet_portal();
+    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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CAP_SHEETS_CSS: () => CSS,
+  CapAutoFocusTarget: () => CapAutoFocusTarget,
+  CapExternalOverlay: () => CapExternalOverlay,
+  CapFixed: () => CapFixed,
+  CapIsland: () => CapIsland,
+  CapScroll: () => CapScroll,
+  CapScrollContent: () => CapScrollContent,
+  CapSheet: () => CapSheet,
+  CapSheetBackdrop: () => CapSheetBackdrop,
+  CapSheetBleedingBackground: () => CapSheetBleedingBackground,
+  CapSheetContent: () => CapSheetContent,
+  CapSheetDescription: () => CapSheetDescription,
+  CapSheetHandle: () => CapSheetHandle,
+  CapSheetOutlet: () => CapSheetOutlet,
+  CapSheetPortal: () => CapSheetPortal,
+  CapSheetSpecialWrapper: () => CapSheetSpecialWrapper,
+  CapSheetSpecialWrapperContent: () => CapSheetSpecialWrapperContent,
+  CapSheetStack: () => CapSheetStack,
+  CapSheetTitle: () => CapSheetTitle,
+  CapSheetTrigger: () => CapSheetTrigger,
+  CapSheetView: () => CapSheetView,
+  CapVisuallyHidden: () => CapVisuallyHidden,
+  SheetController: () => SheetController,
+  applySheetOptions: () => applySheetOptions,
+  getSheetFromElement: () => getSheetFromElement,
+  initCapSheets: () => initCapSheets,
+  injectCapSheetStyles: () => injectCapSheetStyles,
+  updateThemeColor: () => updateThemeColor
+});
+module.exports = __toCommonJS(index_exports);
+init_components();
+init_styles();
+init_theme_color();
+init_sheet_controller();
+init_cap_sheet();
+init_components();
+function initCapSheets() {
+  Promise.resolve().then(() => init_components());
+  if (typeof document !== "undefined") {
+    Promise.resolve().then(() => (init_styles(), styles_exports)).then(({ injectCapSheetStyles: injectCapSheetStyles2 }) => injectCapSheetStyles2(document));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CAP_SHEETS_CSS,
+  CapAutoFocusTarget,
+  CapExternalOverlay,
+  CapFixed,
+  CapIsland,
+  CapScroll,
+  CapScrollContent,
+  CapSheet,
+  CapSheetBackdrop,
+  CapSheetBleedingBackground,
+  CapSheetContent,
+  CapSheetDescription,
+  CapSheetHandle,
+  CapSheetOutlet,
+  CapSheetPortal,
+  CapSheetSpecialWrapper,
+  CapSheetSpecialWrapperContent,
+  CapSheetStack,
+  CapSheetTitle,
+  CapSheetTrigger,
+  CapSheetView,
+  CapVisuallyHidden,
+  SheetController,
+  applySheetOptions,
+  getSheetFromElement,
+  initCapSheets,
+  injectCapSheetStyles,
+  updateThemeColor
+});
+//# sourceMappingURL=index.js.map