@vertz/ui-primitives 0.2.22 → 0.2.24

package/dist/shared/{chunk-myq79qew.js → chunk-jsa3byag.js}

@@ -1,6 +1,6 @@
 import {
   createFloatingPosition
-} from "./chunk-0mcr52hc.js";
+} from "./chunk-vef3sepw.js";
 import {
   Keys,
   isKey
@@ -19,37 +19,57 @@ import {
 } from "./chunk-2db2dnp3.js";
 
 // src/tooltip/tooltip.tsx
-import { __element, __on } from "@vertz/ui/internals";
+import { __discardMountFrame, __element, __flushMountFrame, __on, __pushMountFrame, __styleStr } from "@vertz/ui/internals";
 import { signal } from "@vertz/ui";
 function TooltipTrigger(show, hide) {
-  return (() => {
-    const __el0 = __element("span");
-    __on(__el0, "mouseenter", show);
-    __on(__el0, "mouseleave", hide);
-    __on(__el0, "focus", show);
-    __on(__el0, "blur", hide);
-    __on(__el0, "keydown", (event) => {
-      if (isKey(event, Keys.Escape)) {
-        hide();
-      }
-    });
-    return __el0;
-  })();
+  const __mfDepth = __pushMountFrame();
+  try {
+    const __mfResult0 = (() => {
+      const __el0 = __element("span");
+      __on(__el0, "mouseenter", show);
+      __on(__el0, "mouseleave", hide);
+      __on(__el0, "focus", show);
+      __on(__el0, "blur", hide);
+      __on(__el0, "keydown", (event) => {
+        if (isKey(event, Keys.Escape)) {
+          hide();
+        }
+      });
+      return __el0;
+    })();
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
 }
 function TooltipContent(contentId) {
-  return (() => {
-    const __el0 = __element("div");
-    __el0.setAttribute("role", "tooltip");
-    {
-      const __v = contentId;
-      if (__v != null && __v !== false)
-        __el0.setAttribute("id", __v === true ? "" : __v);
-    }
-    __el0.setAttribute("aria-hidden", "true");
-    __el0.setAttribute("data-state", "closed");
-    __el0.setAttribute("style", "display: none");
-    return __el0;
-  })();
+  const __mfDepth = __pushMountFrame();
+  try {
+    const __mfResult0 = (() => {
+      const __el0 = __element("div");
+      __el0.setAttribute("role", "tooltip");
+      {
+        const __v = contentId;
+        if (__v != null && __v !== false)
+          __el0.setAttribute("id", __v === true ? "" : __v);
+      }
+      __el0.setAttribute("aria-hidden", "true");
+      __el0.setAttribute("data-state", "closed");
+      {
+        const __v = { display: "none" };
+        if (__v != null && __v !== false)
+          __el0.setAttribute("style", typeof __v === "object" ? __styleStr(__v) : __v === true ? "" : String(__v));
+      }
+      return __el0;
+    })();
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
 }
 function TooltipRoot(options = {}) {
   const { delay = 300, onOpenChange, positioning, ...attrs } = options;

package/dist/shared/chunk-jzy1bkdk.js

@@ -0,0 +1,203 @@
+import {
+  Keys,
+  isKey
+} from "./chunk-7867pr13.js";
+import {
+  setDataState,
+  setExpanded,
+  setHidden,
+  setHiddenAnimated,
+  setSelected
+} from "./chunk-vevfhpc9.js";
+import {
+  linkedIds
+} from "./chunk-8y1jf6xr.js";
+import {
+  applyAttrs
+} from "./chunk-2db2dnp3.js";
+
+// src/combobox/combobox.tsx
+import { __discardMountFrame, __element, __enterChildren, __exitChildren, __flushMountFrame, __insert, __on, __pushMountFrame, __styleStr } from "@vertz/ui/internals";
+import { signal } from "@vertz/ui";
+function ComboboxRoot(options = {}) {
+  const __mfDepth = __pushMountFrame();
+  try {
+    let open = function() {
+      state.open.value = true;
+      setExpanded(input, true);
+      setHidden(listbox, false);
+      setDataState(listbox, "open");
+    }, close = function() {
+      state.open.value = false;
+      state.activeIndex.value = -1;
+      setExpanded(input, false);
+      setDataState(listbox, "closed");
+      setHiddenAnimated(listbox, true);
+      updateActiveDescendant(-1);
+    }, selectOption = function(value) {
+      state.value.value = value;
+      state.inputValue.value = value;
+      input.value = value;
+      for (const opt of optionElements) {
+        const isActive = opt.getAttribute("data-value") === value;
+        setSelected(opt, isActive);
+        setDataState(opt, isActive ? "active" : "inactive");
+      }
+      onValueChange?.(value);
+      close();
+      input.focus();
+    }, updateActiveDescendant = function(index) {
+      const opt = optionElements[index];
+      if (index >= 0 && opt) {
+        input.setAttribute("aria-activedescendant", opt.id);
+        for (let i = 0;i < optionElements.length; i++) {
+          const el = optionElements[i];
+          if (el)
+            setDataState(el, i === index ? "active" : "inactive");
+        }
+      } else {
+        input.removeAttribute("aria-activedescendant");
+      }
+    }, Option = function(value, label) {
+      const optId = `${ids.contentId}-opt-${optionElements.length}`;
+      const isSelectedOpt = value === defaultValue;
+      const opt = (() => {
+        const __el2 = __element("div");
+        __el2.setAttribute("role", "option");
+        {
+          const __v = optId;
+          if (__v != null && __v !== false)
+            __el2.setAttribute("id", __v === true ? "" : __v);
+        }
+        {
+          const __v = value;
+          if (__v != null && __v !== false)
+            __el2.setAttribute("data-value", __v === true ? "" : __v);
+        }
+        {
+          const __v = isSelectedOpt ? "true" : "false";
+          if (__v != null && __v !== false)
+            __el2.setAttribute("aria-selected", __v === true ? "" : __v);
+        }
+        {
+          const __v = isSelectedOpt ? "active" : "inactive";
+          if (__v != null && __v !== false)
+            __el2.setAttribute("data-state", __v === true ? "" : __v);
+        }
+        __on(__el2, "click", () => selectOption(value));
+        __enterChildren(__el2);
+        __insert(__el2, label ?? value);
+        __exitChildren();
+        return __el2;
+      })();
+      optionElements.push(opt);
+      return opt;
+    };
+    const { defaultValue = "", onValueChange, onInputChange, ...attrs } = options;
+    const ids = linkedIds("combobox");
+    const state = {
+      open: signal(false),
+      value: signal(defaultValue),
+      inputValue: signal(defaultValue),
+      activeIndex: signal(-1)
+    };
+    const optionElements = [];
+    const input = (() => {
+      const __el0 = __element("input");
+      __el0.setAttribute("type", "text");
+      __el0.setAttribute("role", "combobox");
+      __el0.setAttribute("aria-autocomplete", "list");
+      {
+        const __v = ids.contentId;
+        if (__v != null && __v !== false)
+          __el0.setAttribute("aria-controls", __v === true ? "" : __v);
+      }
+      __el0.setAttribute("aria-haspopup", "listbox");
+      {
+        const __v = ids.triggerId;
+        if (__v != null && __v !== false)
+          __el0.setAttribute("id", __v === true ? "" : __v);
+      }
+      {
+        const __v = defaultValue;
+        if (__v != null)
+          __el0.value = __v;
+      }
+      __el0.setAttribute("aria-expanded", "false");
+      __on(__el0, "input", () => {
+        state.inputValue.value = input.value;
+        onInputChange?.(input.value);
+        if (!state.open.peek())
+          open();
+      });
+      __on(__el0, "focus", () => {
+        if (!state.open.peek() && input.value.length > 0)
+          open();
+      });
+      __on(__el0, "keydown", (event) => {
+        if (isKey(event, Keys.Escape)) {
+          event.preventDefault();
+          close();
+          return;
+        }
+        if (isKey(event, Keys.ArrowDown)) {
+          event.preventDefault();
+          if (!state.open.peek()) {
+            open();
+          }
+          const next = Math.min(state.activeIndex.peek() + 1, optionElements.length - 1);
+          state.activeIndex.value = next;
+          updateActiveDescendant(next);
+          return;
+        }
+        if (isKey(event, Keys.ArrowUp)) {
+          event.preventDefault();
+          const prev = Math.max(state.activeIndex.peek() - 1, 0);
+          state.activeIndex.value = prev;
+          updateActiveDescendant(prev);
+          return;
+        }
+        if (isKey(event, Keys.Enter)) {
+          event.preventDefault();
+          const idx = state.activeIndex.peek();
+          if (idx >= 0 && idx < optionElements.length) {
+            const val = optionElements[idx]?.getAttribute("data-value");
+            if (val != null)
+              selectOption(val);
+          }
+          return;
+        }
+      });
+      return __el0;
+    })();
+    const listbox = (() => {
+      const __el1 = __element("div");
+      __el1.setAttribute("role", "listbox");
+      {
+        const __v = ids.contentId;
+        if (__v != null && __v !== false)
+          __el1.setAttribute("id", __v === true ? "" : __v);
+      }
+      __el1.setAttribute("aria-hidden", "true");
+      __el1.setAttribute("data-state", "closed");
+      {
+        const __v = { display: "none" };
+        if (__v != null && __v !== false)
+          __el1.setAttribute("style", typeof __v === "object" ? __styleStr(__v) : __v === true ? "" : String(__v));
+      }
+      return __el1;
+    })();
+    applyAttrs(input, attrs);
+    const __mfResult0 = { input, listbox, state, Option };
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
+}
+var Combobox = {
+  Root: ComboboxRoot
+};
+
+export { Combobox };

package/dist/shared/chunk-knzg86am.js

@@ -0,0 +1,168 @@
+import {
+  applyAttrs
+} from "./chunk-2db2dnp3.js";
+
+// src/scroll-area/scroll-area.tsx
+import { __append, __conditional, __discardMountFrame, __element, __enterChildren, __exitChildren, __flushMountFrame, __insert, __on, __pushMountFrame, __styleStr } from "@vertz/ui/internals";
+import { signal } from "@vertz/ui";
+function ScrollAreaRoot(options = {}) {
+  const __mfDepth = __pushMountFrame();
+  try {
+    let syncThumbY = function() {
+      const { scrollTop, scrollHeight, clientHeight } = viewport;
+      if (scrollHeight <= clientHeight) {
+        thumbY.style.height = "0";
+        return;
+      }
+      const ratio = clientHeight / scrollHeight;
+      thumbY.style.height = `${ratio * 100}%`;
+      const scrollRatio = scrollTop / (scrollHeight - clientHeight);
+      thumbY.style.transform = `translateY(${scrollRatio * (1 / ratio - 1) * 100}%)`;
+      state.scrollTop.value = scrollTop;
+    }, syncThumbX = function() {
+      const { scrollLeft, scrollWidth, clientWidth } = viewport;
+      if (scrollWidth <= clientWidth) {
+        thumbX.style.width = "0";
+        return;
+      }
+      const ratio = clientWidth / scrollWidth;
+      thumbX.style.width = `${ratio * 100}%`;
+      const scrollRatio = scrollLeft / (scrollWidth - clientWidth);
+      thumbX.style.transform = `translateX(${scrollRatio * (1 / ratio - 1) * 100}%)`;
+      state.scrollLeft.value = scrollLeft;
+    }, update = function() {
+      syncThumbY();
+      syncThumbX();
+    }, handleViewportScroll = function() {
+      if (orientation === "vertical" || orientation === "both")
+        syncThumbY();
+      if (orientation === "horizontal" || orientation === "both")
+        syncThumbX();
+    }, handleThumbYDown = function(e) {
+      isDraggingY = true;
+      startY = e.clientY;
+      startScrollTop = viewport.scrollTop;
+      thumbY.setPointerCapture(e.pointerId);
+      e.preventDefault();
+    }, handleThumbYMove = function(e) {
+      if (!isDraggingY)
+        return;
+      const delta = e.clientY - startY;
+      const scrollbarHeight = scrollbarY.clientHeight;
+      const scrollRange = viewport.scrollHeight - viewport.clientHeight;
+      if (scrollbarHeight > 0) {
+        viewport.scrollTop = startScrollTop + delta / scrollbarHeight * scrollRange;
+      }
+    }, handleThumbYUp = function(e) {
+      isDraggingY = false;
+      thumbY.releasePointerCapture(e.pointerId);
+    }, handleThumbXDown = function(e) {
+      isDraggingX = true;
+      startX = e.clientX;
+      startScrollLeft = viewport.scrollLeft;
+      thumbX.setPointerCapture(e.pointerId);
+      e.preventDefault();
+    }, handleThumbXMove = function(e) {
+      if (!isDraggingX)
+        return;
+      const delta = e.clientX - startX;
+      const scrollbarWidth = scrollbarX.clientWidth;
+      const scrollRange = viewport.scrollWidth - viewport.clientWidth;
+      if (scrollbarWidth > 0) {
+        viewport.scrollLeft = startScrollLeft + delta / scrollbarWidth * scrollRange;
+      }
+    }, handleThumbXUp = function(e) {
+      isDraggingX = false;
+      thumbX.releasePointerCapture(e.pointerId);
+    };
+    const { orientation = "vertical", type: _type, ...attrs } = options;
+    const state = {
+      scrollTop: signal(0),
+      scrollLeft: signal(0)
+    };
+    let isDraggingY = false;
+    let startY = 0;
+    let startScrollTop = 0;
+    let isDraggingX = false;
+    let startX = 0;
+    let startScrollLeft = 0;
+    const thumbY = (() => {
+      const __el0 = __element("div");
+      __on(__el0, "pointerdown", handleThumbYDown);
+      __on(__el0, "pointermove", handleThumbYMove);
+      __on(__el0, "pointerup", handleThumbYUp);
+      return __el0;
+    })();
+    const scrollbarY = (() => {
+      const __el1 = __element("div");
+      __el1.setAttribute("aria-hidden", "true");
+      __el1.setAttribute("data-orientation", "vertical");
+      __enterChildren(__el1);
+      __insert(__el1, thumbY);
+      __exitChildren();
+      return __el1;
+    })();
+    const thumbX = (() => {
+      const __el2 = __element("div");
+      __on(__el2, "pointerdown", handleThumbXDown);
+      __on(__el2, "pointermove", handleThumbXMove);
+      __on(__el2, "pointerup", handleThumbXUp);
+      return __el2;
+    })();
+    const scrollbarX = (() => {
+      const __el3 = __element("div");
+      __el3.setAttribute("aria-hidden", "true");
+      __el3.setAttribute("data-orientation", "horizontal");
+      __enterChildren(__el3);
+      __insert(__el3, thumbX);
+      __exitChildren();
+      return __el3;
+    })();
+    const content = (() => {
+      const __el4 = __element("div");
+      return __el4;
+    })();
+    const showY = orientation === "vertical" || orientation === "both";
+    const showX = orientation === "horizontal" || orientation === "both";
+    const viewport = (() => {
+      const __el5 = __element("div");
+      {
+        const __v = { overflow: "scroll" };
+        if (__v != null && __v !== false)
+          __el5.setAttribute("style", typeof __v === "object" ? __styleStr(__v) : __v === true ? "" : String(__v));
+      }
+      __on(__el5, "scroll", handleViewportScroll);
+      __enterChildren(__el5);
+      __insert(__el5, content);
+      __exitChildren();
+      return __el5;
+    })();
+    viewport.style.scrollbarWidth = "none";
+    const root = (() => {
+      const __el6 = __element("div");
+      {
+        const __v = { position: "relative", overflow: "hidden" };
+        if (__v != null && __v !== false)
+          __el6.setAttribute("style", typeof __v === "object" ? __styleStr(__v) : __v === true ? "" : String(__v));
+      }
+      __enterChildren(__el6);
+      __insert(__el6, viewport);
+      __append(__el6, __conditional(() => showY, () => scrollbarY, () => null));
+      __append(__el6, __conditional(() => showX, () => scrollbarX, () => null));
+      __exitChildren();
+      return __el6;
+    })();
+    applyAttrs(root, attrs);
+    const __mfResult0 = { root, viewport, content, scrollbarY, thumbY, scrollbarX, thumbX, state, update };
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
+}
+var ScrollArea = {
+  Root: ScrollAreaRoot
+};
+
+export { ScrollArea };

package/dist/shared/chunk-kskxxc2q.js

@@ -0,0 +1,228 @@
+import {
+  cn
+} from "./chunk-q7xbcj9q.js";
+import {
+  Keys,
+  handleListNavigation,
+  isKey
+} from "./chunk-7867pr13.js";
+import {
+  setDataState,
+  setExpanded,
+  setHidden,
+  setHiddenAnimated
+} from "./chunk-vevfhpc9.js";
+import {
+  uniqueId
+} from "./chunk-8y1jf6xr.js";
+
+// src/accordion/accordion-composed.tsx
+import { computed, signal } from "@vertz/ui";
+import { __append, __attr, __child, __discardMountFrame, __element, __enterChildren, __exitChildren, __flushMountFrame, __on, __pushMountFrame } from "@vertz/ui/internals";
+import { createContext, ref, useContext } from "@vertz/ui";
+var AccordionContext = createContext(undefined, "@vertz/ui-primitives::AccordionContext");
+var AccordionItemContext = createContext(undefined, "@vertz/ui-primitives::AccordionItemContext");
+function useAccordionContext(componentName) {
+  const ctx = useContext(AccordionContext);
+  if (!ctx) {
+    throw new Error(`<Accordion.${componentName}> must be used inside <Accordion>. ` + "Ensure it is a direct or nested child of the Accordion root component.");
+  }
+  return ctx;
+}
+function AccordionItem(__props) {
+  const __mfDepth = __pushMountFrame();
+  try {
+    const ctx = useAccordionContext("Item");
+    const baseId = uniqueId("accordion");
+    const triggerId = `${baseId}-trigger`;
+    const contentId = `${baseId}-content`;
+    const contentRef = ref();
+    const triggerRef = ref();
+    const itemCtx = {
+      value: __props.value,
+      triggerId,
+      contentId,
+      contentRef,
+      triggerRef,
+      classes: ctx.classes,
+      isOpen: () => ctx.isOpen(__props.value),
+      toggle: () => {
+        const prevHeight = contentRef.current?.scrollHeight ?? 0;
+        ctx.toggle(__props.value);
+        const nowOpen = ctx.isOpen(__props.value);
+        const contentEl = contentRef.current;
+        if (contentEl) {
+          if (nowOpen) {
+            setHidden(contentEl, false);
+            const height = contentEl.scrollHeight;
+            contentEl.style.setProperty("--accordion-content-height", `${height}px`);
+            setDataState(contentEl, "open");
+          } else {
+            contentEl.style.display = "";
+            contentEl.setAttribute("aria-hidden", "false");
+            contentEl.setAttribute("data-state", "open");
+            contentEl.style.setProperty("--accordion-content-height", `${prevHeight}px`);
+            contentEl.offsetHeight;
+            setDataState(contentEl, "closed");
+            setHiddenAnimated(contentEl, true);
+          }
+        }
+        const triggerEl = triggerRef.current;
+        if (triggerEl) {
+          setExpanded(triggerEl, nowOpen);
+          setDataState(triggerEl, nowOpen ? "open" : "closed");
+        }
+      }
+    };
+    const __mfResult0 = AccordionItemContext.Provider({ get value() {
+      return itemCtx;
+    }, children: () => (() => {
+      const __el0 = __element("div");
+      __el0.setAttribute("data-accordion-item", "");
+      __attr(__el0, "data-value", () => __props.value);
+      {
+        const __v = cn(ctx.classes?.item);
+        if (__v != null && __v !== false)
+          __el0.setAttribute("class", __v === true ? "" : __v);
+      }
+      __enterChildren(__el0);
+      __append(__el0, __child(() => __props.children));
+      __exitChildren();
+      return __el0;
+    })() });
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
+}
+function AccordionTrigger(__props) {
+  const __mfDepth = __pushMountFrame();
+  try {
+    const ctx = useContext(AccordionItemContext);
+    if (!ctx) {
+      throw new Error("<Accordion.Trigger> must be used inside <Accordion.Item>. " + "Ensure it is a direct or nested child of an Accordion Item component.");
+    }
+    const initiallyOpen = computed(() => ctx.isOpen());
+    const __mfResult0 = (() => {
+      const __el0 = __element("button");
+      ctx.triggerRef.current = __el0;
+      __el0.setAttribute("type", "button");
+      __attr(__el0, "id", () => ctx.triggerId);
+      __el0.setAttribute("data-accordion-trigger", "");
+      __attr(__el0, "aria-controls", () => ctx.contentId);
+      __attr(__el0, "data-value", () => ctx.value);
+      __attr(__el0, "aria-expanded", () => initiallyOpen.value ? "true" : "false");
+      __attr(__el0, "data-state", () => initiallyOpen.value ? "open" : "closed");
+      __attr(__el0, "class", () => cn(ctx.classes?.trigger, __props.className ?? __props.class));
+      __on(__el0, "click", () => ctx.toggle());
+      __enterChildren(__el0);
+      __append(__el0, __child(() => __props.children));
+      __exitChildren();
+      return __el0;
+    })();
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
+}
+function AccordionContent(__props) {
+  const __mfDepth = __pushMountFrame();
+  try {
+    const ctx = useContext(AccordionItemContext);
+    if (!ctx) {
+      throw new Error("<Accordion.Content> must be used inside <Accordion.Item>. " + "Ensure it is a direct or nested child of an Accordion Item component.");
+    }
+    const el = computed(() => (() => {
+      const __el0 = __element("div");
+      ctx.contentRef.current = __el0;
+      __el0.setAttribute("role", "region");
+      __attr(__el0, "id", () => ctx.contentId);
+      __el0.setAttribute("data-accordion-content", "");
+      __attr(__el0, "aria-labelledby", () => ctx.triggerId);
+      __attr(__el0, "class", () => cn(ctx.classes?.content, __props.className ?? __props.class));
+      __enterChildren(__el0);
+      __append(__el0, (() => {
+        const __el1 = __element("div");
+        __el1.setAttribute("data-part", "content-inner");
+        __enterChildren(__el1);
+        __append(__el1, __child(() => __props.children));
+        __exitChildren();
+        return __el1;
+      })());
+      __exitChildren();
+      return __el0;
+    })());
+    const isOpen = computed(() => ctx.isOpen());
+    el.value.setAttribute("aria-hidden", isOpen.value ? "false" : "true");
+    el.value.setAttribute("data-state", isOpen.value ? "open" : "closed");
+    if (!isOpen.value)
+      el.value.style.display = "none";
+    const __mfResult0 = el.value;
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
+}
+function ComposedAccordionRoot(__props) {
+  const __mfDepth = __pushMountFrame();
+  try {
+    const multiple = computed(() => __props.type === "multiple");
+    const openValues = signal([...__props.defaultValue ?? []], "openValues");
+    const ctx = {
+      classes: __props.classes,
+      isOpen: (value) => openValues.value.includes(value),
+      toggle: (value) => {
+        const current = [...openValues.value];
+        const idx = current.indexOf(value);
+        if (idx >= 0) {
+          current.splice(idx, 1);
+        } else {
+          if (multiple.value) {
+            current.push(value);
+          } else {
+            current.length = 0;
+            current.push(value);
+          }
+        }
+        openValues.value = current;
+        __props.onValueChange?.(current);
+      }
+    };
+    const __mfResult0 = AccordionContext.Provider({ get value() {
+      return ctx;
+    }, children: () => (() => {
+      const __el0 = __element("div");
+      __el0.setAttribute("data-orientation", "vertical");
+      __el0.setAttribute("data-accordion-root", "");
+      __on(__el0, "keydown", (event) => {
+        if (isKey(event, Keys.ArrowUp, Keys.ArrowDown, Keys.Home, Keys.End)) {
+          const root = event.currentTarget;
+          const triggers = [...root.querySelectorAll("[data-accordion-trigger]")];
+          handleListNavigation(event, triggers, { orientation: "vertical" });
+        }
+      });
+      __enterChildren(__el0);
+      __append(__el0, __child(() => __props.children));
+      __exitChildren();
+      return __el0;
+    })() });
+    __flushMountFrame();
+    return __mfResult0;
+  } catch (__mfErr) {
+    __discardMountFrame(__mfDepth);
+    throw __mfErr;
+  }
+}
+var ComposedAccordion = Object.assign(ComposedAccordionRoot, {
+  Item: AccordionItem,
+  Trigger: AccordionTrigger,
+  Content: AccordionContent
+});
+
+export { ComposedAccordion };