@reopt-ai/opt-ui-primitives 1.4.2

package/dist/index.js

@@ -0,0 +1,5013 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/hooks/use-controllable-state.ts
+import { useState, useCallback } from "react";
+function useControllableState(defaultValue, controlledValue, onChange) {
+  const [uncontrolledValue, setUncontrolledValue] = useState(defaultValue);
+  const isControlled = controlledValue !== void 0;
+  const value = isControlled ? controlledValue : uncontrolledValue;
+  const setValue = useCallback(
+    (newValue) => {
+      if (!isControlled) {
+        setUncontrolledValue(newValue);
+      }
+      onChange == null ? void 0 : onChange(newValue);
+    },
+    [isControlled, onChange]
+  );
+  return [value, setValue];
+}
+
+// src/hooks/use-enter-leave.ts
+import { useRef, useEffect, useState as useState2 } from "react";
+function useEnterLeave(open, options) {
+  var _a;
+  const animated = (_a = options == null ? void 0 : options.animated) != null ? _a : true;
+  const ref = useRef(null);
+  const [mounted, setMounted] = useState2(open);
+  const [state, setState] = useState2(open ? "entered" : "idle");
+  const rafRef = useRef(0);
+  useEffect(() => {
+    if (open) {
+      setMounted(true);
+      if (!animated) {
+        setState("entered");
+        return;
+      }
+      setState("entering");
+      rafRef.current = requestAnimationFrame(() => {
+        rafRef.current = requestAnimationFrame(() => {
+          setState("entered");
+        });
+      });
+    } else {
+      if (!animated) {
+        setState("idle");
+        setMounted(false);
+        return;
+      }
+      setState(
+        (prev) => prev === "entered" || prev === "entering" ? "leaving" : prev
+      );
+    }
+    return () => {
+      if (rafRef.current) cancelAnimationFrame(rafRef.current);
+    };
+  }, [open, animated]);
+  useEffect(() => {
+    if (state !== "leaving") return;
+    let cancelled = false;
+    const finish = () => {
+      if (cancelled) return;
+      setState("idle");
+      setMounted(false);
+    };
+    const el = ref.current;
+    if (!el || typeof el.getAnimations !== "function") {
+      const raf2 = requestAnimationFrame(finish);
+      return () => {
+        cancelled = true;
+        cancelAnimationFrame(raf2);
+      };
+    }
+    const raf = requestAnimationFrame(() => {
+      if (cancelled) return;
+      const animations = el.getAnimations();
+      if (animations.length === 0) {
+        finish();
+        return;
+      }
+      Promise.all(
+        animations.map((animation) => animation.finished.catch(() => {
+        }))
+      ).then(finish);
+    });
+    return () => {
+      cancelled = true;
+      cancelAnimationFrame(raf);
+    };
+  }, [state]);
+  const dataAttributes = {};
+  if (state === "entering" || state === "entered") {
+    dataAttributes["data-enter"] = "";
+  }
+  if (state === "leaving") {
+    dataAttributes["data-leave"] = "";
+  }
+  return {
+    ref,
+    mounted,
+    dataAttributes,
+    state
+  };
+}
+
+// src/hooks/use-focus-visible.ts
+import { useCallback as useCallback2, useEffect as useEffect2 } from "react";
+var hadKeyboardEvent = true;
+var listenerCount = 0;
+function handleKeyDown(e) {
+  if (e.metaKey || e.altKey || e.ctrlKey) return;
+  hadKeyboardEvent = true;
+}
+function handlePointerDown() {
+  hadKeyboardEvent = false;
+}
+function addGlobalListeners() {
+  if (listenerCount === 0 && typeof document !== "undefined") {
+    document.addEventListener("keydown", handleKeyDown, true);
+    document.addEventListener("pointerdown", handlePointerDown, true);
+    document.addEventListener("mousedown", handlePointerDown, true);
+    document.addEventListener("touchstart", handlePointerDown, true);
+  }
+  listenerCount += 1;
+}
+function removeGlobalListeners() {
+  listenerCount = Math.max(0, listenerCount - 1);
+  if (listenerCount === 0 && typeof document !== "undefined") {
+    document.removeEventListener("keydown", handleKeyDown, true);
+    document.removeEventListener("pointerdown", handlePointerDown, true);
+    document.removeEventListener("mousedown", handlePointerDown, true);
+    document.removeEventListener("touchstart", handlePointerDown, true);
+  }
+}
+function useFocusVisible() {
+  useEffect2(() => {
+    addGlobalListeners();
+    return removeGlobalListeners;
+  }, []);
+  const onFocus = useCallback2((e) => {
+    if (hadKeyboardEvent) {
+      e.currentTarget.setAttribute("data-focus-visible", "");
+    }
+  }, []);
+  const onBlur = useCallback2((e) => {
+    e.currentTarget.removeAttribute("data-focus-visible");
+  }, []);
+  return {
+    focusVisibleProps: {
+      onFocus,
+      onBlur
+    }
+  };
+}
+
+// src/hooks/use-roving-tabindex.ts
+import { useCallback as useCallback3, useRef as useRef2, useState as useState3, useEffect as useEffect3 } from "react";
+function useRovingTabindex(options = {}) {
+  const {
+    orientation = "horizontal",
+    loop = false,
+    rtl = false,
+    columns
+  } = options;
+  const itemsRef = useRef2([]);
+  const [activeId, setActiveId] = useState3(null);
+  const containerRef = useRef2(null);
+  const seededRef = useRef2(false);
+  const getEnabledItems = useCallback3(() => {
+    return itemsRef.current.filter((item) => !item.disabled);
+  }, []);
+  const register = useCallback3(
+    (id, element, disabled) => {
+      var _a, _b;
+      const existing = itemsRef.current.findIndex((item) => item.id === id);
+      const activeBecameDisabled = existing >= 0 && id === activeId && !!disabled;
+      if (existing >= 0) {
+        itemsRef.current[existing] = { id, element, disabled };
+      } else {
+        itemsRef.current.push({ id, element, disabled });
+      }
+      if (activeId === null && !seededRef.current && !disabled) {
+        seededRef.current = true;
+        setActiveId(id);
+      } else if (activeBecameDisabled) {
+        const next = (_b = (_a = itemsRef.current.find((item) => !item.disabled)) == null ? void 0 : _a.id) != null ? _b : null;
+        if (next === null) seededRef.current = false;
+        setActiveId(next);
+      }
+    },
+    [activeId]
+  );
+  const unregister = useCallback3(
+    (id) => {
+      var _a, _b;
+      itemsRef.current = itemsRef.current.filter((item) => item.id !== id);
+      if (activeId === id) {
+        const next = (_b = (_a = getEnabledItems()[0]) == null ? void 0 : _a.id) != null ? _b : null;
+        if (next === null) seededRef.current = false;
+        setActiveId(next);
+      }
+    },
+    [activeId, getEnabledItems]
+  );
+  const moveTo = useCallback3((id) => {
+    setActiveId(id);
+    const item = itemsRef.current.find((i) => i.id === id);
+    item == null ? void 0 : item.element.focus();
+  }, []);
+  const moveByOffset = useCallback3(
+    (offset2) => {
+      const enabled = getEnabledItems();
+      if (enabled.length === 0) return;
+      const currentIndex = enabled.findIndex((item) => item.id === activeId);
+      let nextIndex = currentIndex + offset2;
+      if (loop) {
+        nextIndex = (nextIndex % enabled.length + enabled.length) % enabled.length;
+      } else {
+        nextIndex = Math.max(0, Math.min(enabled.length - 1, nextIndex));
+      }
+      moveTo(enabled[nextIndex].id);
+    },
+    [activeId, getEnabledItems, loop, moveTo]
+  );
+  const onKeyDown = useCallback3(
+    (e) => {
+      const grid = columns !== void 0 && columns > 0;
+      const horizontal = grid || orientation === "horizontal" || orientation === "both";
+      const vertical = grid || orientation === "vertical" || orientation === "both";
+      const rowOffset = grid ? columns : 1;
+      if (vertical && e.key === "ArrowDown") {
+        e.preventDefault();
+        moveByOffset(rowOffset);
+      } else if (vertical && e.key === "ArrowUp") {
+        e.preventDefault();
+        moveByOffset(-rowOffset);
+      } else if (horizontal && e.key === "ArrowRight") {
+        e.preventDefault();
+        moveByOffset(rtl ? -1 : 1);
+      } else if (horizontal && e.key === "ArrowLeft") {
+        e.preventDefault();
+        moveByOffset(rtl ? 1 : -1);
+      } else if (e.key === "Home") {
+        e.preventDefault();
+        const enabled = getEnabledItems();
+        if (enabled.length > 0) moveTo(enabled[0].id);
+      } else if (e.key === "End") {
+        e.preventDefault();
+        const enabled = getEnabledItems();
+        if (enabled.length > 0) moveTo(enabled[enabled.length - 1].id);
+      }
+    },
+    [orientation, rtl, columns, moveByOffset, getEnabledItems, moveTo]
+  );
+  useEffect3(() => {
+    for (const item of itemsRef.current) {
+      if (item.id === activeId) {
+        item.element.setAttribute("data-active-item", "");
+      } else {
+        item.element.removeAttribute("data-active-item");
+      }
+    }
+  }, [activeId]);
+  return {
+    containerRef,
+    containerProps: {
+      ref: containerRef,
+      onKeyDown
+    },
+    activeId,
+    register,
+    unregister,
+    moveTo,
+    getTabIndex: (id) => id === activeId ? 0 : -1
+  };
+}
+
+// src/hooks/use-floating.ts
+import {
+  useFloating as useFloatingUI,
+  useDismiss,
+  autoUpdate,
+  offset,
+  flip as flipMiddleware,
+  shift as shiftMiddleware,
+  size as sizeMiddleware,
+  hide as hideMiddleware
+} from "@floating-ui/react";
+import {
+  useCallback as useCallback4,
+  useEffect as useEffect4,
+  useMemo,
+  useRef as useRef3,
+  useState as useState4
+} from "react";
+
+// src/internal/state-attrs.ts
+function getStateAttributesProps(attrs) {
+  const result = {};
+  for (const key in attrs) {
+    if (!Object.prototype.hasOwnProperty.call(attrs, key)) continue;
+    const value = attrs[key];
+    if (value === false || value == null || value === "") continue;
+    result[key] = value === true ? "" : String(value);
+  }
+  return result;
+}
+
+// src/hooks/use-floating.ts
+function useFloating(options = {}) {
+  var _a, _b, _c, _d, _e, _f;
+  const {
+    placement = "bottom-start",
+    strategy = "absolute",
+    gutter,
+    sideOffset,
+    alignOffset,
+    sameWidth = false,
+    flip = true,
+    lazyFlip = false,
+    shift = 8,
+    overflowPadding = 12,
+    open = false,
+    onOpenChange,
+    dismiss
+  } = options;
+  const onOpenChangeRef = useRef3(onOpenChange);
+  onOpenChangeRef.current = onOpenChange;
+  const handleOpenChange = useCallback4(
+    (next, _event, reason) => {
+      var _a2;
+      (_a2 = onOpenChangeRef.current) == null ? void 0 : _a2.call(onOpenChangeRef, next, reason);
+    },
+    []
+  );
+  const sideOffsetRef = useRef3(void 0);
+  sideOffsetRef.current = (_a = sideOffset != null ? sideOffset : gutter) != null ? _a : 4;
+  const alignOffsetRef = useRef3(void 0);
+  alignOffsetRef.current = alignOffset;
+  const middleware = useMemo(() => {
+    const m = [];
+    m.push(
+      offset((state) => {
+        const args = {
+          rects: state.rects,
+          placement: state.placement
+        };
+        const so = sideOffsetRef.current;
+        const ao = alignOffsetRef.current;
+        return {
+          mainAxis: typeof so === "function" ? so(args) : so,
+          alignmentAxis: ao == null ? void 0 : typeof ao === "function" ? ao(args) : ao
+        };
+      })
+    );
+    if (flip) m.push(flipMiddleware({ padding: overflowPadding }));
+    if (shift) {
+      const shiftPadding = typeof shift === "number" ? shift : 8;
+      m.push(shiftMiddleware({ padding: shiftPadding }));
+    }
+    m.push(
+      sizeMiddleware({
+        padding: overflowPadding,
+        apply({ rects, elements, availableWidth, availableHeight }) {
+          const dpr = typeof window !== "undefined" && window.devicePixelRatio || 1;
+          const roundByDpr = (v) => Math.round(v * dpr) / dpr;
+          const styles = {
+            "--opt-available-width": `${Math.max(0, Math.round(availableWidth))}px`,
+            "--opt-available-height": `${Math.max(0, Math.round(availableHeight))}px`,
+            "--opt-anchor-width": `${roundByDpr(rects.reference.width)}px`,
+            "--opt-anchor-height": `${roundByDpr(rects.reference.height)}px`
+          };
+          if (sameWidth)
+            styles.width = `${roundByDpr(rects.reference.width)}px`;
+          Object.assign(elements.floating.style, styles);
+        }
+      })
+    );
+    m.push(hideMiddleware({ padding: overflowPadding }));
+    return m;
+  }, [flip, shift, sameWidth, overflowPadding]);
+  const [lockedPlacement, setLockedPlacement] = useState4(
+    null
+  );
+  const effectivePlacement = lazyFlip && lockedPlacement ? lockedPlacement : placement;
+  const floating = useFloatingUI({
+    placement: effectivePlacement,
+    strategy,
+    middleware,
+    whileElementsMounted: open ? autoUpdate : void 0,
+    open,
+    onOpenChange: handleOpenChange
+  });
+  const dismissConfig = typeof dismiss === "object" ? dismiss : {};
+  useDismiss(floating.context, {
+    enabled: dismiss !== void 0 && dismiss !== false,
+    outsidePress: (_b = dismissConfig.outsidePress) != null ? _b : true,
+    escapeKey: (_c = dismissConfig.escapeKey) != null ? _c : true,
+    ancestorScroll: (_d = dismissConfig.ancestorScroll) != null ? _d : false
+  });
+  const isPositioned = floating.isPositioned;
+  useEffect4(() => {
+    if (!open) {
+      setLockedPlacement(null);
+    }
+  }, [open]);
+  useEffect4(() => {
+    if (open && lazyFlip && isPositioned && lockedPlacement === null) {
+      setLockedPlacement(floating.placement);
+    }
+  }, [open, lazyFlip, isPositioned, floating.placement, lockedPlacement]);
+  const [side, alignPart] = floating.placement.split("-");
+  const align = alignPart != null ? alignPart : "center";
+  const anchorHidden = (_f = (_e = floating.middlewareData.hide) == null ? void 0 : _e.referenceHidden) != null ? _f : false;
+  return {
+    refs: floating.refs,
+    floatingStyles: floating.floatingStyles,
+    placement: floating.placement,
+    side,
+    align,
+    isPositioned,
+    anchorHidden,
+    context: floating.context,
+    getReferenceProps: () => ({
+      ref: floating.refs.setReference
+    }),
+    getFloatingProps: () => ({
+      ref: floating.refs.setFloating,
+      style: __spreadValues(__spreadValues({
+        // Seed the available-space caps so first-frame CSS
+        // (max-height: var(--opt-available-height)) resolves before the size
+        // middleware runs — the imperative apply() then refines these.
+        "--opt-available-width": "100vw",
+        "--opt-available-height": "100vh"
+      }, floating.floatingStyles), isPositioned ? null : { opacity: 0 })
+    }),
+    /**
+     * `data-open`/`data-closed`/`data-side`/`data-align`/`data-anchor-hidden`
+     * for the positioner. Additive — spread onto the panel alongside existing
+     * data attributes so Core can target open state, resolved side, and anchor
+     * visibility with CSS only.
+     */
+    getPositionerStateProps: (isOpen) => getStateAttributesProps({
+      "data-open": isOpen,
+      "data-closed": !isOpen,
+      "data-side": side,
+      "data-align": align,
+      "data-anchor-hidden": anchorHidden
+    })
+  };
+}
+
+// src/hooks/use-id.ts
+import { useId as useReactId } from "react";
+function useId(providedId) {
+  const generatedId = useReactId();
+  return providedId != null ? providedId : generatedId;
+}
+
+// src/hooks/use-focusable-when-disabled.ts
+function useFocusableWhenDisabled({
+  disabled = false,
+  focusableWhenDisabled = false,
+  isNativeButton = true,
+  tabIndex
+}) {
+  const inert = disabled && focusableWhenDisabled;
+  return {
+    // Emit native `disabled` only when NOT keeping the element focusable.
+    disabled: isNativeButton ? disabled && !focusableWhenDisabled : void 0,
+    "aria-disabled": inert ? true : void 0,
+    // Native buttons are focusable by default; a non-native element needs an
+    // explicit tabIndex to remain reachable while disabled.
+    tabIndex: !isNativeButton && inert ? tabIndex != null ? tabIndex : 0 : tabIndex
+  };
+}
+
+// src/hooks/use-scroll-into-view.ts
+import { useEffect as useEffect5 } from "react";
+function useScrollActiveDescendantIntoView(activeId) {
+  useEffect5(() => {
+    if (!activeId) return;
+    const el = document.getElementById(activeId);
+    if (el && typeof el.scrollIntoView === "function") {
+      el.scrollIntoView({ block: "nearest", inline: "nearest" });
+    }
+  }, [activeId]);
+}
+
+// src/primitives/disclosure.tsx
+import {
+  createContext,
+  useContext,
+  useCallback as useCallback5,
+  useRef as useRef4,
+  useEffect as useEffect6
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var DisclosureContext = createContext(null);
+function useDisclosureContext() {
+  const ctx = useContext(DisclosureContext);
+  if (!ctx)
+    throw new Error("Disclosure components must be used within DisclosureRoot");
+  return ctx;
+}
+function DisclosureRoot({
+  children,
+  open: controlledOpen,
+  defaultOpen = false,
+  onOpenChange,
+  setOpen: setOpenDeprecated,
+  animated = true
+}) {
+  const [open, setOpen] = useControllableState(
+    defaultOpen,
+    controlledOpen,
+    onOpenChange != null ? onOpenChange : setOpenDeprecated
+  );
+  const baseId = useId();
+  const contentId = `${baseId}-content`;
+  const triggerId = `${baseId}-trigger`;
+  return /* @__PURE__ */ jsx(
+    DisclosureContext.Provider,
+    {
+      value: { open, setOpen, contentId, triggerId, animated },
+      children
+    }
+  );
+}
+function DisclosureTrigger(_a) {
+  var _b = _a, {
+    onClick
+  } = _b, props = __objRest(_b, [
+    "onClick"
+  ]);
+  const { open, setOpen, contentId, triggerId } = useDisclosureContext();
+  const handleClick = useCallback5(
+    (e) => {
+      setOpen(!open);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [open, setOpen, onClick]
+  );
+  return /* @__PURE__ */ jsx(
+    "button",
+    __spreadValues({
+      type: "button",
+      id: triggerId,
+      "aria-expanded": open,
+      "aria-controls": contentId,
+      onClick: handleClick
+    }, props)
+  );
+}
+function DisclosureContent(_a) {
+  var _b = _a, {
+    hiddenUntilFound = false,
+    style
+  } = _b, props = __objRest(_b, [
+    "hiddenUntilFound",
+    "style"
+  ]);
+  const { open, setOpen, contentId, triggerId, animated } = useDisclosureContext();
+  const { ref, mounted, dataAttributes } = useEnterLeave(open, {
+    animated: animated && !hiddenUntilFound
+  });
+  const innerRef = useRef4(null);
+  useEffect6(() => {
+    if (innerRef.current) {
+      ref.current = innerRef.current;
+    }
+  }, [ref]);
+  useEffect6(() => {
+    const el = innerRef.current;
+    if (!el || !hiddenUntilFound) return;
+    const onBeforeMatch = () => setOpen(true);
+    el.addEventListener("beforematch", onBeforeMatch);
+    return () => el.removeEventListener("beforematch", onBeforeMatch);
+  }, [hiddenUntilFound, setOpen]);
+  useEffect6(() => {
+    const el = innerRef.current;
+    if (!el || !hiddenUntilFound) return;
+    if (open) el.removeAttribute("hidden");
+    else el.setAttribute("hidden", "until-found");
+  }, [open, hiddenUntilFound]);
+  if (hiddenUntilFound) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      __spreadValues({
+        ref: innerRef,
+        id: contentId,
+        role: "region",
+        "aria-labelledby": triggerId,
+        "data-state": open ? "open" : "closed",
+        style
+      }, props)
+    );
+  }
+  if (!mounted) return null;
+  return /* @__PURE__ */ jsx(
+    "div",
+    __spreadValues(__spreadValues({
+      ref: innerRef,
+      id: contentId,
+      role: "region",
+      "aria-labelledby": triggerId,
+      style
+    }, dataAttributes), props)
+  );
+}
+
+// src/primitives/button.tsx
+import { forwardRef, useCallback as useCallback6 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Button = forwardRef(
+  (_a, ref) => {
+    var _b = _a, {
+      type = "button",
+      clickOnEnter,
+      clickOnSpace,
+      focusableWhenDisabled = false,
+      disabled = false,
+      onKeyDown,
+      onClick
+    } = _b, props = __objRest(_b, [
+      "type",
+      "clickOnEnter",
+      "clickOnSpace",
+      "focusableWhenDisabled",
+      "disabled",
+      "onKeyDown",
+      "onClick"
+    ]);
+    const focusableProps = useFocusableWhenDisabled({
+      disabled,
+      focusableWhenDisabled
+    });
+    const inert = disabled && focusableWhenDisabled;
+    const handleKeyDown2 = useCallback6(
+      (e) => {
+        if (inert) {
+          if (e.key === "Enter" || e.key === " ") {
+            e.preventDefault();
+            return;
+          }
+        } else {
+          if (clickOnEnter === false && e.key === "Enter") {
+            e.preventDefault();
+          }
+          if (clickOnSpace === false && e.key === " ") {
+            e.preventDefault();
+          }
+        }
+        onKeyDown == null ? void 0 : onKeyDown(e);
+      },
+      [inert, clickOnEnter, clickOnSpace, onKeyDown]
+    );
+    const handleClick = useCallback6(
+      (e) => {
+        if (inert) {
+          e.preventDefault();
+          e.stopPropagation();
+          return;
+        }
+        onClick == null ? void 0 : onClick(e);
+      },
+      [inert, onClick]
+    );
+    const needsKeyHandler = inert || clickOnEnter === false || clickOnSpace === false;
+    return /* @__PURE__ */ jsx2(
+      "button",
+      __spreadProps(__spreadValues(__spreadValues({
+        ref,
+        type
+      }, focusableProps), props), {
+        onKeyDown: needsKeyHandler ? handleKeyDown2 : onKeyDown,
+        onClick: handleClick
+      })
+    );
+  }
+);
+Button.displayName = "Button";
+
+// src/primitives/dialog.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useCallback as useCallback7,
+  useRef as useRef5,
+  useEffect as useEffect7,
+  forwardRef as forwardRef2
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var DialogContext = createContext2(null);
+function useDialogContext() {
+  const ctx = useContext2(DialogContext);
+  if (!ctx) throw new Error("Dialog components must be used within DialogRoot");
+  return ctx;
+}
+function useDialogClose() {
+  const { setOpen } = useDialogContext();
+  return () => setOpen(false);
+}
+function DialogRoot({
+  children,
+  open: controlledOpen,
+  defaultOpen = false,
+  onOpenChange,
+  setOpen: setOpenDeprecated,
+  animated = true
+}) {
+  const [open, setOpen] = useControllableState(
+    defaultOpen,
+    controlledOpen,
+    onOpenChange != null ? onOpenChange : setOpenDeprecated
+  );
+  const baseId = useId();
+  const headingId = `${baseId}-heading`;
+  const descriptionId = `${baseId}-description`;
+  const dialogRef = useRef5(null);
+  return /* @__PURE__ */ jsx3(
+    DialogContext.Provider,
+    {
+      value: { open, setOpen, headingId, descriptionId, animated, dialogRef },
+      children
+    }
+  );
+}
+var DialogDisclosure = forwardRef2((_a, ref) => {
+  var _b = _a, { onClick } = _b, props = __objRest(_b, ["onClick"]);
+  const { setOpen } = useDialogContext();
+  const handleClick = useCallback7(
+    (e) => {
+      setOpen(true);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [setOpen, onClick]
+  );
+  return /* @__PURE__ */ jsx3("button", __spreadValues({ ref, type: "button", onClick: handleClick }, props));
+});
+DialogDisclosure.displayName = "DialogDisclosure";
+var DialogPanel = forwardRef2(
+  (_a, forwardedRef) => {
+    var _b = _a, {
+      backdrop: _backdrop,
+      dismissOnBackdrop = true,
+      dismissOnEscape = true,
+      children,
+      onClick
+    } = _b, props = __objRest(_b, [
+      "backdrop",
+      "dismissOnBackdrop",
+      "dismissOnEscape",
+      "children",
+      "onClick"
+    ]);
+    const { open, setOpen, headingId, descriptionId, animated, dialogRef } = useDialogContext();
+    const {
+      ref: enterLeaveRef,
+      mounted,
+      dataAttributes
+    } = useEnterLeave(open, { animated });
+    const lastFocusedRef = useRef5(null);
+    const wasMountedRef = useRef5(false);
+    useEffect7(() => {
+      const dialog = dialogRef.current;
+      if (!dialog) return;
+      if (mounted && !dialog.open) {
+        lastFocusedRef.current = document.activeElement;
+        dialog.showModal();
+      }
+    }, [mounted, dialogRef]);
+    useEffect7(() => {
+      var _a2;
+      if (mounted) {
+        wasMountedRef.current = true;
+      } else if (wasMountedRef.current) {
+        wasMountedRef.current = false;
+        (_a2 = lastFocusedRef.current) == null ? void 0 : _a2.focus();
+        lastFocusedRef.current = null;
+      }
+    }, [mounted]);
+    const mergedRef = useCallback7(
+      (node) => {
+        dialogRef.current = node;
+        enterLeaveRef.current = node;
+        if (typeof forwardedRef === "function") forwardedRef(node);
+        else if (forwardedRef) forwardedRef.current = node;
+      },
+      [dialogRef, enterLeaveRef, forwardedRef]
+    );
+    useEffect7(() => {
+      const dialog = dialogRef.current;
+      if (!dialog) return;
+      const handleCancel = (e) => {
+        e.preventDefault();
+        if (dismissOnEscape) setOpen(false);
+      };
+      dialog.addEventListener("cancel", handleCancel);
+      return () => dialog.removeEventListener("cancel", handleCancel);
+    }, [dialogRef, setOpen, dismissOnEscape]);
+    const handleClick = useCallback7(
+      (e) => {
+        if (dismissOnBackdrop && e.target === e.currentTarget) {
+          setOpen(false);
+        }
+        onClick == null ? void 0 : onClick(e);
+      },
+      [setOpen, onClick, dismissOnBackdrop]
+    );
+    if (!mounted) return null;
+    return /* @__PURE__ */ jsx3(
+      "dialog",
+      __spreadProps(__spreadValues(__spreadValues({
+        ref: mergedRef,
+        "aria-labelledby": headingId,
+        "aria-describedby": descriptionId,
+        onClick: handleClick
+      }, dataAttributes), props), {
+        children
+      })
+    );
+  }
+);
+DialogPanel.displayName = "DialogPanel";
+var AlertDialogPanel = forwardRef2(function AlertDialogPanel2(props, ref) {
+  return /* @__PURE__ */ jsx3(
+    DialogPanel,
+    __spreadValues({
+      ref,
+      role: "alertdialog",
+      dismissOnBackdrop: false,
+      dismissOnEscape: false
+    }, props)
+  );
+});
+function DialogHeading(props) {
+  const { headingId } = useDialogContext();
+  return /* @__PURE__ */ jsx3("h2", __spreadValues({ id: headingId }, props));
+}
+function DialogDescription(props) {
+  const { descriptionId } = useDialogContext();
+  return /* @__PURE__ */ jsx3("p", __spreadValues({ id: descriptionId }, props));
+}
+var DialogDismiss = forwardRef2(
+  (_a, ref) => {
+    var _b = _a, { onClick } = _b, props = __objRest(_b, ["onClick"]);
+    const { setOpen } = useDialogContext();
+    const handleClick = useCallback7(
+      (e) => {
+        setOpen(false);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [setOpen, onClick]
+    );
+    return /* @__PURE__ */ jsx3("button", __spreadValues({ ref, type: "button", onClick: handleClick }, props));
+  }
+);
+DialogDismiss.displayName = "DialogDismiss";
+
+// src/primitives/tabs.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useCallback as useCallback8,
+  useRef as useRef6,
+  useLayoutEffect
+} from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function nextEnabledTabId(tabs, currentId, delta) {
+  const enabled = tabs.filter((t) => !t.disabled);
+  if (enabled.length === 0) return null;
+  const idx = enabled.findIndex((t) => t.id === currentId);
+  if (idx < 0) return enabled[0].id;
+  const n = enabled.length;
+  const next = ((idx + delta) % n + n) % n;
+  return enabled[next].id;
+}
+var TabsContext = createContext3(null);
+function useTabsContext() {
+  const ctx = useContext3(TabsContext);
+  if (!ctx) throw new Error("Tabs components must be used within TabsRoot");
+  return ctx;
+}
+function TabsRoot({
+  children,
+  selectedId: controlledId,
+  defaultSelectedId = "",
+  onSelectedIdChange,
+  setSelectedId: setSelectedIdDeprecated,
+  orientation = "horizontal"
+}) {
+  const [selectedId, setSelectedId] = useControllableState(
+    defaultSelectedId,
+    controlledId,
+    onSelectedIdChange != null ? onSelectedIdChange : setSelectedIdDeprecated
+  );
+  const baseId = useId();
+  const tabs = useRef6([]);
+  const registerTab = useCallback8((id, disabled) => {
+    const existing = tabs.current.findIndex((t) => t.id === id);
+    if (existing >= 0) tabs.current[existing] = { id, disabled };
+    else tabs.current.push({ id, disabled });
+  }, []);
+  const unregisterTab = useCallback8((id) => {
+    tabs.current = tabs.current.filter((t) => t.id !== id);
+  }, []);
+  useLayoutEffect(() => {
+    if (!selectedId) {
+      const first = tabs.current.find((t) => !t.disabled);
+      if (first) setSelectedId(first.id);
+    }
+  }, [selectedId, setSelectedId]);
+  return /* @__PURE__ */ jsx4(
+    TabsContext.Provider,
+    {
+      value: {
+        selectedId,
+        setSelectedId,
+        baseId,
+        orientation,
+        registerTab,
+        unregisterTab,
+        tabs
+      },
+      children
+    }
+  );
+}
+function TabList(_a) {
+  var _b = _a, {
+    role = "tablist",
+    onKeyDown
+  } = _b, props = __objRest(_b, [
+    "role",
+    "onKeyDown"
+  ]);
+  const { selectedId, setSelectedId, tabs, orientation } = useTabsContext();
+  const handleKeyDown2 = useCallback8(
+    (e) => {
+      var _a2, _b2, _c, _d, _e;
+      const prevKey = orientation === "vertical" ? "ArrowUp" : "ArrowLeft";
+      const nextKey = orientation === "vertical" ? "ArrowDown" : "ArrowRight";
+      let nextId = null;
+      if (e.key === nextKey) {
+        e.preventDefault();
+        nextId = nextEnabledTabId(tabs.current, selectedId, 1);
+      } else if (e.key === prevKey) {
+        e.preventDefault();
+        nextId = nextEnabledTabId(tabs.current, selectedId, -1);
+      } else if (e.key === "Home") {
+        e.preventDefault();
+        nextId = (_b2 = (_a2 = tabs.current.find((t) => !t.disabled)) == null ? void 0 : _a2.id) != null ? _b2 : null;
+      } else if (e.key === "End") {
+        e.preventDefault();
+        nextId = (_d = (_c = [...tabs.current].reverse().find((t) => !t.disabled)) == null ? void 0 : _c.id) != null ? _d : null;
+      }
+      if (nextId) {
+        setSelectedId(nextId);
+        (_e = document.getElementById(`${nextId}-tab`)) == null ? void 0 : _e.focus();
+      }
+      onKeyDown == null ? void 0 : onKeyDown(e);
+    },
+    [selectedId, setSelectedId, tabs, orientation, onKeyDown]
+  );
+  return /* @__PURE__ */ jsx4(
+    "div",
+    __spreadValues({
+      role,
+      "aria-orientation": orientation,
+      onKeyDown: handleKeyDown2
+    }, props)
+  );
+}
+function Tab(_a) {
+  var _b = _a, { id, disabled, onClick } = _b, props = __objRest(_b, ["id", "disabled", "onClick"]);
+  const { selectedId, setSelectedId, registerTab, unregisterTab } = useTabsContext();
+  const isSelected = selectedId === id;
+  useLayoutEffect(() => {
+    registerTab(id, disabled);
+    return () => unregisterTab(id);
+  }, [id, disabled, registerTab, unregisterTab]);
+  const handleClick = useCallback8(
+    (e) => {
+      if (!disabled) setSelectedId(id);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [id, disabled, setSelectedId, onClick]
+  );
+  return /* @__PURE__ */ jsx4(
+    "button",
+    __spreadValues({
+      type: "button",
+      role: "tab",
+      id: `${id}-tab`,
+      "aria-selected": isSelected,
+      "aria-controls": isSelected ? `${id}-panel` : void 0,
+      tabIndex: isSelected ? 0 : -1,
+      disabled,
+      "data-active-item": isSelected ? "" : void 0,
+      onClick: handleClick
+    }, props)
+  );
+}
+function TabPanel(_a) {
+  var _b = _a, { tabId } = _b, props = __objRest(_b, ["tabId"]);
+  const { selectedId } = useTabsContext();
+  const isSelected = selectedId === tabId;
+  if (!isSelected) return null;
+  return /* @__PURE__ */ jsx4(
+    "div",
+    __spreadValues({
+      role: "tabpanel",
+      id: `${tabId}-panel`,
+      "aria-labelledby": `${tabId}-tab`,
+      tabIndex: 0
+    }, props)
+  );
+}
+
+// src/primitives/radio-group.tsx
+import {
+  createContext as createContext4,
+  useContext as useContext4,
+  useCallback as useCallback9,
+  forwardRef as forwardRef3,
+  useId as useReactId2
+} from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var RadioGroupContext = createContext4(null);
+function useRadioGroupContext() {
+  return useContext4(RadioGroupContext);
+}
+function RadioGroupRoot(_a) {
+  var _b = _a, {
+    children,
+    name: providedName,
+    value: controlledValue,
+    defaultValue = "",
+    onValueChange,
+    onChange,
+    disabled = false,
+    orientation = "vertical"
+  } = _b, props = __objRest(_b, [
+    "children",
+    "name",
+    "value",
+    "defaultValue",
+    "onValueChange",
+    "onChange",
+    "disabled",
+    "orientation"
+  ]);
+  const [value, setValue] = useControllableState(
+    defaultValue,
+    controlledValue,
+    onValueChange != null ? onValueChange : onChange
+  );
+  const generatedName = useReactId2().replace(/:/g, "");
+  const name = providedName != null ? providedName : `radio-group-${generatedName}`;
+  return /* @__PURE__ */ jsx5(
+    RadioGroupContext.Provider,
+    {
+      value: { name, value, setValue, disabled, orientation },
+      children: /* @__PURE__ */ jsx5("div", __spreadProps(__spreadValues({ role: "radiogroup", "aria-orientation": orientation }, props), { children }))
+    }
+  );
+}
+var Radio = forwardRef3(
+  (_a, ref) => {
+    var _b = _a, { value, disabled: itemDisabled, className } = _b, props = __objRest(_b, ["value", "disabled", "className"]);
+    const group = useRadioGroupContext();
+    if (!group) throw new Error("Radio must be used within RadioGroupRoot");
+    const {
+      name,
+      value: groupValue,
+      setValue,
+      disabled: groupDisabled
+    } = group;
+    const isDisabled = itemDisabled != null ? itemDisabled : groupDisabled;
+    const isChecked = groupValue === value;
+    const handleChange = useCallback9(() => {
+      if (!isDisabled) setValue(value);
+    }, [isDisabled, setValue, value]);
+    return /* @__PURE__ */ jsx5(
+      "input",
+      __spreadValues({
+        ref,
+        type: "radio",
+        name,
+        value,
+        checked: isChecked,
+        disabled: isDisabled,
+        onChange: handleChange,
+        className
+      }, props)
+    );
+  }
+);
+Radio.displayName = "Radio";
+
+// src/primitives/tooltip.tsx
+import React, {
+  createContext as createContext5,
+  useContext as useContext5,
+  useCallback as useCallback10,
+  useRef as useRef7,
+  useEffect as useEffect8,
+  useState as useState5,
+  forwardRef as forwardRef4
+} from "react";
+
+// src/internal/merge-props.ts
+var EVENT_HANDLER = /^on[A-Z]/;
+function mergeProps(...parts) {
+  const result = {};
+  for (const part of parts) {
+    if (!part) continue;
+    for (const key in part) {
+      if (!Object.prototype.hasOwnProperty.call(part, key)) continue;
+      const value = part[key];
+      const existing = result[key];
+      if (EVENT_HANDLER.test(key) && typeof value === "function" && typeof existing === "function") {
+        const a = existing;
+        const b = value;
+        result[key] = (...args) => {
+          a(...args);
+          return b(...args);
+        };
+      } else if (key === "className") {
+        const merged = [existing, value].filter(Boolean).join(" ");
+        result[key] = merged || void 0;
+      } else if (key === "style" && existing && typeof existing === "object" && value && typeof value === "object") {
+        result[key] = __spreadValues(__spreadValues({}, existing), value);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function mergeRefs(...refs) {
+  return (value) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    }
+  };
+}
+
+// src/internal/overlay-portal.tsx
+import { FloatingPortal } from "@floating-ui/react";
+import { Fragment, jsx as jsx6 } from "react/jsx-runtime";
+function OverlayPortal({
+  portal,
+  portalRoot,
+  children
+}) {
+  if (!portal) return /* @__PURE__ */ jsx6(Fragment, { children });
+  if (typeof portalRoot === "string") {
+    return /* @__PURE__ */ jsx6(FloatingPortal, { id: portalRoot, children });
+  }
+  return /* @__PURE__ */ jsx6(FloatingPortal, { root: portalRoot != null ? portalRoot : void 0, children });
+}
+
+// src/primitives/tooltip.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function mergeAriaDescribedBy(...values) {
+  const ids = values.flatMap(
+    (value) => typeof value === "string" ? value.trim().split(/\s+/) : []
+  );
+  const uniqueIds = [...new Set(ids.filter(Boolean))];
+  return uniqueIds.length > 0 ? uniqueIds.join(" ") : void 0;
+}
+var TooltipContext = createContext5(null);
+function useTooltipContext() {
+  const ctx = useContext5(TooltipContext);
+  if (!ctx)
+    throw new Error("Tooltip components must be used within TooltipProvider");
+  return ctx;
+}
+function TooltipProvider({
+  children,
+  timeout,
+  showTimeout = 700,
+  hideTimeout = 300,
+  placement = "top",
+  animated = true,
+  portal = false,
+  portalRoot = null
+}) {
+  const [open, setOpen] = useState5(false);
+  const tooltipId = useId();
+  const showDelay = timeout != null ? timeout : showTimeout;
+  const showTimerRef = useRef7(void 0);
+  const hideTimerRef = useRef7(void 0);
+  const { getReferenceProps: getFloatRefProps, getFloatingProps } = useFloating(
+    {
+      placement,
+      gutter: 8,
+      open
+    }
+  );
+  const show = useCallback10(() => {
+    clearTimeout(hideTimerRef.current);
+    showTimerRef.current = setTimeout(() => setOpen(true), showDelay);
+  }, [showDelay]);
+  const hide = useCallback10(() => {
+    clearTimeout(showTimerRef.current);
+    hideTimerRef.current = setTimeout(() => setOpen(false), hideTimeout);
+  }, [hideTimeout]);
+  useEffect8(() => {
+    return () => {
+      clearTimeout(showTimerRef.current);
+      clearTimeout(hideTimerRef.current);
+    };
+  }, []);
+  useEffect8(() => {
+    if (!open) return;
+    const handler = (e) => {
+      if (e.key === "Escape") {
+        clearTimeout(showTimerRef.current);
+        clearTimeout(hideTimerRef.current);
+        setOpen(false);
+      }
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [open]);
+  const getReferenceProps = useCallback10(() => {
+    return __spreadProps(__spreadValues({}, getFloatRefProps()), {
+      "aria-describedby": open ? tooltipId : void 0,
+      onMouseEnter: show,
+      onMouseLeave: hide,
+      onFocus: show,
+      onBlur: hide
+    });
+  }, [getFloatRefProps, open, tooltipId, show, hide]);
+  return /* @__PURE__ */ jsx7(
+    TooltipContext.Provider,
+    {
+      value: {
+        open,
+        setOpen,
+        tooltipId,
+        show,
+        hide,
+        animated,
+        portal,
+        portalRoot,
+        getReferenceProps,
+        getFloatingProps
+      },
+      children
+    }
+  );
+}
+var TooltipAnchor = forwardRef4(
+  (_a, ref) => {
+    var _b = _a, { children, render, "aria-describedby": ariaDescribedBy } = _b, props = __objRest(_b, ["children", "render", "aria-describedby"]);
+    const { getReferenceProps } = useTooltipContext();
+    const _a2 = getReferenceProps(), {
+      ref: referenceRef,
+      "aria-describedby": referenceDescribedBy
+    } = _a2, referenceProps = __objRest(_a2, [
+      "ref",
+      "aria-describedby"
+    ]);
+    if (render) {
+      const renderProps = render.props;
+      const renderRef = renderProps.ref;
+      const mergedProps2 = mergeProps(renderProps, props, referenceProps);
+      return React.cloneElement(render, __spreadProps(__spreadValues({}, mergedProps2), {
+        "aria-describedby": mergeAriaDescribedBy(
+          renderProps["aria-describedby"],
+          ariaDescribedBy,
+          referenceDescribedBy
+        ),
+        ref: mergeRefs(renderRef, ref, referenceRef)
+      }));
+    }
+    const mergedProps = mergeProps(props, referenceProps);
+    return /* @__PURE__ */ jsx7(
+      "div",
+      __spreadProps(__spreadValues({
+        ref: mergeRefs(
+          ref,
+          referenceRef
+        )
+      }, mergedProps), {
+        "aria-describedby": mergeAriaDescribedBy(
+          ariaDescribedBy,
+          referenceDescribedBy
+        ),
+        children
+      })
+    );
+  }
+);
+TooltipAnchor.displayName = "TooltipAnchor";
+function Tooltip(_a) {
+  var _b = _a, {
+    children,
+    onMouseEnter,
+    onMouseLeave
+  } = _b, props = __objRest(_b, [
+    "children",
+    "onMouseEnter",
+    "onMouseLeave"
+  ]);
+  const {
+    open,
+    tooltipId,
+    show,
+    hide,
+    animated,
+    portal,
+    portalRoot,
+    getFloatingProps
+  } = useTooltipContext();
+  const { mounted, dataAttributes, ref } = useEnterLeave(open, { animated });
+  const floatingProps = getFloatingProps();
+  if (!mounted) return null;
+  const node = /* @__PURE__ */ jsx7(
+    "div",
+    __spreadProps(__spreadValues(__spreadValues({
+      ref: (n) => {
+        ref.current = n;
+        if (floatingProps.ref && typeof floatingProps.ref === "function") {
+          floatingProps.ref(n);
+        }
+      },
+      id: tooltipId,
+      role: "tooltip",
+      style: floatingProps.style,
+      onMouseEnter: (e) => {
+        show();
+        onMouseEnter == null ? void 0 : onMouseEnter(e);
+      },
+      onMouseLeave: (e) => {
+        hide();
+        onMouseLeave == null ? void 0 : onMouseLeave(e);
+      }
+    }, dataAttributes), props), {
+      children
+    })
+  );
+  return /* @__PURE__ */ jsx7(OverlayPortal, { portal, portalRoot, children: node });
+}
+
+// src/primitives/popover.tsx
+import {
+  createContext as createContext6,
+  useContext as useContext6,
+  useCallback as useCallback11,
+  forwardRef as forwardRef5
+} from "react";
+import { FloatingFocusManager } from "@floating-ui/react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var PopoverContext = createContext6(null);
+function usePopoverContext() {
+  const ctx = useContext6(PopoverContext);
+  if (!ctx)
+    throw new Error("Popover components must be used within PopoverRoot");
+  return ctx;
+}
+function PopoverRoot({
+  children,
+  open: controlledOpen,
+  defaultOpen = false,
+  onOpenChange,
+  setOpen: setOpenDeprecated,
+  placement = "bottom-start",
+  manageFocus = false,
+  animated = true,
+  portal = false,
+  portalRoot = null
+}) {
+  const [open, setOpen] = useControllableState(
+    defaultOpen,
+    controlledOpen,
+    onOpenChange != null ? onOpenChange : setOpenDeprecated
+  );
+  const popoverId = useId();
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getPositionerStateProps,
+    context
+  } = useFloating({
+    placement,
+    gutter: 8,
+    open,
+    onOpenChange: setOpen,
+    dismiss: true
+  });
+  return /* @__PURE__ */ jsx8(
+    PopoverContext.Provider,
+    {
+      value: {
+        open,
+        setOpen,
+        popoverId,
+        manageFocus,
+        animated,
+        portal,
+        portalRoot,
+        getReferenceProps,
+        getFloatingProps,
+        getPositionerStateProps,
+        context
+      },
+      children
+    }
+  );
+}
+var PopoverTrigger = forwardRef5((_a, ref) => {
+  var _b = _a, { onClick } = _b, props = __objRest(_b, ["onClick"]);
+  const { open, setOpen, popoverId, getReferenceProps } = usePopoverContext();
+  const refProps = getReferenceProps();
+  const handleClick = useCallback11(
+    (e) => {
+      setOpen(!open);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [open, setOpen, onClick]
+  );
+  return /* @__PURE__ */ jsx8(
+    "button",
+    __spreadValues({
+      ref: (node) => {
+        if (refProps.ref && typeof refProps.ref === "function") {
+          refProps.ref(node);
+        }
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      type: "button",
+      "aria-expanded": open,
+      "aria-controls": open ? popoverId : void 0,
+      "data-popover-trigger": popoverId,
+      onClick: handleClick
+    }, props)
+  );
+});
+PopoverTrigger.displayName = "PopoverTrigger";
+function PopoverContent(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const {
+    open,
+    popoverId,
+    manageFocus,
+    animated,
+    portal,
+    portalRoot,
+    getFloatingProps,
+    getPositionerStateProps,
+    context
+  } = usePopoverContext();
+  const { ref, mounted, dataAttributes } = useEnterLeave(open, { animated });
+  const floatingProps = getFloatingProps();
+  if (!mounted) return null;
+  const node = /* @__PURE__ */ jsx8(
+    "div",
+    __spreadProps(__spreadValues(__spreadValues(__spreadValues({
+      ref: (n) => {
+        ref.current = n;
+        if (floatingProps.ref && typeof floatingProps.ref === "function") {
+          floatingProps.ref(n);
+        }
+      },
+      id: popoverId,
+      "data-popover-id": popoverId,
+      tabIndex: -1,
+      style: floatingProps.style
+    }, getPositionerStateProps(open)), dataAttributes), props), {
+      children
+    })
+  );
+  return /* @__PURE__ */ jsx8(OverlayPortal, { portal, portalRoot, children: manageFocus ? (
+    // Non-modal focus management: move focus into the panel on open, place
+    // tab guards for correct tab-out continuity (incl. the VoiceOver/WebKit
+    // workaround), and return focus to the trigger on close.
+    /* @__PURE__ */ jsx8(FloatingFocusManager, { context, modal: false, returnFocus: true, children: node })
+  ) : node });
+}
+var PopoverClose = forwardRef5(
+  (_a, ref) => {
+    var _b = _a, { onClick } = _b, props = __objRest(_b, ["onClick"]);
+    const { setOpen } = usePopoverContext();
+    const handleClick = useCallback11(
+      (e) => {
+        setOpen(false);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [setOpen, onClick]
+    );
+    return /* @__PURE__ */ jsx8("button", __spreadValues({ ref, type: "button", onClick: handleClick }, props));
+  }
+);
+PopoverClose.displayName = "PopoverClose";
+
+// src/primitives/select.tsx
+import {
+  createContext as createContext7,
+  useContext as useContext7,
+  useCallback as useCallback12,
+  useEffect as useEffect9,
+  useLayoutEffect as useLayoutEffect2,
+  useMemo as useMemo2,
+  useRef as useRef8,
+  useState as useState6,
+  forwardRef as forwardRef6
+} from "react";
+import { jsx as jsx9, jsxs } from "react/jsx-runtime";
+function firstEnabledId(items) {
+  var _a, _b;
+  return (_b = (_a = items.find((i) => !i.disabled)) == null ? void 0 : _a.id) != null ? _b : null;
+}
+function moveActiveId(items, activeId, delta) {
+  const enabled = items.filter((i) => !i.disabled);
+  if (enabled.length === 0) return null;
+  const idx = enabled.findIndex((i) => i.id === activeId);
+  if (idx < 0) {
+    return delta > 0 ? enabled[0].id : enabled[enabled.length - 1].id;
+  }
+  const next = Math.min(enabled.length - 1, Math.max(0, idx + delta));
+  return enabled[next].id;
+}
+var SelectContext = createContext7(null);
+function useSelectContext() {
+  const ctx = useContext7(SelectContext);
+  if (!ctx) throw new Error("Select components must be used within SelectRoot");
+  return ctx;
+}
+function SelectRoot({
+  children,
+  value: controlledValue,
+  defaultValue,
+  onValueChange,
+  setValue: setValueDeprecated,
+  multiple = false,
+  name,
+  open: controlledOpen,
+  onOpenChange,
+  setOpen: setOpenDeprecated,
+  animated = true,
+  portal = false,
+  portalRoot = null
+}) {
+  var _a;
+  const normalizedDefault = defaultValue != null ? defaultValue : multiple ? [] : "";
+  const [value, setValue] = useControllableState(
+    normalizedDefault,
+    controlledValue,
+    onValueChange != null ? onValueChange : setValueDeprecated
+  );
+  const [open, setOpenState] = useState6(controlledOpen != null ? controlledOpen : false);
+  const onOpenChangeCb = onOpenChange != null ? onOpenChange : setOpenDeprecated;
+  const [activeId, setActiveId] = useState6(null);
+  const selectId = useId();
+  const listboxId = `${selectId}-listbox`;
+  const items = useRef8([]);
+  useEffect9(() => {
+    if (controlledOpen !== void 0) setOpenState(controlledOpen);
+  }, [controlledOpen]);
+  const setOpen = useCallback12(
+    (v) => {
+      if (controlledOpen === void 0) setOpenState(v);
+      onOpenChangeCb == null ? void 0 : onOpenChangeCb(v);
+      if (!v) setActiveId(null);
+    },
+    [controlledOpen, onOpenChangeCb]
+  );
+  const selectedValues = useMemo2(
+    () => Array.isArray(value) ? value : value === "" ? [] : [value],
+    [value]
+  );
+  const isSelected = useCallback12(
+    (v) => selectedValues.includes(v),
+    [selectedValues]
+  );
+  const selectValue = useCallback12(
+    (v) => {
+      if (multiple) {
+        const arr = Array.isArray(value) ? value : value ? [value] : [];
+        setValue(arr.includes(v) ? arr.filter((x) => x !== v) : [...arr, v]);
+      } else {
+        setValue(v);
+        setOpen(false);
+      }
+    },
+    [multiple, value, setValue, setOpen]
+  );
+  const registerItem = useCallback12((entry) => {
+    const list = items.current;
+    const existing = list.findIndex((i) => i.id === entry.id);
+    if (existing >= 0) list[existing] = entry;
+    else list.push(entry);
+  }, []);
+  const unregisterItem = useCallback12((id) => {
+    items.current = items.current.filter((i) => i.id !== id);
+  }, []);
+  const { getReferenceProps, getFloatingProps } = useFloating({
+    placement: "bottom-start",
+    gutter: 4,
+    sameWidth: true,
+    open,
+    onOpenChange: setOpen,
+    dismiss: { outsidePress: true, escapeKey: false }
+  });
+  return /* @__PURE__ */ jsxs(
+    SelectContext.Provider,
+    {
+      value: {
+        open,
+        setOpen,
+        value,
+        selectedValues,
+        multiple,
+        isSelected,
+        selectValue,
+        activeId,
+        setActiveId,
+        selectId,
+        listboxId,
+        getReferenceProps,
+        getFloatingProps,
+        items,
+        registerItem,
+        unregisterItem,
+        animated,
+        portal,
+        portalRoot
+      },
+      children: [
+        children,
+        name && (multiple ? selectedValues.map((v) => /* @__PURE__ */ jsx9("input", { type: "hidden", name, value: v }, v)) : /* @__PURE__ */ jsx9("input", { type: "hidden", name, value: (_a = selectedValues[0]) != null ? _a : "" }))
+      ]
+    }
+  );
+}
+function SelectLabel(props) {
+  const { selectId } = useSelectContext();
+  return /* @__PURE__ */ jsx9("label", __spreadValues({ htmlFor: selectId }, props));
+}
+var SelectTrigger = forwardRef6(
+  (_a, ref) => {
+    var _b = _a, { onClick, onKeyDown, children } = _b, props = __objRest(_b, ["onClick", "onKeyDown", "children"]);
+    var _a2;
+    const {
+      open,
+      setOpen,
+      selectedValues,
+      multiple,
+      selectValue,
+      selectId,
+      listboxId,
+      getReferenceProps,
+      items,
+      activeId,
+      setActiveId
+    } = useSelectContext();
+    const refProps = getReferenceProps();
+    const typeahead = useRef8({
+      buffer: "",
+      timer: 0
+    });
+    const selectActive = useCallback12(() => {
+      const item = items.current.find((i) => i.id === activeId);
+      if (item && !item.disabled) {
+        selectValue(item.value);
+      }
+    }, [items, activeId, selectValue]);
+    const runTypeahead = useCallback12(
+      (char) => {
+        const t = typeahead.current;
+        window.clearTimeout(t.timer);
+        t.buffer += char.toLowerCase();
+        t.timer = window.setTimeout(() => {
+          t.buffer = "";
+        }, 500);
+        const match = items.current.filter((i) => !i.disabled).find(
+          (i) => {
+            var _a3, _b2;
+            return (_b2 = (_a3 = document.getElementById(i.id)) == null ? void 0 : _a3.textContent) == null ? void 0 : _b2.trim().toLowerCase().startsWith(t.buffer);
+          }
+        );
+        if (match) setActiveId(match.id);
+      },
+      [items, setActiveId]
+    );
+    const handleClick = useCallback12(
+      (e) => {
+        setOpen(!open);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [open, setOpen, onClick]
+    );
+    const handleKeyDown2 = useCallback12(
+      (e) => {
+        var _a3, _b2;
+        switch (e.key) {
+          case "ArrowDown":
+            e.preventDefault();
+            if (!open) setOpen(true);
+            else setActiveId(moveActiveId(items.current, activeId, 1));
+            break;
+          case "ArrowUp":
+            e.preventDefault();
+            if (!open) setOpen(true);
+            else setActiveId(moveActiveId(items.current, activeId, -1));
+            break;
+          case "Home":
+            if (open) {
+              e.preventDefault();
+              setActiveId(firstEnabledId(items.current));
+            }
+            break;
+          case "End":
+            if (open) {
+              e.preventDefault();
+              const enabled = items.current.filter((i) => !i.disabled);
+              setActiveId((_b2 = (_a3 = enabled[enabled.length - 1]) == null ? void 0 : _a3.id) != null ? _b2 : null);
+            }
+            break;
+          case "Enter":
+          case " ":
+            e.preventDefault();
+            if (open) selectActive();
+            else setOpen(true);
+            break;
+          case "Escape":
+            if (open) {
+              e.preventDefault();
+              setOpen(false);
+            }
+            break;
+          default:
+            if (open && e.key.length === 1 && e.key !== " " && !e.metaKey && !e.ctrlKey && !e.altKey && !e.nativeEvent.isComposing) {
+              runTypeahead(e.key);
+            }
+        }
+        onKeyDown == null ? void 0 : onKeyDown(e);
+      },
+      [
+        open,
+        items,
+        activeId,
+        setActiveId,
+        setOpen,
+        selectActive,
+        runTypeahead,
+        onKeyDown
+      ]
+    );
+    return /* @__PURE__ */ jsx9(
+      "button",
+      __spreadProps(__spreadValues({
+        ref: (node) => {
+          if (refProps.ref && typeof refProps.ref === "function") {
+            refProps.ref(node);
+          }
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        type: "button",
+        id: selectId,
+        role: "combobox",
+        "aria-expanded": open,
+        "aria-haspopup": "listbox",
+        "aria-controls": open ? listboxId : void 0,
+        "aria-activedescendant": open ? activeId != null ? activeId : void 0 : void 0,
+        "data-select-trigger": selectId,
+        onClick: handleClick,
+        onKeyDown: handleKeyDown2
+      }, props), {
+        children: children != null ? children : multiple ? selectedValues.join(", ") : (_a2 = selectedValues[0]) != null ? _a2 : ""
+      })
+    );
+  }
+);
+SelectTrigger.displayName = "SelectTrigger";
+function SelectPopover(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const {
+    open,
+    multiple,
+    selectedValues,
+    listboxId,
+    selectId,
+    getFloatingProps,
+    items,
+    activeId,
+    setActiveId,
+    animated,
+    portal,
+    portalRoot
+  } = useSelectContext();
+  const { ref, mounted, dataAttributes } = useEnterLeave(open, { animated });
+  const floatingProps = getFloatingProps();
+  useLayoutEffect2(() => {
+    if (mounted) {
+      setActiveId((prev) => {
+        var _a2;
+        if (prev) return prev;
+        const selected = items.current.find(
+          (i) => selectedValues.includes(i.value)
+        );
+        return (_a2 = selected == null ? void 0 : selected.id) != null ? _a2 : firstEnabledId(items.current);
+      });
+    }
+  }, [mounted, items, selectedValues, setActiveId]);
+  useScrollActiveDescendantIntoView(activeId);
+  if (!mounted) return null;
+  const node = /* @__PURE__ */ jsx9(
+    "div",
+    __spreadProps(__spreadValues(__spreadValues({
+      ref: (n) => {
+        ref.current = n;
+        if (floatingProps.ref && typeof floatingProps.ref === "function") {
+          floatingProps.ref(n);
+        }
+      },
+      id: listboxId,
+      role: "listbox",
+      "aria-multiselectable": multiple || void 0,
+      "aria-activedescendant": activeId != null ? activeId : void 0,
+      "data-select-id": selectId,
+      style: floatingProps.style
+    }, dataAttributes), props), {
+      children
+    })
+  );
+  return /* @__PURE__ */ jsx9(OverlayPortal, { portal, portalRoot, children: node });
+}
+function SelectItem(_a) {
+  var _b = _a, {
+    value: itemValue,
+    disabled,
+    onClick,
+    children
+  } = _b, props = __objRest(_b, [
+    "value",
+    "disabled",
+    "onClick",
+    "children"
+  ]);
+  const {
+    isSelected: isValueSelected,
+    selectValue,
+    activeId,
+    setActiveId,
+    registerItem,
+    unregisterItem
+  } = useSelectContext();
+  const itemId = useId();
+  const isSelected = isValueSelected(itemValue);
+  const isActive = activeId === itemId;
+  useLayoutEffect2(() => {
+    registerItem({ id: itemId, value: itemValue, disabled });
+    return () => unregisterItem(itemId);
+  }, [itemId, itemValue, disabled, registerItem, unregisterItem]);
+  const handleClick = useCallback12(
+    (e) => {
+      if (!disabled) {
+        selectValue(itemValue);
+      }
+      onClick == null ? void 0 : onClick(e);
+    },
+    [disabled, itemValue, selectValue, onClick]
+  );
+  return /* @__PURE__ */ jsx9(
+    "div",
+    __spreadProps(__spreadValues({
+      id: itemId,
+      role: "option",
+      "aria-selected": isSelected,
+      "aria-disabled": disabled || void 0,
+      "data-active-item": isActive ? "" : void 0,
+      "data-disabled": disabled ? "" : void 0,
+      onClick: handleClick,
+      onMouseEnter: () => {
+        if (!disabled) setActiveId(itemId);
+      }
+    }, props), {
+      children: children != null ? children : itemValue
+    })
+  );
+}
+
+// src/primitives/combobox.tsx
+import {
+  createContext as createContext8,
+  useContext as useContext8,
+  useCallback as useCallback13,
+  useEffect as useEffect10,
+  useLayoutEffect as useLayoutEffect3,
+  useMemo as useMemo3,
+  useRef as useRef9,
+  useState as useState7,
+  useSyncExternalStore,
+  forwardRef as forwardRef7
+} from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function firstEnabledId2(items) {
+  var _a, _b;
+  return (_b = (_a = items.find((i) => !i.disabled)) == null ? void 0 : _a.id) != null ? _b : null;
+}
+function moveActiveId2(items, activeId, delta) {
+  const enabled = items.filter((i) => !i.disabled);
+  if (enabled.length === 0) return null;
+  const idx = enabled.findIndex((i) => i.id === activeId);
+  if (idx < 0) {
+    return delta > 0 ? enabled[0].id : enabled[enabled.length - 1].id;
+  }
+  const next = Math.min(enabled.length - 1, Math.max(0, idx + delta));
+  return enabled[next].id;
+}
+function createComboboxStore(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    getState: () => state,
+    setState: (partial) => {
+      const next = __spreadValues(__spreadValues({}, state), partial);
+      if (next.value === state.value && next.searchValue === state.searchValue && next.activeId === state.activeId && next.open === state.open) {
+        return;
+      }
+      state = next;
+      listeners.forEach((l) => l());
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+var ComboboxStoreContext = createContext8(
+  null
+);
+function useComboboxStoreContext() {
+  const ctx = useContext8(ComboboxStoreContext);
+  if (!ctx)
+    throw new Error("Combobox components must be used within ComboboxRoot");
+  return ctx;
+}
+function useComboboxSelector(selector) {
+  const { store } = useComboboxStoreContext();
+  return useSyncExternalStore(
+    store.subscribe,
+    () => selector(store.getState()),
+    () => selector(store.getState())
+  );
+}
+var ComboboxFloatingContext = createContext8(null);
+function useComboboxFloating() {
+  const ctx = useContext8(ComboboxFloatingContext);
+  if (!ctx)
+    throw new Error("Combobox components must be used within ComboboxRoot");
+  return ctx;
+}
+function ComboboxRoot({
+  children,
+  value: controlledValue,
+  defaultValue = "",
+  onValueChange,
+  setValue: setValueDeprecated,
+  open: controlledOpen,
+  onOpenChange,
+  setOpen: setOpenDeprecated,
+  animated = true,
+  portal = false,
+  portalRoot = null
+}) {
+  const comboboxId = useId();
+  const listboxId = `${comboboxId}-listbox`;
+  const items = useRef9([]);
+  const [store] = useState7(
+    () => createComboboxStore({
+      value: controlledValue != null ? controlledValue : defaultValue,
+      searchValue: "",
+      activeId: null,
+      open: controlledOpen != null ? controlledOpen : false
+    })
+  );
+  const propsRef = useRef9({
+    controlledValue,
+    controlledOpen,
+    onValueChange: onValueChange != null ? onValueChange : setValueDeprecated,
+    onOpenChange: onOpenChange != null ? onOpenChange : setOpenDeprecated
+  });
+  propsRef.current = {
+    controlledValue,
+    controlledOpen,
+    onValueChange: onValueChange != null ? onValueChange : setValueDeprecated,
+    onOpenChange: onOpenChange != null ? onOpenChange : setOpenDeprecated
+  };
+  useEffect10(() => {
+    if (controlledValue !== void 0)
+      store.setState({ value: controlledValue });
+  }, [controlledValue, store]);
+  useEffect10(() => {
+    if (controlledOpen !== void 0) store.setState({ open: controlledOpen });
+  }, [controlledOpen, store]);
+  const actions = useMemo3(
+    () => ({
+      setValue: (v) => {
+        var _a;
+        const p = propsRef.current;
+        if (p.controlledValue === void 0) store.setState({ value: v });
+        (_a = p.onValueChange) == null ? void 0 : _a.call(p, v);
+      },
+      setOpen: (v) => {
+        var _a;
+        const p = propsRef.current;
+        if (p.controlledOpen === void 0) store.setState({ open: v });
+        (_a = p.onOpenChange) == null ? void 0 : _a.call(p, v);
+        if (!v) store.setState({ activeId: null });
+      },
+      setSearchValue: (v) => store.setState({ searchValue: v }),
+      setActiveId: (updater) => {
+        const cur = store.getState().activeId;
+        const next = typeof updater === "function" ? updater(cur) : updater;
+        store.setState({ activeId: next });
+      }
+    }),
+    [store]
+  );
+  const registerItem = useCallback13((entry) => {
+    const list = items.current;
+    const existing = list.findIndex((i) => i.id === entry.id);
+    if (existing >= 0) list[existing] = entry;
+    else list.push(entry);
+  }, []);
+  const unregisterItem = useCallback13((id) => {
+    items.current = items.current.filter((i) => i.id !== id);
+  }, []);
+  const open = useSyncExternalStore(
+    store.subscribe,
+    () => store.getState().open,
+    () => store.getState().open
+  );
+  const { getReferenceProps, getFloatingProps } = useFloating({
+    placement: "bottom-start",
+    gutter: 4,
+    sameWidth: true,
+    lazyFlip: true,
+    open,
+    onOpenChange: actions.setOpen,
+    dismiss: { outsidePress: true, escapeKey: false }
+  });
+  const storeContext = useMemo3(
+    () => ({
+      store,
+      actions,
+      comboboxId,
+      listboxId,
+      items,
+      registerItem,
+      unregisterItem
+    }),
+    [store, actions, comboboxId, listboxId, registerItem, unregisterItem]
+  );
+  const floatingContext = useMemo3(
+    () => ({
+      getReferenceProps,
+      getFloatingProps,
+      animated,
+      portal,
+      portalRoot
+    }),
+    [getReferenceProps, getFloatingProps, animated, portal, portalRoot]
+  );
+  return /* @__PURE__ */ jsx10(ComboboxStoreContext.Provider, { value: storeContext, children: /* @__PURE__ */ jsx10(ComboboxFloatingContext.Provider, { value: floatingContext, children }) });
+}
+var ComboboxInput = forwardRef7(
+  (_a, ref) => {
+    var _b = _a, { onKeyDown } = _b, props = __objRest(_b, ["onKeyDown"]);
+    const { actions, comboboxId, listboxId, items } = useComboboxStoreContext();
+    const { getReferenceProps } = useComboboxFloating();
+    const open = useComboboxSelector((s) => s.open);
+    const searchValue = useComboboxSelector((s) => s.searchValue);
+    const activeId = useComboboxSelector((s) => s.activeId);
+    const refProps = getReferenceProps();
+    useScrollActiveDescendantIntoView(activeId);
+    const handleChange = useCallback13(
+      (e) => {
+        actions.setSearchValue(e.target.value);
+        if (!open) actions.setOpen(true);
+        actions.setActiveId(null);
+      },
+      [actions, open]
+    );
+    const selectActive = useCallback13(() => {
+      const item = items.current.find((i) => i.id === activeId);
+      if (item && !item.disabled) {
+        actions.setValue(item.value);
+        actions.setSearchValue(item.value);
+        actions.setOpen(false);
+      }
+    }, [items, activeId, actions]);
+    const handleKeyDown2 = useCallback13(
+      (e) => {
+        if (e.nativeEvent.isComposing) {
+          onKeyDown == null ? void 0 : onKeyDown(e);
+          return;
+        }
+        switch (e.key) {
+          case "ArrowDown":
+            e.preventDefault();
+            if (!open) actions.setOpen(true);
+            actions.setActiveId(moveActiveId2(items.current, activeId, 1));
+            break;
+          case "ArrowUp":
+            e.preventDefault();
+            if (!open) actions.setOpen(true);
+            actions.setActiveId(moveActiveId2(items.current, activeId, -1));
+            break;
+          case "Enter":
+            if (open && activeId) {
+              e.preventDefault();
+              selectActive();
+            }
+            break;
+          case "Escape":
+            if (open) {
+              e.preventDefault();
+              actions.setOpen(false);
+            }
+            break;
+        }
+        onKeyDown == null ? void 0 : onKeyDown(e);
+      },
+      [open, actions, activeId, items, selectActive, onKeyDown]
+    );
+    return /* @__PURE__ */ jsx10(
+      "input",
+      __spreadValues({
+        ref: (node) => {
+          if (refProps.ref && typeof refProps.ref === "function") {
+            refProps.ref(node);
+          }
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        type: "text",
+        role: "combobox",
+        id: comboboxId,
+        "aria-expanded": open,
+        "aria-autocomplete": "list",
+        "aria-controls": open ? listboxId : void 0,
+        "aria-activedescendant": open ? activeId != null ? activeId : void 0 : void 0,
+        "data-combobox-input": comboboxId,
+        value: searchValue,
+        onChange: handleChange,
+        onKeyDown: handleKeyDown2
+      }, props)
+    );
+  }
+);
+ComboboxInput.displayName = "ComboboxInput";
+function ComboboxPopover(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const { actions, comboboxId, listboxId, items } = useComboboxStoreContext();
+  const { getFloatingProps, animated, portal, portalRoot } = useComboboxFloating();
+  const open = useComboboxSelector((s) => s.open);
+  const { ref, mounted, dataAttributes } = useEnterLeave(open, { animated });
+  const floatingProps = getFloatingProps();
+  useLayoutEffect3(() => {
+    if (mounted) {
+      actions.setActiveId((prev) => prev != null ? prev : firstEnabledId2(items.current));
+    }
+  }, [mounted, items, actions]);
+  if (!mounted) return null;
+  const node = /* @__PURE__ */ jsx10(
+    "div",
+    __spreadProps(__spreadValues(__spreadValues({
+      ref: (n) => {
+        ref.current = n;
+        if (floatingProps.ref && typeof floatingProps.ref === "function") {
+          floatingProps.ref(n);
+        }
+      },
+      id: listboxId,
+      role: "listbox",
+      "data-combobox-id": comboboxId,
+      style: floatingProps.style
+    }, dataAttributes), props), {
+      children
+    })
+  );
+  return /* @__PURE__ */ jsx10(OverlayPortal, { portal, portalRoot, children: node });
+}
+function ComboboxItem(_a) {
+  var _b = _a, {
+    value: itemValue,
+    disabled,
+    onClick,
+    children
+  } = _b, props = __objRest(_b, [
+    "value",
+    "disabled",
+    "onClick",
+    "children"
+  ]);
+  const { actions, registerItem, unregisterItem } = useComboboxStoreContext();
+  const itemId = useId();
+  const isSelected = useComboboxSelector((s) => s.value === itemValue);
+  const isActive = useComboboxSelector((s) => s.activeId === itemId);
+  useLayoutEffect3(() => {
+    registerItem({ id: itemId, value: itemValue, disabled });
+    return () => unregisterItem(itemId);
+  }, [itemId, itemValue, disabled, registerItem, unregisterItem]);
+  const handleClick = useCallback13(
+    (e) => {
+      if (!disabled) {
+        actions.setValue(itemValue);
+        actions.setSearchValue(itemValue);
+        actions.setOpen(false);
+      }
+      onClick == null ? void 0 : onClick(e);
+    },
+    [disabled, itemValue, actions, onClick]
+  );
+  return /* @__PURE__ */ jsx10(
+    "div",
+    __spreadProps(__spreadValues({
+      id: itemId,
+      role: "option",
+      "aria-selected": isSelected,
+      "aria-disabled": disabled || void 0,
+      "data-active-item": isActive ? "" : void 0,
+      "data-disabled": disabled ? "" : void 0,
+      onClick: handleClick,
+      onMouseEnter: () => {
+        if (!disabled) actions.setActiveId(itemId);
+      }
+    }, props), {
+      children: children != null ? children : itemValue
+    })
+  );
+}
+var ComboboxGroupContext = createContext8(
+  null
+);
+function ComboboxGroup(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const labelId = useId();
+  return /* @__PURE__ */ jsx10(ComboboxGroupContext.Provider, { value: { labelId }, children: /* @__PURE__ */ jsx10("div", __spreadProps(__spreadValues({ role: "group", "aria-labelledby": labelId }, props), { children })) });
+}
+function ComboboxGroupLabel(props) {
+  const ctx = useContext8(ComboboxGroupContext);
+  return /* @__PURE__ */ jsx10("div", __spreadValues({ id: ctx == null ? void 0 : ctx.labelId }, props));
+}
+
+// src/primitives/command.tsx
+import {
+  createContext as createContext9,
+  forwardRef as forwardRef8,
+  useCallback as useCallback14,
+  useContext as useContext9,
+  useEffect as useEffect11,
+  useLayoutEffect as useLayoutEffect4,
+  useMemo as useMemo4,
+  useRef as useRef10,
+  useState as useState8
+} from "react";
+import { jsx as jsx11, jsxs as jsxs2 } from "react/jsx-runtime";
+var CommandContext = createContext9(null);
+function useCommandContext() {
+  const ctx = useContext9(CommandContext);
+  if (!ctx)
+    throw new Error("Command components must be used within CommandRoot");
+  return ctx;
+}
+function defaultFilter(value, search, keywords) {
+  if (!search) return true;
+  const needle = search.toLowerCase();
+  if (value.toLowerCase().includes(needle)) return true;
+  return keywords.some((k) => k.toLowerCase().includes(needle));
+}
+function CommandRoot(_a) {
+  var _b = _a, {
+    children,
+    value: controlledValue,
+    defaultValue = "",
+    onValueChange,
+    shouldFilter = true,
+    filter = defaultFilter,
+    onEscape
+  } = _b, props = __objRest(_b, [
+    "children",
+    "value",
+    "defaultValue",
+    "onValueChange",
+    "shouldFilter",
+    "filter",
+    "onEscape"
+  ]);
+  const [value, setValue] = useControllableState(
+    defaultValue,
+    controlledValue,
+    onValueChange
+  );
+  const [search, setSearch] = useState8("");
+  const [activeValue, setActiveValue] = useState8("");
+  const itemsRef = useRef10(/* @__PURE__ */ new Map());
+  const [version, setVersion] = useState8(0);
+  const baseId = useId();
+  const bumpVersion = useCallback14(() => setVersion((v) => v + 1), []);
+  const visibleValues = useMemo4(() => {
+    const result = [];
+    for (const [, ref] of itemsRef.current) {
+      const item = ref.current;
+      if (!shouldFilter || filter(item.value, search, item.keywords)) {
+        result.push(item.value);
+      }
+    }
+    return result;
+  }, [search, shouldFilter, filter, version]);
+  useEffect11(() => {
+    const enabled = visibleValues.filter((v) => {
+      for (const [, ref] of itemsRef.current) {
+        if (ref.current.value === v) return !ref.current.disabled;
+      }
+      return true;
+    });
+    if (enabled.length === 0) {
+      if (activeValue) setActiveValue("");
+      return;
+    }
+    if (!enabled.includes(activeValue) && enabled[0]) {
+      setActiveValue(enabled[0]);
+    }
+  }, [visibleValues, activeValue]);
+  const activeId = useMemo4(() => {
+    for (const [id, ref] of itemsRef.current) {
+      if (ref.current.value === activeValue) return id;
+    }
+    return void 0;
+  }, [activeValue, version]);
+  const ctx = useMemo4(
+    () => ({
+      search,
+      setSearch,
+      value,
+      setValue,
+      activeValue,
+      setActiveValue,
+      itemsRef,
+      bumpVersion,
+      shouldFilter,
+      filter,
+      visibleValues,
+      activeId,
+      onEscape,
+      inputId: `${baseId}-input`,
+      listId: `${baseId}-list`
+    }),
+    [
+      search,
+      value,
+      setValue,
+      activeValue,
+      bumpVersion,
+      shouldFilter,
+      filter,
+      visibleValues,
+      activeId,
+      onEscape,
+      baseId
+    ]
+  );
+  return /* @__PURE__ */ jsx11(CommandContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx11("div", __spreadProps(__spreadValues({ "data-slot": "command" }, props), { children })) });
+}
+var CommandInput = forwardRef8(
+  function CommandInput2(_a, ref) {
+    var _b = _a, { onKeyDown, onValueChange, value: controlledValue } = _b, props = __objRest(_b, ["onKeyDown", "onValueChange", "value"]);
+    const ctx = useCommandContext();
+    const value = controlledValue != null ? controlledValue : ctx.search;
+    useScrollActiveDescendantIntoView(ctx.activeId);
+    const navigableValues = useCallback14(() => {
+      const disabled = /* @__PURE__ */ new Set();
+      for (const [, r] of ctx.itemsRef.current) {
+        if (r.current.disabled) disabled.add(r.current.value);
+      }
+      return ctx.visibleValues.filter((v) => !disabled.has(v));
+    }, [ctx]);
+    const handleKeyDown2 = useCallback14(
+      (e) => {
+        var _a2, _b2, _c;
+        if (e.nativeEvent.isComposing) {
+          onKeyDown == null ? void 0 : onKeyDown(e);
+          return;
+        }
+        const vals = navigableValues();
+        const idx = vals.indexOf(ctx.activeValue);
+        switch (e.key) {
+          case "ArrowDown": {
+            e.preventDefault();
+            const next = vals[Math.min(idx + 1, vals.length - 1)];
+            if (next) ctx.setActiveValue(next);
+            break;
+          }
+          case "ArrowUp": {
+            e.preventDefault();
+            const prev = vals[Math.max(idx - 1, 0)];
+            if (prev) ctx.setActiveValue(prev);
+            break;
+          }
+          case "Home": {
+            if (vals[0]) {
+              e.preventDefault();
+              ctx.setActiveValue(vals[0]);
+            }
+            break;
+          }
+          case "End": {
+            const last = vals[vals.length - 1];
+            if (last) {
+              e.preventDefault();
+              ctx.setActiveValue(last);
+            }
+            break;
+          }
+          case "Enter": {
+            if (ctx.activeValue && vals.includes(ctx.activeValue)) {
+              e.preventDefault();
+              ctx.setValue(ctx.activeValue);
+              for (const [, r] of ctx.itemsRef.current) {
+                if (r.current.value === ctx.activeValue) {
+                  (_b2 = (_a2 = r.current).onSelect) == null ? void 0 : _b2.call(_a2, ctx.activeValue);
+                  break;
+                }
+              }
+            }
+            break;
+          }
+          case "Escape": {
+            (_c = ctx.onEscape) == null ? void 0 : _c.call(ctx);
+            break;
+          }
+        }
+        onKeyDown == null ? void 0 : onKeyDown(e);
+      },
+      [ctx, navigableValues, onKeyDown]
+    );
+    return /* @__PURE__ */ jsx11(
+      "input",
+      __spreadValues({
+        ref,
+        type: "text",
+        role: "combobox",
+        id: ctx.inputId,
+        "aria-expanded": true,
+        "aria-autocomplete": "list",
+        "aria-controls": ctx.listId,
+        "aria-activedescendant": ctx.activeId,
+        autoCorrect: "off",
+        autoComplete: "off",
+        spellCheck: false,
+        value,
+        onChange: (e) => {
+          ctx.setSearch(e.target.value);
+          onValueChange == null ? void 0 : onValueChange(e.target.value);
+        },
+        onKeyDown: handleKeyDown2
+      }, props)
+    );
+  }
+);
+function CommandList(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const ctx = useCommandContext();
+  return /* @__PURE__ */ jsx11("div", __spreadProps(__spreadValues({ role: "listbox", id: ctx.listId, "data-slot": "command-list" }, props), { children }));
+}
+function CommandEmpty(_a) {
+  var _b = _a, { children } = _b, props = __objRest(_b, ["children"]);
+  const ctx = useCommandContext();
+  if (ctx.visibleValues.length > 0) return null;
+  return /* @__PURE__ */ jsx11("div", __spreadProps(__spreadValues({ role: "presentation", "data-slot": "command-empty" }, props), { children }));
+}
+function CommandGroup(_a) {
+  var _b = _a, {
+    heading,
+    children
+  } = _b, props = __objRest(_b, [
+    "heading",
+    "children"
+  ]);
+  const headingId = useId();
+  const hasHeading = heading != null;
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    __spreadProps(__spreadValues({
+      role: "group",
+      "data-slot": "command-group",
+      "aria-labelledby": hasHeading ? headingId : void 0
+    }, props), {
+      children: [
+        hasHeading && /* @__PURE__ */ jsx11(
+          "div",
+          {
+            id: headingId,
+            "data-slot": "command-group-heading",
+            role: "presentation",
+            children: heading
+          }
+        ),
+        /* @__PURE__ */ jsx11("div", { "data-slot": "command-group-items", children })
+      ]
+    })
+  );
+}
+function CommandSeparator(props) {
+  return /* @__PURE__ */ jsx11("div", __spreadValues({ role: "separator", "data-slot": "command-separator" }, props));
+}
+var CommandItem = forwardRef8(
+  function CommandItem2(_a, ref) {
+    var _b = _a, {
+      value,
+      keywords,
+      disabled,
+      onSelect,
+      onClick,
+      onMouseEnter,
+      children
+    } = _b, props = __objRest(_b, [
+      "value",
+      "keywords",
+      "disabled",
+      "onSelect",
+      "onClick",
+      "onMouseEnter",
+      "children"
+    ]);
+    const ctx = useCommandContext();
+    const itemId = useId();
+    const metaRef = useRef10({
+      value,
+      keywords: keywords != null ? keywords : [],
+      disabled: Boolean(disabled),
+      onSelect
+    });
+    metaRef.current = {
+      value,
+      keywords: keywords != null ? keywords : [],
+      disabled: Boolean(disabled),
+      onSelect
+    };
+    const { itemsRef, bumpVersion } = ctx;
+    useLayoutEffect4(() => {
+      const map = itemsRef.current;
+      map.set(itemId, metaRef);
+      bumpVersion();
+      return () => {
+        map.delete(itemId);
+        bumpVersion();
+      };
+    }, [itemId, itemsRef, bumpVersion]);
+    useEffect11(() => {
+      bumpVersion();
+    }, [value, disabled, bumpVersion]);
+    const visible = !ctx.shouldFilter || ctx.filter(value, ctx.search, keywords != null ? keywords : []);
+    if (!visible) return null;
+    const isActive = ctx.activeValue === value;
+    return /* @__PURE__ */ jsx11(
+      "div",
+      __spreadProps(__spreadValues({
+        ref,
+        role: "option",
+        id: itemId,
+        "aria-selected": isActive || void 0,
+        "aria-disabled": disabled || void 0,
+        "data-active-item": isActive ? "" : void 0,
+        "data-disabled": disabled ? "" : void 0,
+        "data-value": value,
+        "data-slot": "command-item",
+        onClick: (e) => {
+          if (disabled) return;
+          ctx.setValue(value);
+          onSelect == null ? void 0 : onSelect(value);
+          onClick == null ? void 0 : onClick(e);
+        },
+        onMouseEnter: (e) => {
+          if (!disabled) ctx.setActiveValue(value);
+          onMouseEnter == null ? void 0 : onMouseEnter(e);
+        }
+      }, props), {
+        children
+      })
+    );
+  }
+);
+function useCommandState() {
+  const { search, value, activeValue, visibleValues } = useCommandContext();
+  return { search, value, activeValue, visibleValues };
+}
+
+// src/primitives/menu.tsx
+import {
+  createContext as createContext10,
+  useContext as useContext10,
+  useCallback as useCallback15,
+  useEffect as useEffect12,
+  useLayoutEffect as useLayoutEffect5,
+  useRef as useRef11,
+  useState as useState9,
+  forwardRef as forwardRef9
+} from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+function firstEnabledId3(items) {
+  var _a, _b;
+  return (_b = (_a = items.find((i) => !i.disabled)) == null ? void 0 : _a.id) != null ? _b : null;
+}
+function moveActiveId3(items, activeId, delta) {
+  const enabled = items.filter((i) => !i.disabled);
+  if (enabled.length === 0) return null;
+  const idx = enabled.findIndex((i) => i.id === activeId);
+  if (idx < 0) {
+    return delta > 0 ? enabled[0].id : enabled[enabled.length - 1].id;
+  }
+  const next = Math.min(enabled.length - 1, Math.max(0, idx + delta));
+  return enabled[next].id;
+}
+var MenuContext = createContext10(null);
+function useMenuContext() {
+  const ctx = useContext10(MenuContext);
+  if (!ctx) throw new Error("Menu components must be used within MenuRoot");
+  return ctx;
+}
+var MenubarContext = createContext10(null);
+function useMenubarContext() {
+  return useContext10(MenubarContext);
+}
+function MenubarRoot({ children }) {
+  const [activeMenuId, setActiveMenuId] = useState9(null);
+  return /* @__PURE__ */ jsx12(MenubarContext.Provider, { value: { activeMenuId, setActiveMenuId }, children });
+}
+function MenubarContainer(_a) {
+  var _b = _a, {
+    onKeyDown
+  } = _b, props = __objRest(_b, [
+    "onKeyDown"
+  ]);
+  const handleKeyDown2 = useCallback15(
+    (e) => {
+      if (e.key === "ArrowLeft" || e.key === "ArrowRight" || e.key === "Home" || e.key === "End") {
+        const triggers = Array.from(
+          e.currentTarget.querySelectorAll('[role="menuitem"]')
+        );
+        if (triggers.length > 0) {
+          const current = triggers.indexOf(
+            document.activeElement
+          );
+          let next = current;
+          if (e.key === "ArrowRight")
+            next = current < 0 ? 0 : (current + 1) % triggers.length;
+          else if (e.key === "ArrowLeft")
+            next = current < 0 ? 0 : (current - 1 + triggers.length) % triggers.length;
+          else if (e.key === "Home") next = 0;
+          else if (e.key === "End") next = triggers.length - 1;
+          if (triggers[next]) {
+            e.preventDefault();
+            triggers[next].focus();
+          }
+        }
+      }
+      onKeyDown == null ? void 0 : onKeyDown(e);
+    },
+    [onKeyDown]
+  );
+  return /* @__PURE__ */ jsx12("div", __spreadValues({ role: "menubar", onKeyDown: handleKeyDown2 }, props));
+}
+function MenuRoot({
+  children,
+  open: controlledOpen,
+  onOpenChange,
+  setOpen: setOpenDeprecated,
+  animated = true,
+  portal = false,
+  portalRoot = null
+}) {
+  const [open, setOpenState] = useState9(controlledOpen != null ? controlledOpen : false);
+  const [activeId, setActiveId] = useState9(null);
+  const menuId = useId();
+  const triggerId = `${menuId}-trigger`;
+  const items = useRef11([]);
+  const onOpenChangeCb = onOpenChange != null ? onOpenChange : setOpenDeprecated;
+  useEffect12(() => {
+    if (controlledOpen !== void 0) setOpenState(controlledOpen);
+  }, [controlledOpen]);
+  const setOpen = useCallback15(
+    (v) => {
+      if (controlledOpen === void 0) setOpenState(v);
+      onOpenChangeCb == null ? void 0 : onOpenChangeCb(v);
+      if (!v) setActiveId(null);
+    },
+    [controlledOpen, onOpenChangeCb]
+  );
+  const focusTrigger = useCallback15(() => {
+    var _a;
+    (_a = document.getElementById(triggerId)) == null ? void 0 : _a.focus();
+  }, [triggerId]);
+  const { getReferenceProps, getFloatingProps } = useFloating({
+    placement: "bottom-start",
+    gutter: 8,
+    open,
+    onOpenChange: setOpen,
+    dismiss: { outsidePress: true, escapeKey: false }
+  });
+  const registerItem = useCallback15((id, disabled) => {
+    const list = items.current;
+    const existing = list.findIndex((i) => i.id === id);
+    if (existing >= 0) list[existing] = { id, disabled };
+    else list.push({ id, disabled });
+  }, []);
+  const unregisterItem = useCallback15((id) => {
+    items.current = items.current.filter((i) => i.id !== id);
+  }, []);
+  return /* @__PURE__ */ jsx12(
+    MenuContext.Provider,
+    {
+      value: {
+        open,
+        setOpen,
+        menuId,
+        triggerId,
+        getReferenceProps,
+        getFloatingProps,
+        activeId,
+        setActiveId,
+        items,
+        registerItem,
+        unregisterItem,
+        focusTrigger,
+        animated,
+        portal,
+        portalRoot
+      },
+      children
+    }
+  );
+}
+var MenuTrigger = forwardRef9(
+  (_a, ref) => {
+    var _b = _a, { onClick, onKeyDown, role } = _b, props = __objRest(_b, ["onClick", "onKeyDown", "role"]);
+    const { open, setOpen, menuId, triggerId, getReferenceProps } = useMenuContext();
+    const menubarCtx = useMenubarContext();
+    const refProps = getReferenceProps();
+    const handleClick = useCallback15(
+      (e) => {
+        setOpen(!open);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [open, setOpen, onClick]
+    );
+    const handleKeyDown2 = useCallback15(
+      (e) => {
+        if (e.key === "ArrowDown" || e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          setOpen(true);
+        }
+        onKeyDown == null ? void 0 : onKeyDown(e);
+      },
+      [setOpen, onKeyDown]
+    );
+    return /* @__PURE__ */ jsx12(
+      "button",
+      __spreadValues({
+        ref: (node) => {
+          if (refProps.ref && typeof refProps.ref === "function") {
+            refProps.ref(node);
+          }
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        type: "button",
+        role: role != null ? role : menubarCtx ? "menuitem" : void 0,
+        id: triggerId,
+        "aria-expanded": open,
+        "aria-haspopup": "menu",
+        "aria-controls": open ? menuId : void 0,
+        "data-menu-trigger": menuId,
+        onClick: handleClick,
+        onKeyDown: handleKeyDown2
+      }, props)
+    );
+  }
+);
+MenuTrigger.displayName = "MenuTrigger";
+function MenuPopover(_a) {
+  var _b = _a, {
+    children,
+    onKeyDown
+  } = _b, props = __objRest(_b, [
+    "children",
+    "onKeyDown"
+  ]);
+  const {
+    open,
+    setOpen,
+    menuId,
+    triggerId,
+    getFloatingProps,
+    items,
+    activeId,
+    setActiveId,
+    focusTrigger,
+    animated,
+    portal,
+    portalRoot
+  } = useMenuContext();
+  const { ref, mounted, dataAttributes } = useEnterLeave(open, { animated });
+  const floatingProps = getFloatingProps();
+  const menuRef = useRef11(null);
+  const typeahead = useRef11({
+    buffer: "",
+    timer: 0
+  });
+  const activate = useCallback15(() => {
+    var _a2;
+    if (activeId) (_a2 = document.getElementById(activeId)) == null ? void 0 : _a2.click();
+  }, [activeId]);
+  const runTypeahead = useCallback15(
+    (char) => {
+      const t = typeahead.current;
+      window.clearTimeout(t.timer);
+      t.buffer += char.toLowerCase();
+      t.timer = window.setTimeout(() => {
+        t.buffer = "";
+      }, 500);
+      const match = items.current.filter((i) => !i.disabled).find(
+        (i) => {
+          var _a2, _b2;
+          return (_b2 = (_a2 = document.getElementById(i.id)) == null ? void 0 : _a2.textContent) == null ? void 0 : _b2.trim().toLowerCase().startsWith(t.buffer);
+        }
+      );
+      if (match) setActiveId(match.id);
+    },
+    [items, setActiveId]
+  );
+  const handleKeyDown2 = useCallback15(
+    (e) => {
+      var _a2, _b2;
+      switch (e.key) {
+        case "ArrowDown":
+          e.preventDefault();
+          setActiveId(moveActiveId3(items.current, activeId, 1));
+          break;
+        case "ArrowUp":
+          e.preventDefault();
+          setActiveId(moveActiveId3(items.current, activeId, -1));
+          break;
+        case "Home":
+          e.preventDefault();
+          setActiveId(firstEnabledId3(items.current));
+          break;
+        case "End": {
+          e.preventDefault();
+          const enabled = items.current.filter((i) => !i.disabled);
+          setActiveId((_b2 = (_a2 = enabled[enabled.length - 1]) == null ? void 0 : _a2.id) != null ? _b2 : null);
+          break;
+        }
+        case "Enter":
+        case " ":
+          e.preventDefault();
+          activate();
+          break;
+        case "Escape":
+          e.preventDefault();
+          setOpen(false);
+          focusTrigger();
+          break;
+        case "Tab":
+          setOpen(false);
+          break;
+        default:
+          if (e.key.length === 1 && e.key !== " " && !e.metaKey && !e.ctrlKey && !e.altKey && !e.nativeEvent.isComposing) {
+            runTypeahead(e.key);
+          }
+      }
+      onKeyDown == null ? void 0 : onKeyDown(e);
+    },
+    [
+      activeId,
+      items,
+      setActiveId,
+      setOpen,
+      focusTrigger,
+      activate,
+      runTypeahead,
+      onKeyDown
+    ]
+  );
+  useLayoutEffect5(() => {
+    var _a2;
+    if (mounted) {
+      (_a2 = menuRef.current) == null ? void 0 : _a2.focus();
+      setActiveId((prev) => prev != null ? prev : firstEnabledId3(items.current));
+    }
+  }, [mounted, items, setActiveId]);
+  useScrollActiveDescendantIntoView(activeId);
+  if (!mounted) return null;
+  const node = /* @__PURE__ */ jsx12(
+    "div",
+    __spreadProps(__spreadValues(__spreadValues({
+      ref: (n) => {
+        menuRef.current = n;
+        ref.current = n;
+        if (floatingProps.ref && typeof floatingProps.ref === "function") {
+          floatingProps.ref(n);
+        }
+      },
+      id: menuId,
+      role: "menu",
+      "aria-labelledby": triggerId,
+      "aria-activedescendant": activeId != null ? activeId : void 0,
+      "data-menu-id": menuId,
+      style: floatingProps.style,
+      tabIndex: -1,
+      onKeyDown: handleKeyDown2
+    }, dataAttributes), props), {
+      children
+    })
+  );
+  return /* @__PURE__ */ jsx12(OverlayPortal, { portal, portalRoot, children: node });
+}
+function useMenuItemRegistration(disabled) {
+  const { registerItem, unregisterItem, activeId } = useMenuContext();
+  const itemId = useId();
+  useLayoutEffect5(() => {
+    registerItem(itemId, disabled);
+    return () => unregisterItem(itemId);
+  }, [itemId, disabled, registerItem, unregisterItem]);
+  return { itemId, isActive: activeId === itemId };
+}
+function MenuItem(_a) {
+  var _b = _a, {
+    disabled,
+    hideOnClick = true,
+    onClick,
+    children
+  } = _b, props = __objRest(_b, [
+    "disabled",
+    "hideOnClick",
+    "onClick",
+    "children"
+  ]);
+  const { setOpen, focusTrigger } = useMenuContext();
+  const { itemId, isActive } = useMenuItemRegistration(disabled);
+  const handleClick = useCallback15(
+    (e) => {
+      if (disabled) return;
+      onClick == null ? void 0 : onClick(e);
+      if (hideOnClick) {
+        setOpen(false);
+        focusTrigger();
+      }
+    },
+    [disabled, onClick, hideOnClick, setOpen, focusTrigger]
+  );
+  return /* @__PURE__ */ jsx12(
+    "div",
+    __spreadProps(__spreadValues({
+      id: itemId,
+      role: "menuitem",
+      tabIndex: -1,
+      "aria-disabled": disabled || void 0,
+      "data-active-item": isActive ? "" : void 0,
+      "data-disabled": disabled ? "" : void 0,
+      onClick: handleClick
+    }, props), {
+      children
+    })
+  );
+}
+function MenuItemCheckbox(_a) {
+  var _b = _a, {
+    checked = false,
+    onChange,
+    disabled,
+    onClick,
+    children
+  } = _b, props = __objRest(_b, [
+    "checked",
+    "onChange",
+    "disabled",
+    "onClick",
+    "children"
+  ]);
+  const { itemId, isActive } = useMenuItemRegistration(disabled);
+  const handleClick = useCallback15(
+    (e) => {
+      if (disabled) return;
+      onChange == null ? void 0 : onChange(!checked);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [disabled, checked, onChange, onClick]
+  );
+  return /* @__PURE__ */ jsx12(
+    "div",
+    __spreadProps(__spreadValues({
+      id: itemId,
+      role: "menuitemcheckbox",
+      "aria-checked": checked,
+      "aria-disabled": disabled || void 0,
+      "data-active-item": isActive ? "" : void 0,
+      "data-disabled": disabled ? "" : void 0,
+      tabIndex: -1,
+      onClick: handleClick
+    }, props), {
+      children
+    })
+  );
+}
+function MenuItemRadio(_a) {
+  var _b = _a, {
+    checked = false,
+    onChange,
+    disabled,
+    onClick,
+    children
+  } = _b, props = __objRest(_b, [
+    "checked",
+    "onChange",
+    "disabled",
+    "onClick",
+    "children"
+  ]);
+  const { itemId, isActive } = useMenuItemRegistration(disabled);
+  const handleClick = useCallback15(
+    (e) => {
+      if (disabled) return;
+      onChange == null ? void 0 : onChange(!checked);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [disabled, checked, onChange, onClick]
+  );
+  return /* @__PURE__ */ jsx12(
+    "div",
+    __spreadProps(__spreadValues({
+      id: itemId,
+      role: "menuitemradio",
+      "aria-checked": checked,
+      "aria-disabled": disabled || void 0,
+      "data-active-item": isActive ? "" : void 0,
+      "data-disabled": disabled ? "" : void 0,
+      tabIndex: -1,
+      onClick: handleClick
+    }, props), {
+      children
+    })
+  );
+}
+function MenuSeparator(props) {
+  return /* @__PURE__ */ jsx12("hr", __spreadValues({ role: "separator" }, props));
+}
+function MenuButtonArrow(props) {
+  const { open } = useMenuContext();
+  return /* @__PURE__ */ jsx12("span", __spreadProps(__spreadValues({ "aria-hidden": "true", "data-expanded": open ? "" : void 0 }, props), { children: "\u25BE" }));
+}
+
+// src/primitives/toolbar.tsx
+import {
+  createContext as createContext11,
+  useContext as useContext11,
+  useCallback as useCallback16,
+  useRef as useRef12,
+  useLayoutEffect as useLayoutEffect6,
+  useState as useState10
+} from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+function firstEnabledId4(items) {
+  var _a, _b;
+  return (_b = (_a = items.find((i) => !i.disabled)) == null ? void 0 : _a.id) != null ? _b : null;
+}
+function moveActiveId4(items, activeId, delta) {
+  const enabled = items.filter((i) => !i.disabled);
+  if (enabled.length === 0) return null;
+  const idx = enabled.findIndex((i) => i.id === activeId);
+  if (idx < 0) {
+    return delta > 0 ? enabled[0].id : enabled[enabled.length - 1].id;
+  }
+  const next = Math.min(enabled.length - 1, Math.max(0, idx + delta));
+  return enabled[next].id;
+}
+var ToolbarContext = createContext11(null);
+function useToolbarContext() {
+  const ctx = useContext11(ToolbarContext);
+  if (!ctx)
+    throw new Error("Toolbar components must be used within ToolbarRoot");
+  return ctx;
+}
+function ToolbarRoot({
+  children,
+  orientation = "horizontal"
+}) {
+  const [activeId, setActiveId] = useState10(null);
+  const items = useRef12([]);
+  const registerItem = useCallback16((entry) => {
+    const list = items.current;
+    const existing = list.findIndex((i) => i.id === entry.id);
+    if (existing >= 0) list[existing] = entry;
+    else list.push(entry);
+  }, []);
+  const unregisterItem = useCallback16((id) => {
+    items.current = items.current.filter((i) => i.id !== id);
+    setActiveId((prev) => prev === id ? firstEnabledId4(items.current) : prev);
+  }, []);
+  useLayoutEffect6(() => {
+    setActiveId((prev) => prev != null ? prev : firstEnabledId4(items.current));
+  }, [activeId]);
+  return /* @__PURE__ */ jsx13(
+    ToolbarContext.Provider,
+    {
+      value: {
+        orientation,
+        activeId,
+        setActiveId,
+        registerItem,
+        unregisterItem,
+        items
+      },
+      children
+    }
+  );
+}
+function ToolbarContainer(_a) {
+  var _b = _a, {
+    onKeyDown
+  } = _b, props = __objRest(_b, [
+    "onKeyDown"
+  ]);
+  const { orientation, activeId, setActiveId, items } = useToolbarContext();
+  const focusActive = useCallback16(
+    (id) => {
+      var _a2, _b2;
+      if (!id) return;
+      (_b2 = (_a2 = items.current.find((i) => i.id === id)) == null ? void 0 : _a2.element) == null ? void 0 : _b2.focus();
+    },
+    [items]
+  );
+  const handleKeyDown2 = useCallback16(
+    (e) => {
+      var _a2, _b2;
+      const prevKey = orientation === "vertical" ? "ArrowUp" : "ArrowLeft";
+      const nextKey = orientation === "vertical" ? "ArrowDown" : "ArrowRight";
+      let nextId;
+      if (e.key === nextKey) {
+        e.preventDefault();
+        nextId = moveActiveId4(items.current, activeId, 1);
+      } else if (e.key === prevKey) {
+        e.preventDefault();
+        nextId = moveActiveId4(items.current, activeId, -1);
+      } else if (e.key === "Home") {
+        e.preventDefault();
+        nextId = firstEnabledId4(items.current);
+      } else if (e.key === "End") {
+        e.preventDefault();
+        const enabled = items.current.filter((i) => !i.disabled);
+        nextId = (_b2 = (_a2 = enabled[enabled.length - 1]) == null ? void 0 : _a2.id) != null ? _b2 : null;
+      }
+      if (nextId) {
+        setActiveId(nextId);
+        focusActive(nextId);
+      }
+      onKeyDown == null ? void 0 : onKeyDown(e);
+    },
+    [orientation, activeId, setActiveId, items, focusActive, onKeyDown]
+  );
+  return /* @__PURE__ */ jsx13(
+    "div",
+    __spreadValues({
+      role: "toolbar",
+      "aria-orientation": orientation,
+      onKeyDown: handleKeyDown2
+    }, props)
+  );
+}
+function ToolbarButton(_a) {
+  var _b = _a, {
+    disabled,
+    onFocus
+  } = _b, props = __objRest(_b, [
+    "disabled",
+    "onFocus"
+  ]);
+  const { registerItem, unregisterItem, activeId, setActiveId } = useToolbarContext();
+  const itemId = useId();
+  const buttonRef = useRef12(null);
+  const isActive = activeId === itemId;
+  useLayoutEffect6(() => {
+    registerItem({ id: itemId, element: buttonRef.current, disabled });
+    return () => unregisterItem(itemId);
+  }, [itemId, disabled, registerItem, unregisterItem]);
+  return /* @__PURE__ */ jsx13(
+    "button",
+    __spreadValues({
+      ref: buttonRef,
+      type: "button",
+      disabled,
+      tabIndex: isActive ? 0 : -1,
+      onFocus: (e) => {
+        if (!disabled) setActiveId(itemId);
+        onFocus == null ? void 0 : onFocus(e);
+      }
+    }, props)
+  );
+}
+function ToolbarSeparator(props) {
+  return /* @__PURE__ */ jsx13("hr", __spreadValues({ role: "separator", "aria-orientation": "vertical" }, props));
+}
+
+// src/primitives/composite.tsx
+import {
+  createContext as createContext12,
+  useContext as useContext12,
+  useCallback as useCallback17,
+  useRef as useRef13,
+  useState as useState11,
+  useEffect as useEffect13,
+  cloneElement,
+  isValidElement
+} from "react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+function firstEnabledFrom(list, start, dir, loop) {
+  const n = list.length;
+  if (n === 0) return -1;
+  let i = start;
+  for (let guard = 0; guard <= n; guard++) {
+    if (i >= 0 && i < n && !list[i].disabled) return i;
+    i += dir;
+    if (loop) i = (i % n + n) % n;
+    else if (i < 0 || i >= n) return -1;
+  }
+  return -1;
+}
+var CompositeContext = createContext12(null);
+function useCompositeContext() {
+  const ctx = useContext12(CompositeContext);
+  if (!ctx)
+    throw new Error(
+      "Composite components must be used within CompositeProvider"
+    );
+  return ctx;
+}
+function CompositeProvider({
+  children,
+  focusLoop = false,
+  focusWrap = false,
+  orientation = "both",
+  activeId: controlledActiveId,
+  onActiveIdChange,
+  setActiveId: setActiveIdDeprecated
+}) {
+  const [internalActiveId, setInternalActiveId] = useState11(null);
+  const items = useRef13([]);
+  const onActiveIdChangeCb = onActiveIdChange != null ? onActiveIdChange : setActiveIdDeprecated;
+  const activeId = controlledActiveId !== void 0 ? controlledActiveId : internalActiveId;
+  const activeIdRef = useRef13(activeId);
+  activeIdRef.current = activeId;
+  const seededRef = useRef13(false);
+  const setActiveId = useCallback17(
+    (id) => {
+      if (controlledActiveId === void 0) setInternalActiveId(id);
+      onActiveIdChangeCb == null ? void 0 : onActiveIdChangeCb(id);
+    },
+    [controlledActiveId, onActiveIdChangeCb]
+  );
+  const registerItem = useCallback17(
+    (id, element, row = 0, col = 0, disabled = false) => {
+      const list = items.current;
+      const existing = list.findIndex((i) => i.id === id);
+      const activeBecameDisabled = existing >= 0 && id === activeIdRef.current && disabled;
+      if (existing >= 0) {
+        list[existing] = { id, element, row, col, disabled };
+      } else {
+        list.push({ id, element, row, col, disabled });
+      }
+      if (controlledActiveId !== void 0) return;
+      if (activeIdRef.current === null && !seededRef.current && !disabled) {
+        seededRef.current = true;
+        activeIdRef.current = id;
+        setActiveId(id);
+      } else if (activeBecameDisabled) {
+        const idx = firstEnabledFrom(list, 0, 1, false);
+        const nextId = idx >= 0 ? list[idx].id : null;
+        activeIdRef.current = nextId;
+        if (nextId === null) {
+          seededRef.current = false;
+          setInternalActiveId(null);
+        } else {
+          setActiveId(nextId);
+        }
+      }
+    },
+    [controlledActiveId, setActiveId]
+  );
+  const unregisterItem = useCallback17(
+    (id) => {
+      items.current = items.current.filter((i) => i.id !== id);
+      if (controlledActiveId === void 0) {
+        setInternalActiveId((prev) => {
+          if (prev !== id) return prev;
+          const idx = firstEnabledFrom(items.current, 0, 1, false);
+          const nextId = idx >= 0 ? items.current[idx].id : null;
+          activeIdRef.current = nextId;
+          if (nextId === null) seededRef.current = false;
+          return nextId;
+        });
+      }
+    },
+    [controlledActiveId]
+  );
+  return /* @__PURE__ */ jsx14(
+    CompositeContext.Provider,
+    {
+      value: {
+        activeId,
+        setActiveId,
+        registerItem,
+        unregisterItem,
+        items,
+        focusLoop,
+        focusWrap,
+        orientation
+      },
+      children
+    }
+  );
+}
+function Composite(_a) {
+  var _b = _a, { onKeyDown, render } = _b, props = __objRest(_b, ["onKeyDown", "render"]);
+  const { activeId, setActiveId, items, focusLoop, focusWrap, orientation } = useCompositeContext();
+  const handleKeyDown2 = useCallback17(
+    (e) => {
+      var _a2, _b2, _c, _d;
+      const list = items.current;
+      const currentIndex = list.findIndex((i) => i.id === activeId);
+      if (currentIndex < 0) return;
+      let nextIndex = -1;
+      const { row, col } = list[currentIndex];
+      const isHorizontal = orientation !== "vertical";
+      const isVertical = orientation !== "horizontal";
+      const navigate = (offset2) => {
+        const dir = offset2 >= 0 ? 1 : -1;
+        let target = currentIndex + offset2;
+        if (focusLoop) {
+          target = (target % list.length + list.length) % list.length;
+        } else if (focusWrap && (target < 0 || target >= list.length)) {
+          return void 0;
+        } else {
+          target = Math.max(0, Math.min(list.length - 1, target));
+        }
+        const enabled = firstEnabledFrom(list, target, dir, focusLoop);
+        return enabled >= 0 ? enabled : void 0;
+      };
+      const navigateRow = (dir) => {
+        const sibling = list.find(
+          (i) => i.col === col && i.row === row + dir && !i.disabled
+        );
+        if (sibling) return list.indexOf(sibling);
+        return navigate(dir);
+      };
+      switch (e.key) {
+        case "ArrowRight":
+          if (!isHorizontal) break;
+          e.preventDefault();
+          nextIndex = (_a2 = navigate(1)) != null ? _a2 : currentIndex;
+          break;
+        case "ArrowLeft":
+          if (!isHorizontal) break;
+          e.preventDefault();
+          nextIndex = (_b2 = navigate(-1)) != null ? _b2 : currentIndex;
+          break;
+        case "ArrowDown":
+          if (!isVertical) break;
+          e.preventDefault();
+          nextIndex = (_c = navigateRow(1)) != null ? _c : currentIndex;
+          break;
+        case "ArrowUp":
+          if (!isVertical) break;
+          e.preventDefault();
+          nextIndex = (_d = navigateRow(-1)) != null ? _d : currentIndex;
+          break;
+        case "Home":
+          e.preventDefault();
+          nextIndex = firstEnabledFrom(list, 0, 1, false);
+          break;
+        case "End":
+          e.preventDefault();
+          nextIndex = firstEnabledFrom(list, list.length - 1, -1, false);
+          break;
+      }
+      if (nextIndex >= 0 && list[nextIndex]) {
+        setActiveId(list[nextIndex].id);
+        list[nextIndex].element.focus();
+      }
+      onKeyDown == null ? void 0 : onKeyDown(e);
+    },
+    [
+      activeId,
+      items,
+      focusLoop,
+      focusWrap,
+      orientation,
+      setActiveId,
+      onKeyDown
+    ]
+  );
+  if (render && isValidElement(render)) {
+    const merged = mergeProps(
+      render.props,
+      { onKeyDown: handleKeyDown2 },
+      props
+    );
+    return cloneElement(
+      render,
+      merged
+    );
+  }
+  return /* @__PURE__ */ jsx14("div", __spreadValues({ onKeyDown: handleKeyDown2 }, props));
+}
+function CompositeRow(_a) {
+  var _b = _a, { render } = _b, props = __objRest(_b, ["render"]);
+  if (render && isValidElement(render)) {
+    const merged = mergeProps(
+      render.props,
+      { role: "row" },
+      props
+    );
+    return cloneElement(
+      render,
+      merged
+    );
+  }
+  return /* @__PURE__ */ jsx14("div", __spreadValues({ role: "row" }, props));
+}
+function CompositeItem(_a) {
+  var _b = _a, {
+    id: providedId,
+    row = 0,
+    col = 0,
+    disabled,
+    render,
+    onFocus
+  } = _b, props = __objRest(_b, [
+    "id",
+    "row",
+    "col",
+    "disabled",
+    "render",
+    "onFocus"
+  ]);
+  const id = useId(providedId);
+  const { activeId, setActiveId, registerItem, unregisterItem } = useCompositeContext();
+  const ref = useRef13(null);
+  const isActive = activeId === id;
+  useEffect13(() => {
+    if (ref.current) registerItem(id, ref.current, row, col, disabled);
+    return () => unregisterItem(id);
+  }, [id, row, col, disabled, registerItem, unregisterItem]);
+  const sharedProps = __spreadValues({
+    tabIndex: isActive && !disabled ? 0 : -1,
+    "data-active-item": isActive ? "" : void 0,
+    "aria-disabled": disabled || void 0,
+    // Compose with any consumer-supplied onFocus (previously clobbered by the
+    // spread of `...props`).
+    onFocus: (e) => {
+      if (!disabled) setActiveId(id);
+      onFocus == null ? void 0 : onFocus(e);
+    }
+  }, props);
+  if (render && isValidElement(render)) {
+    const renderRef = render.props.ref;
+    const merged = mergeProps(
+      render.props,
+      sharedProps
+    );
+    return cloneElement(render, __spreadProps(__spreadValues({}, merged), {
+      ref: renderRef ? mergeRefs(ref, renderRef) : ref
+    }));
+  }
+  return /* @__PURE__ */ jsx14(
+    "button",
+    __spreadProps(__spreadValues({
+      type: "button",
+      disabled
+    }, sharedProps), {
+      ref
+    })
+  );
+}
+
+// src/primitives/separator.tsx
+import { forwardRef as forwardRef10 } from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+var Separator = forwardRef10(
+  function Separator2(_a, ref) {
+    var _b = _a, { orientation = "horizontal", decorative = false } = _b, props = __objRest(_b, ["orientation", "decorative"]);
+    const semanticProps = decorative ? { role: "none" } : { role: "separator", "aria-orientation": orientation };
+    return /* @__PURE__ */ jsx15(
+      "div",
+      __spreadValues(__spreadValues({
+        ref,
+        "data-orientation": orientation
+      }, semanticProps), props)
+    );
+  }
+);
+
+// src/primitives/toggle.tsx
+import {
+  createContext as createContext13,
+  useCallback as useCallback18,
+  useContext as useContext13,
+  useLayoutEffect as useLayoutEffect7,
+  useMemo as useMemo5,
+  useRef as useRef14,
+  useState as useState12
+} from "react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+function firstEnabledId5(items) {
+  var _a, _b;
+  return (_b = (_a = items.find((i) => !i.disabled)) == null ? void 0 : _a.id) != null ? _b : null;
+}
+function moveActiveId5(items, activeId, delta) {
+  const enabled = items.filter((i) => !i.disabled);
+  if (enabled.length === 0) return null;
+  const idx = enabled.findIndex((i) => i.id === activeId);
+  if (idx < 0)
+    return delta > 0 ? enabled[0].id : enabled[enabled.length - 1].id;
+  const next = Math.min(enabled.length - 1, Math.max(0, idx + delta));
+  return enabled[next].id;
+}
+var ToggleGroupContext = createContext13(null);
+function ToggleGroup(_a) {
+  var _b = _a, {
+    value: controlledValue,
+    defaultValue,
+    onValueChange,
+    toggleMultiple = false,
+    orientation = "horizontal",
+    disabled = false,
+    onKeyDown
+  } = _b, props = __objRest(_b, [
+    "value",
+    "defaultValue",
+    "onValueChange",
+    "toggleMultiple",
+    "orientation",
+    "disabled",
+    "onKeyDown"
+  ]);
+  const normalizedDefault = defaultValue != null ? defaultValue : toggleMultiple ? [] : "";
+  const [value, setValue] = useControllableState(
+    normalizedDefault,
+    controlledValue,
+    onValueChange
+  );
+  const selected = useMemo5(
+    () => Array.isArray(value) ? value : value === "" ? [] : [value],
+    [value]
+  );
+  const isPressed = useCallback18(
+    (v) => selected.includes(v),
+    [selected]
+  );
+  const toggle = useCallback18(
+    (v) => {
+      if (toggleMultiple) {
+        const set = new Set(Array.isArray(value) ? value : []);
+        if (set.has(v)) set.delete(v);
+        else set.add(v);
+        setValue([...set]);
+      } else {
+        const current = Array.isArray(value) ? value[0] : value;
+        setValue(current === v ? "" : v);
+      }
+    },
+    [toggleMultiple, value, setValue]
+  );
+  const [activeId, setActiveId] = useState12(null);
+  const items = useRef14([]);
+  const registerItem = useCallback18((entry) => {
+    const list = items.current;
+    const existing = list.findIndex((i) => i.id === entry.id);
+    if (existing >= 0) list[existing] = entry;
+    else list.push(entry);
+  }, []);
+  const unregisterItem = useCallback18((id) => {
+    items.current = items.current.filter((i) => i.id !== id);
+    setActiveId((prev) => prev === id ? firstEnabledId5(items.current) : prev);
+  }, []);
+  useLayoutEffect7(() => {
+    setActiveId((prev) => prev != null ? prev : firstEnabledId5(items.current));
+  }, [activeId]);
+  const focusActive = useCallback18((id) => {
+    var _a2, _b2;
+    if (!id) return;
+    (_b2 = (_a2 = items.current.find((i) => i.id === id)) == null ? void 0 : _a2.element) == null ? void 0 : _b2.focus();
+  }, []);
+  const handleKeyDown2 = useCallback18(
+    (e) => {
+      var _a2, _b2;
+      const prevKey = orientation === "vertical" ? "ArrowUp" : "ArrowLeft";
+      const nextKey = orientation === "vertical" ? "ArrowDown" : "ArrowRight";
+      let nextId;
+      if (e.key === nextKey) {
+        e.preventDefault();
+        nextId = moveActiveId5(items.current, activeId, 1);
+      } else if (e.key === prevKey) {
+        e.preventDefault();
+        nextId = moveActiveId5(items.current, activeId, -1);
+      } else if (e.key === "Home") {
+        e.preventDefault();
+        nextId = firstEnabledId5(items.current);
+      } else if (e.key === "End") {
+        e.preventDefault();
+        const enabled = items.current.filter((i) => !i.disabled);
+        nextId = (_b2 = (_a2 = enabled[enabled.length - 1]) == null ? void 0 : _a2.id) != null ? _b2 : null;
+      }
+      if (nextId) {
+        setActiveId(nextId);
+        focusActive(nextId);
+      }
+      onKeyDown == null ? void 0 : onKeyDown(e);
+    },
+    [orientation, activeId, focusActive, onKeyDown]
+  );
+  return /* @__PURE__ */ jsx16(
+    ToggleGroupContext.Provider,
+    {
+      value: {
+        isPressed,
+        toggle,
+        disabled,
+        orientation,
+        activeId,
+        setActiveId,
+        registerItem,
+        unregisterItem,
+        items
+      },
+      children: /* @__PURE__ */ jsx16("div", __spreadValues({ role: "group", onKeyDown: handleKeyDown2 }, props))
+    }
+  );
+}
+function Toggle(_a) {
+  var _b = _a, {
+    pressed: pressedProp,
+    defaultPressed = false,
+    onPressedChange,
+    value,
+    disabled,
+    onClick,
+    onFocus
+  } = _b, props = __objRest(_b, [
+    "pressed",
+    "defaultPressed",
+    "onPressedChange",
+    "value",
+    "disabled",
+    "onClick",
+    "onFocus"
+  ]);
+  const group = useContext13(ToggleGroupContext);
+  const itemId = useId();
+  const buttonRef = useRef14(null);
+  const [standalonePressed, setStandalonePressed] = useControllableState(
+    defaultPressed,
+    pressedProp,
+    onPressedChange
+  );
+  const inGroup = group !== null;
+  const isDisabled = disabled || inGroup && group.disabled || false;
+  useLayoutEffect7(() => {
+    if (!inGroup) return void 0;
+    group.registerItem({
+      id: itemId,
+      element: buttonRef.current,
+      disabled: isDisabled
+    });
+    return () => group.unregisterItem(itemId);
+  }, [inGroup, group, itemId, isDisabled]);
+  const pressed = inGroup && value !== void 0 ? group.isPressed(value) : standalonePressed;
+  const isActive = inGroup ? group.activeId === itemId : void 0;
+  const handleClick = useCallback18(
+    (e) => {
+      if (inGroup) {
+        if (value !== void 0) group.toggle(value);
+      } else {
+        setStandalonePressed(!standalonePressed);
+      }
+      onClick == null ? void 0 : onClick(e);
+    },
+    [inGroup, group, value, setStandalonePressed, standalonePressed, onClick]
+  );
+  return /* @__PURE__ */ jsx16(
+    "button",
+    __spreadValues({
+      ref: buttonRef,
+      type: "button",
+      "aria-pressed": pressed,
+      "data-pressed": pressed ? "" : void 0,
+      disabled: isDisabled,
+      tabIndex: inGroup ? isActive ? 0 : -1 : void 0,
+      onClick: handleClick,
+      onFocus: (e) => {
+        if (inGroup && !isDisabled) group.setActiveId(itemId);
+        onFocus == null ? void 0 : onFocus(e);
+      }
+    }, props)
+  );
+}
+
+// src/primitives/switch.tsx
+import { forwardRef as forwardRef11, useCallback as useCallback19 } from "react";
+
+// src/internal/visually-hidden.ts
+var VISUALLY_HIDDEN = {
+  position: "absolute",
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0 0 0 0)",
+  whiteSpace: "nowrap",
+  border: 0
+};
+
+// src/primitives/switch.tsx
+import { Fragment as Fragment2, jsx as jsx17, jsxs as jsxs3 } from "react/jsx-runtime";
+var Switch = forwardRef11(
+  function Switch2(_a, ref) {
+    var _b = _a, {
+      checked,
+      defaultChecked = false,
+      onCheckedChange,
+      disabled = false,
+      name,
+      value = "on",
+      required,
+      onClick
+    } = _b, props = __objRest(_b, [
+      "checked",
+      "defaultChecked",
+      "onCheckedChange",
+      "disabled",
+      "name",
+      "value",
+      "required",
+      "onClick"
+    ]);
+    const [on, setOn] = useControllableState(
+      defaultChecked,
+      checked,
+      onCheckedChange
+    );
+    const handleClick = useCallback19(
+      (e) => {
+        if (disabled) return;
+        setOn(!on);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [disabled, on, setOn, onClick]
+    );
+    return /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      /* @__PURE__ */ jsx17(
+        "button",
+        __spreadValues({
+          ref,
+          type: "button",
+          role: "switch",
+          "aria-checked": on,
+          disabled,
+          "data-state": on ? "checked" : "unchecked",
+          "data-disabled": disabled ? "" : void 0,
+          onClick: handleClick
+        }, props)
+      ),
+      name != null && /* @__PURE__ */ jsx17(
+        "input",
+        {
+          type: "checkbox",
+          "aria-hidden": true,
+          tabIndex: -1,
+          name,
+          value,
+          checked: on,
+          required,
+          disabled,
+          readOnly: true,
+          style: VISUALLY_HIDDEN
+        }
+      )
+    ] });
+  }
+);
+
+// src/primitives/checkbox.tsx
+import { forwardRef as forwardRef12, useCallback as useCallback20 } from "react";
+import { Fragment as Fragment3, jsx as jsx18, jsxs as jsxs4 } from "react/jsx-runtime";
+var Checkbox = forwardRef12(
+  function Checkbox2(_a, ref) {
+    var _b = _a, {
+      checked,
+      defaultChecked = false,
+      indeterminate = false,
+      onCheckedChange,
+      disabled = false,
+      name,
+      value = "on",
+      required,
+      onClick,
+      children
+    } = _b, props = __objRest(_b, [
+      "checked",
+      "defaultChecked",
+      "indeterminate",
+      "onCheckedChange",
+      "disabled",
+      "name",
+      "value",
+      "required",
+      "onClick",
+      "children"
+    ]);
+    const [on, setOn] = useControllableState(
+      defaultChecked,
+      checked,
+      onCheckedChange
+    );
+    const handleClick = useCallback20(
+      (e) => {
+        if (disabled) return;
+        setOn(indeterminate ? true : !on);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [disabled, indeterminate, on, setOn, onClick]
+    );
+    return /* @__PURE__ */ jsxs4(Fragment3, { children: [
+      /* @__PURE__ */ jsx18(
+        "button",
+        __spreadProps(__spreadValues({
+          ref,
+          type: "button",
+          role: "checkbox",
+          "aria-checked": indeterminate ? "mixed" : on,
+          disabled,
+          "data-state": indeterminate ? "indeterminate" : on ? "checked" : "unchecked",
+          "data-disabled": disabled ? "" : void 0,
+          onClick: handleClick
+        }, props), {
+          children
+        })
+      ),
+      name != null && /* @__PURE__ */ jsx18(
+        "input",
+        {
+          type: "checkbox",
+          "aria-hidden": true,
+          tabIndex: -1,
+          name,
+          value,
+          checked: on,
+          required,
+          disabled,
+          readOnly: true,
+          style: VISUALLY_HIDDEN
+        }
+      )
+    ] });
+  }
+);
+
+// src/primitives/progress.tsx
+import { forwardRef as forwardRef13 } from "react";
+import { jsx as jsx19 } from "react/jsx-runtime";
+function formatPercent(fraction) {
+  return new Intl.NumberFormat(void 0, { style: "percent" }).format(
+    fraction
+  );
+}
+var Progress = forwardRef13(
+  function Progress2(_a, ref) {
+    var _b = _a, { value = null, min = 0, max = 100, getValueLabel } = _b, props = __objRest(_b, ["value", "min", "max", "getValueLabel"]);
+    const indeterminate = value == null || Number.isNaN(value);
+    const clamped = indeterminate ? null : Math.min(max, Math.max(min, value));
+    const fraction = clamped == null || max === min ? 0 : (clamped - min) / (max - min);
+    const valueText = clamped == null ? void 0 : getValueLabel ? getValueLabel(clamped, min, max) : formatPercent(fraction);
+    return /* @__PURE__ */ jsx19(
+      "div",
+      __spreadValues({
+        ref,
+        role: "progressbar",
+        "aria-valuemin": min,
+        "aria-valuemax": max,
+        "aria-valuenow": clamped != null ? clamped : void 0,
+        "aria-valuetext": valueText,
+        "data-state": indeterminate ? "indeterminate" : fraction >= 1 ? "complete" : "loading",
+        "data-value": clamped != null ? clamped : void 0
+      }, props)
+    );
+  }
+);
+
+// src/primitives/meter.tsx
+import { forwardRef as forwardRef14 } from "react";
+import { jsx as jsx20 } from "react/jsx-runtime";
+function formatPercent2(fraction) {
+  return new Intl.NumberFormat(void 0, { style: "percent" }).format(
+    fraction
+  );
+}
+var Meter = forwardRef14(function Meter2(_a, ref) {
+  var _b = _a, { value, min = 0, max = 100, getValueLabel } = _b, props = __objRest(_b, ["value", "min", "max", "getValueLabel"]);
+  const clamped = Math.min(max, Math.max(min, value));
+  const fraction = max === min ? 0 : (clamped - min) / (max - min);
+  const valueText = getValueLabel ? getValueLabel(clamped, min, max) : formatPercent2(fraction);
+  return /* @__PURE__ */ jsx20(
+    "div",
+    __spreadValues({
+      ref,
+      role: "meter",
+      "aria-valuemin": min,
+      "aria-valuemax": max,
+      "aria-valuenow": clamped,
+      "aria-valuetext": valueText,
+      "data-value": clamped
+    }, props)
+  );
+});
+
+// src/primitives/accordion.tsx
+import {
+  createContext as createContext14,
+  useCallback as useCallback21,
+  useContext as useContext14,
+  useEffect as useEffect14,
+  useRef as useRef15
+} from "react";
+import { jsx as jsx21 } from "react/jsx-runtime";
+var AccordionRootContext = createContext14(
+  null
+);
+function useAccordionRoot() {
+  const ctx = useContext14(AccordionRootContext);
+  if (!ctx) {
+    throw new Error("Accordion components must be used within AccordionRoot");
+  }
+  return ctx;
+}
+var AccordionItemContext = createContext14(
+  null
+);
+function useAccordionItem() {
+  const ctx = useContext14(AccordionItemContext);
+  if (!ctx) {
+    throw new Error(
+      "AccordionTrigger/AccordionContent must be used within AccordionItem"
+    );
+  }
+  return ctx;
+}
+function AccordionRoot({
+  children,
+  type = "single",
+  value: controlledValue,
+  defaultValue,
+  onValueChange,
+  collapsible = false,
+  disabled = false,
+  animated = true
+}) {
+  const multiple = type === "multiple";
+  const normalizedDefault = defaultValue != null ? defaultValue : multiple ? [] : null;
+  const [value, setValue] = useControllableState(
+    normalizedDefault,
+    controlledValue,
+    onValueChange
+  );
+  const isExpanded = useCallback21(
+    (v) => Array.isArray(value) ? value.includes(v) : value === v,
+    [value]
+  );
+  const toggle = useCallback21(
+    (v) => {
+      if (multiple) {
+        const set = new Set(Array.isArray(value) ? value : []);
+        if (set.has(v)) set.delete(v);
+        else set.add(v);
+        setValue([...set]);
+      } else {
+        const current = Array.isArray(value) ? value[0] : value;
+        if (current === v) {
+          if (collapsible) setValue(null);
+        } else {
+          setValue(v);
+        }
+      }
+    },
+    [multiple, value, collapsible, setValue]
+  );
+  return /* @__PURE__ */ jsx21(
+    AccordionRootContext.Provider,
+    {
+      value: { isExpanded, toggle, disabled, animated },
+      children
+    }
+  );
+}
+function AccordionItem(_a) {
+  var _b = _a, {
+    value,
+    disabled = false
+  } = _b, props = __objRest(_b, [
+    "value",
+    "disabled"
+  ]);
+  const root = useAccordionRoot();
+  const baseId = useId();
+  const itemDisabled = disabled || root.disabled;
+  return /* @__PURE__ */ jsx21(
+    AccordionItemContext.Provider,
+    {
+      value: {
+        value,
+        triggerId: `${baseId}-trigger`,
+        contentId: `${baseId}-content`,
+        disabled: itemDisabled
+      },
+      children: /* @__PURE__ */ jsx21("div", __spreadValues({ "data-state": root.isExpanded(value) ? "open" : "closed" }, props))
+    }
+  );
+}
+function AccordionTrigger(_a) {
+  var _b = _a, {
+    onClick,
+    disabled
+  } = _b, props = __objRest(_b, [
+    "onClick",
+    "disabled"
+  ]);
+  const root = useAccordionRoot();
+  const item = useAccordionItem();
+  const expanded = root.isExpanded(item.value);
+  const isDisabled = disabled || item.disabled;
+  const handleClick = useCallback21(
+    (e) => {
+      if (!isDisabled) root.toggle(item.value);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [isDisabled, root, item.value, onClick]
+  );
+  return /* @__PURE__ */ jsx21(
+    "button",
+    __spreadValues({
+      type: "button",
+      id: item.triggerId,
+      "aria-expanded": expanded,
+      "aria-controls": item.contentId,
+      disabled: isDisabled,
+      "data-state": expanded ? "open" : "closed",
+      onClick: handleClick
+    }, props)
+  );
+}
+function AccordionContent(_a) {
+  var _b = _a, { style } = _b, props = __objRest(_b, ["style"]);
+  const root = useAccordionRoot();
+  const item = useAccordionItem();
+  const expanded = root.isExpanded(item.value);
+  const { ref, mounted, dataAttributes } = useEnterLeave(expanded, {
+    animated: root.animated
+  });
+  const innerRef = useRef15(null);
+  useEffect14(() => {
+    if (innerRef.current) {
+      ref.current = innerRef.current;
+    }
+  }, [ref]);
+  if (!mounted) return null;
+  return /* @__PURE__ */ jsx21(
+    "div",
+    __spreadValues(__spreadValues({
+      ref: innerRef,
+      id: item.contentId,
+      role: "region",
+      "aria-labelledby": item.triggerId,
+      style
+    }, dataAttributes), props)
+  );
+}
+
+// src/form/form-store.ts
+import { useCallback as useCallback22, useRef as useRef16, useSyncExternalStore as useSyncExternalStore2 } from "react";
+function getByPath(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc == null || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, obj);
+}
+function setByPath(obj, path, value) {
+  const keys = path.split(".");
+  const result = __spreadValues({}, obj);
+  let current = result;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const next = current[key];
+    if (Array.isArray(next)) {
+      current[key] = [...next];
+    } else if (next && typeof next === "object") {
+      current[key] = __spreadValues({}, next);
+    } else {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return result;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(
+      (k) => deepEqual(
+        a[k],
+        b[k]
+      )
+    );
+  }
+  return false;
+}
+function collectFieldPaths(value, prefix = "") {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return prefix ? [prefix] : [];
+    }
+    return value.flatMap(
+      (item, index) => collectFieldPaths(item, prefix ? `${prefix}.${index}` : `${index}`)
+    );
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return prefix ? [prefix] : [];
+    }
+    return entries.flatMap(
+      ([key, nestedValue]) => collectFieldPaths(nestedValue, prefix ? `${prefix}.${key}` : key)
+    );
+  }
+  return prefix ? [prefix] : [];
+}
+function createFormStore(optionsRef) {
+  function getOptions() {
+    return optionsRef.current;
+  }
+  function getDefaultValues() {
+    return __spreadValues({}, getOptions().defaultValues);
+  }
+  function getValidateOn() {
+    var _a;
+    return (_a = getOptions().validateOn) != null ? _a : "change";
+  }
+  let values = getDefaultValues();
+  let validationErrors = {};
+  let injectedErrors = {};
+  let errors = {};
+  let touched = /* @__PURE__ */ new Set();
+  let submitting = false;
+  let submitError = void 0;
+  let validating = false;
+  let version = 0;
+  let submitToken = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const controls = /* @__PURE__ */ new Map();
+  function notify() {
+    version++;
+    for (const l of listeners) l();
+  }
+  function focusFirstInvalid(errs) {
+    for (const [name, getElement] of controls) {
+      if (!errs[name]) continue;
+      const el = getElement();
+      if (!el) return;
+      el.focus();
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+        try {
+          el.select();
+        } catch (e) {
+        }
+      }
+      return;
+    }
+  }
+  function recombineErrors() {
+    errors = __spreadValues(__spreadValues({}, injectedErrors), validationErrors);
+  }
+  function runValidation() {
+    var _a;
+    const validate = getOptions().validate;
+    if (!validate) {
+      validationErrors = {};
+      recombineErrors();
+      return errors;
+    }
+    validating = true;
+    try {
+      validationErrors = (_a = validate(values)) != null ? _a : {};
+    } finally {
+      validating = false;
+    }
+    recombineErrors();
+    return errors;
+  }
+  const store = {
+    getValues: () => values,
+    getValue: ((name) => getByPath(values, name)),
+    setValue: ((name, value) => {
+      values = setByPath(values, name, value);
+      touched.add(name);
+      if (name in injectedErrors) {
+        delete injectedErrors[name];
+        recombineErrors();
+      }
+      if (getValidateOn() === "change") {
+        errors = runValidation();
+      }
+      notify();
+    }),
+    getErrors: () => __spreadValues({}, errors),
+    getError: (name) => errors[name],
+    setError: (name, error) => {
+      if (error === void 0) {
+        delete injectedErrors[name];
+      } else {
+        injectedErrors[name] = error;
+        touched.add(name);
+      }
+      recombineErrors();
+      if (!validating) {
+        notify();
+      }
+    },
+    getFieldTouched: (name) => touched.has(name),
+    setFieldTouched: (name, isTouched) => {
+      if (isTouched) {
+        touched.add(name);
+        if (getValidateOn() === "blur") {
+          errors = runValidation();
+        }
+      } else {
+        touched.delete(name);
+      }
+      notify();
+    },
+    isDirty: () => {
+      const defaultValues = getDefaultValues();
+      return !deepEqual(values, defaultValues);
+    },
+    isFieldDirty: (name) => {
+      const defaultValues = getDefaultValues();
+      return !deepEqual(
+        getByPath(values, name),
+        getByPath(defaultValues, name)
+      );
+    },
+    validate: () => {
+      errors = runValidation();
+      for (const key of collectFieldPaths(values)) {
+        touched.add(key);
+      }
+      for (const key of Object.keys(errors)) {
+        touched.add(key);
+      }
+      notify();
+      return errors;
+    },
+    reset: () => {
+      values = getDefaultValues();
+      validationErrors = {};
+      injectedErrors = {};
+      errors = {};
+      touched = /* @__PURE__ */ new Set();
+      submitting = false;
+      submitError = void 0;
+      submitToken += 1;
+      notify();
+    },
+    resetField: (name) => {
+      const defaultValues = getDefaultValues();
+      const defaultVal = getByPath(defaultValues, name);
+      values = setByPath(values, name, defaultVal);
+      delete validationErrors[name];
+      delete injectedErrors[name];
+      recombineErrors();
+      touched.delete(name);
+      notify();
+    },
+    registerControl: (name, getElement) => {
+      controls.set(name, getElement);
+      return () => {
+        if (controls.get(name) === getElement) controls.delete(name);
+      };
+    },
+    submit: (e) => {
+      var _a, _b, _c;
+      (_a = e == null ? void 0 : e.preventDefault) == null ? void 0 : _a.call(e);
+      if (submitting) return;
+      submitError = void 0;
+      const errs = store.validate();
+      if (Object.keys(errs).length > 0) {
+        focusFirstInvalid(errs);
+        return;
+      }
+      const result = (_c = (_b = getOptions()).onSubmit) == null ? void 0 : _c.call(_b, values);
+      if (result && typeof result === "object" && "then" in result) {
+        const token = submitToken += 1;
+        submitting = true;
+        notify();
+        result.then(
+          () => {
+            if (token !== submitToken) return;
+            submitting = false;
+            notify();
+          },
+          (err) => {
+            if (token !== submitToken) return;
+            submitting = false;
+            submitError = err;
+            notify();
+          }
+        );
+      }
+    },
+    isSubmitting: () => submitting,
+    getSubmitError: () => submitError,
+    push: ((name, item) => {
+      const arr = getByPath(values, name);
+      const newArr = Array.isArray(arr) ? [...arr, item] : [item];
+      values = setByPath(values, name, newArr);
+      touched.add(name);
+      if (getValidateOn() === "change") {
+        errors = runValidation();
+      }
+      notify();
+    }),
+    remove: (name, index) => {
+      const arr = getByPath(values, name);
+      if (Array.isArray(arr)) {
+        const newArr = arr.filter((_, i) => i !== index);
+        values = setByPath(values, name, newArr);
+        touched.add(name);
+        if (getValidateOn() === "change") {
+          errors = runValidation();
+        }
+        notify();
+      }
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getSnapshot: () => version
+  };
+  return store;
+}
+function useFormStore(options) {
+  const optionsRef = useRef16(options);
+  optionsRef.current = options;
+  const storeRef = useRef16(void 0);
+  if (!storeRef.current) {
+    storeRef.current = createFormStore(optionsRef);
+  }
+  useSyncExternalStore2(
+    storeRef.current.subscribe,
+    storeRef.current.getSnapshot,
+    storeRef.current.getSnapshot
+  );
+  return storeRef.current;
+}
+function useFieldValue(store, name) {
+  const getSnapshot = useCallback22(
+    () => store.getValue(name),
+    [store, name]
+  );
+  useSyncExternalStore2(store.subscribe, getSnapshot, getSnapshot);
+  return store.getValue(name);
+}
+var noopSubscribe = () => () => {
+};
+function useFieldValueMaybe(store, name) {
+  const subscribe = useCallback22(
+    (cb) => store ? store.subscribe(cb) : noopSubscribe(),
+    [store]
+  );
+  const getSnapshot = useCallback22(
+    () => store ? store.getValue(name) : void 0,
+    [store, name]
+  );
+  return useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+}
+function useStoreSubscription(store) {
+  const subscribe = useCallback22(
+    (cb) => store ? store.subscribe(cb) : noopSubscribe(),
+    [store]
+  );
+  const getSnapshot = useCallback22(
+    () => store ? store.getSnapshot() : 0,
+    [store]
+  );
+  useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/form/form-context.tsx
+import { createContext as createContext15, useContext as useContext15 } from "react";
+import { jsx as jsx22 } from "react/jsx-runtime";
+var FormContext = createContext15(null);
+function FormProvider({
+  store,
+  children
+}) {
+  return /* @__PURE__ */ jsx22(FormContext.Provider, { value: store, children });
+}
+function useFormContext() {
+  return useContext15(FormContext);
+}
+
+// src/form/form-primitives.tsx
+import {
+  createContext as createContext16,
+  forwardRef as forwardRef15,
+  useCallback as useCallback23,
+  useContext as useContext16,
+  useEffect as useEffect15,
+  useMemo as useMemo6,
+  useRef as useRef17,
+  useState as useState13
+} from "react";
+import { jsx as jsx23 } from "react/jsx-runtime";
+function useRegisterControl(form, name, forwardedRef) {
+  const elRef = useRef17(null);
+  useEffect15(() => {
+    if (!form) return;
+    return form.registerControl(name, () => elRef.current);
+  }, [form, name]);
+  return useMemo6(
+    () => mergeRefs((node) => {
+      elRef.current = node;
+    }, forwardedRef),
+    [forwardedRef]
+  );
+}
+var FormFieldContext = createContext16(null);
+function useFormField() {
+  return useContext16(FormFieldContext);
+}
+function composeDescribedBy(field, hasError, own) {
+  const ids = [
+    own,
+    hasError && field ? field.errorId : null,
+    (field == null ? void 0 : field.hasDescription) ? field.descriptionId : null
+  ].filter(Boolean);
+  return ids.length ? ids.join(" ") : void 0;
+}
+function FormRoot(_a) {
+  var _b = _a, { onSubmit } = _b, props = __objRest(_b, ["onSubmit"]);
+  const form = useFormContext();
+  return /* @__PURE__ */ jsx23(
+    "form",
+    __spreadValues({
+      onSubmit: (e) => {
+        e.preventDefault();
+        form == null ? void 0 : form.submit();
+        onSubmit == null ? void 0 : onSubmit(e);
+      }
+    }, props)
+  );
+}
+function FormField(_a) {
+  var _b = _a, { name } = _b, props = __objRest(_b, ["name"]);
+  const base = useId();
+  const [hasDescription, setHasDescription] = useState13(false);
+  const ctx = useMemo6(
+    () => ({
+      name,
+      inputId: `${base}-input`,
+      errorId: `${base}-error`,
+      descriptionId: `${base}-description`,
+      hasDescription,
+      setHasDescription
+    }),
+    [name, base, hasDescription]
+  );
+  return /* @__PURE__ */ jsx23(FormFieldContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx23("div", __spreadValues({}, props)) });
+}
+function FormLabel(_a) {
+  var _b = _a, { htmlFor, name: _name } = _b, props = __objRest(_b, ["htmlFor", "name"]);
+  const field = useFormField();
+  return /* @__PURE__ */ jsx23("label", __spreadValues({ htmlFor: htmlFor != null ? htmlFor : field == null ? void 0 : field.inputId }, props));
+}
+var FormInput = forwardRef15(
+  (_a, ref) => {
+    var _b = _a, { name, id, onChange, "aria-describedby": ariaDescribedBy } = _b, props = __objRest(_b, ["name", "id", "onChange", "aria-describedby"]);
+    var _a2;
+    const form = useFormContext();
+    const field = useFormField();
+    const value = (_a2 = useFieldValueMaybe(form, name)) != null ? _a2 : "";
+    const error = form == null ? void 0 : form.getError(name);
+    const touched = form == null ? void 0 : form.getFieldTouched(name);
+    const hasError = Boolean(error && touched);
+    const setRef = useRegisterControl(form, name, ref);
+    const handleChange = useCallback23(
+      (e) => {
+        const el = e.target;
+        let next = el.value;
+        if (el.type === "number" && el.value !== "") {
+          next = Number.isNaN(el.valueAsNumber) ? el.value : el.valueAsNumber;
+        }
+        form == null ? void 0 : form.setValue(name, next);
+        onChange == null ? void 0 : onChange(e);
+      },
+      [form, name, onChange]
+    );
+    return /* @__PURE__ */ jsx23(
+      "input",
+      __spreadValues({
+        ref: setRef,
+        id: id != null ? id : field == null ? void 0 : field.inputId,
+        name,
+        value,
+        onChange: handleChange,
+        onBlur: () => form == null ? void 0 : form.setFieldTouched(name, true),
+        "aria-invalid": hasError || void 0,
+        "aria-describedby": composeDescribedBy(field, hasError, ariaDescribedBy)
+      }, props)
+    );
+  }
+);
+FormInput.displayName = "FormInput";
+var FormTextarea = forwardRef15(
+  (_a, ref) => {
+    var _b = _a, { name, id, onChange, "aria-describedby": ariaDescribedBy } = _b, props = __objRest(_b, ["name", "id", "onChange", "aria-describedby"]);
+    var _a2;
+    const form = useFormContext();
+    const field = useFormField();
+    const value = (_a2 = useFieldValueMaybe(form, name)) != null ? _a2 : "";
+    const error = form == null ? void 0 : form.getError(name);
+    const touched = form == null ? void 0 : form.getFieldTouched(name);
+    const hasError = Boolean(error && touched);
+    const setRef = useRegisterControl(form, name, ref);
+    const handleChange = useCallback23(
+      (e) => {
+        form == null ? void 0 : form.setValue(name, e.target.value);
+        onChange == null ? void 0 : onChange(e);
+      },
+      [form, name, onChange]
+    );
+    return /* @__PURE__ */ jsx23(
+      "textarea",
+      __spreadValues({
+        ref: setRef,
+        id: id != null ? id : field == null ? void 0 : field.inputId,
+        name,
+        value,
+        onChange: handleChange,
+        onBlur: () => form == null ? void 0 : form.setFieldTouched(name, true),
+        "aria-invalid": hasError || void 0,
+        "aria-describedby": composeDescribedBy(field, hasError, ariaDescribedBy)
+      }, props)
+    );
+  }
+);
+FormTextarea.displayName = "FormTextarea";
+var FormSelect = forwardRef15(
+  (_a, ref) => {
+    var _b = _a, {
+      name,
+      id,
+      onChange,
+      "aria-describedby": ariaDescribedBy,
+      children
+    } = _b, props = __objRest(_b, [
+      "name",
+      "id",
+      "onChange",
+      "aria-describedby",
+      "children"
+    ]);
+    var _a2;
+    const form = useFormContext();
+    const field = useFormField();
+    const value = (_a2 = useFieldValueMaybe(form, name)) != null ? _a2 : "";
+    const error = form == null ? void 0 : form.getError(name);
+    const touched = form == null ? void 0 : form.getFieldTouched(name);
+    const hasError = Boolean(error && touched);
+    const setRef = useRegisterControl(form, name, ref);
+    const handleChange = useCallback23(
+      (e) => {
+        form == null ? void 0 : form.setValue(name, e.target.value);
+        onChange == null ? void 0 : onChange(e);
+      },
+      [form, name, onChange]
+    );
+    return /* @__PURE__ */ jsx23(
+      "select",
+      __spreadProps(__spreadValues({
+        ref: setRef,
+        id: id != null ? id : field == null ? void 0 : field.inputId,
+        name,
+        value,
+        onChange: handleChange,
+        onBlur: () => form == null ? void 0 : form.setFieldTouched(name, true),
+        "aria-invalid": hasError || void 0,
+        "aria-describedby": composeDescribedBy(field, hasError, ariaDescribedBy)
+      }, props), {
+        children
+      })
+    );
+  }
+);
+FormSelect.displayName = "FormSelect";
+var FormSwitch = forwardRef15(
+  (_a, ref) => {
+    var _b = _a, { name, onClick, onBlur, "aria-describedby": ariaDescribedBy } = _b, props = __objRest(_b, ["name", "onClick", "onBlur", "aria-describedby"]);
+    const form = useFormContext();
+    const field = useFormField();
+    const checked = Boolean(useFieldValueMaybe(form, name));
+    const error = form == null ? void 0 : form.getError(name);
+    const touched = form == null ? void 0 : form.getFieldTouched(name);
+    const hasError = Boolean(error && touched);
+    const handleClick = useCallback23(
+      (e) => {
+        form == null ? void 0 : form.setValue(name, !checked);
+        onClick == null ? void 0 : onClick(e);
+      },
+      [form, name, checked, onClick]
+    );
+    return /* @__PURE__ */ jsx23(
+      "button",
+      __spreadValues({
+        ref,
+        type: "button",
+        role: "switch",
+        "aria-checked": checked,
+        "aria-describedby": composeDescribedBy(field, hasError, ariaDescribedBy),
+        onClick: handleClick,
+        onBlur: (e) => {
+          form == null ? void 0 : form.setFieldTouched(name, true);
+          onBlur == null ? void 0 : onBlur(e);
+        }
+      }, props)
+    );
+  }
+);
+FormSwitch.displayName = "FormSwitch";
+var FormCheckbox = forwardRef15(
+  (_a, ref) => {
+    var _b = _a, {
+      name,
+      value,
+      onChange,
+      onBlur,
+      "aria-describedby": ariaDescribedBy
+    } = _b, props = __objRest(_b, [
+      "name",
+      "value",
+      "onChange",
+      "onBlur",
+      "aria-describedby"
+    ]);
+    const form = useFormContext();
+    const field = useFormField();
+    const fieldValue = useFieldValueMaybe(form, name);
+    const checked = value ? Array.isArray(fieldValue) && fieldValue.includes(value) : Boolean(fieldValue);
+    const error = form == null ? void 0 : form.getError(name);
+    const touched = form == null ? void 0 : form.getFieldTouched(name);
+    const hasError = Boolean(error && touched);
+    const handleChange = useCallback23(
+      (e) => {
+        if (value && Array.isArray(fieldValue)) {
+          const newArr = e.target.checked ? [...fieldValue, value] : fieldValue.filter((v) => v !== value);
+          form == null ? void 0 : form.setValue(name, newArr);
+        } else if (value) {
+          form == null ? void 0 : form.setValue(name, e.target.checked ? [value] : []);
+        } else {
+          form == null ? void 0 : form.setValue(name, e.target.checked);
+        }
+        onChange == null ? void 0 : onChange(e);
+      },
+      [form, name, value, fieldValue, onChange]
+    );
+    return /* @__PURE__ */ jsx23(
+      "input",
+      __spreadValues({
+        ref,
+        type: "checkbox",
+        name,
+        checked,
+        onChange: handleChange,
+        onBlur: (e) => {
+          form == null ? void 0 : form.setFieldTouched(name, true);
+          onBlur == null ? void 0 : onBlur(e);
+        },
+        "aria-invalid": hasError || void 0,
+        "aria-describedby": composeDescribedBy(field, hasError, ariaDescribedBy)
+      }, props)
+    );
+  }
+);
+FormCheckbox.displayName = "FormCheckbox";
+function FormRadioGroup(_a) {
+  var _b = _a, { name: _name } = _b, props = __objRest(_b, ["name"]);
+  return /* @__PURE__ */ jsx23("div", __spreadValues({ role: "radiogroup" }, props));
+}
+var FormRadio = forwardRef15(
+  (_a, ref) => {
+    var _b = _a, {
+      name,
+      value,
+      onChange,
+      onBlur,
+      "aria-describedby": ariaDescribedBy
+    } = _b, props = __objRest(_b, [
+      "name",
+      "value",
+      "onChange",
+      "onBlur",
+      "aria-describedby"
+    ]);
+    const form = useFormContext();
+    const field = useFormField();
+    const fieldValue = useFieldValueMaybe(form, name);
+    const checked = fieldValue === value;
+    const error = form == null ? void 0 : form.getError(name);
+    const touched = form == null ? void 0 : form.getFieldTouched(name);
+    const hasError = Boolean(error && touched);
+    const handleChange = useCallback23(
+      (e) => {
+        form == null ? void 0 : form.setValue(name, value);
+        onChange == null ? void 0 : onChange(e);
+      },
+      [form, name, value, onChange]
+    );
+    return /* @__PURE__ */ jsx23(
+      "input",
+      __spreadValues({
+        ref,
+        type: "radio",
+        name,
+        value,
+        checked,
+        onChange: handleChange,
+        onBlur: (e) => {
+          form == null ? void 0 : form.setFieldTouched(name, true);
+          onBlur == null ? void 0 : onBlur(e);
+        },
+        "aria-invalid": hasError || void 0,
+        "aria-describedby": composeDescribedBy(field, hasError, ariaDescribedBy)
+      }, props)
+    );
+  }
+);
+FormRadio.displayName = "FormRadio";
+function FormDescription(_a) {
+  var _b = _a, {
+    name: _name
+  } = _b, props = __objRest(_b, [
+    "name"
+  ]);
+  const field = useFormField();
+  const setHasDescription = field == null ? void 0 : field.setHasDescription;
+  useEffect15(() => {
+    setHasDescription == null ? void 0 : setHasDescription(true);
+    return () => setHasDescription == null ? void 0 : setHasDescription(false);
+  }, [setHasDescription]);
+  return /* @__PURE__ */ jsx23("p", __spreadValues({ id: field == null ? void 0 : field.descriptionId }, props));
+}
+function FormError(_a) {
+  var _b = _a, { name, children } = _b, props = __objRest(_b, ["name", "children"]);
+  const form = useFormContext();
+  const field = useFormField();
+  useStoreSubscription(form);
+  const error = form == null ? void 0 : form.getError(name);
+  const touched = form == null ? void 0 : form.getFieldTouched(name);
+  if (!error || !touched) return null;
+  return /* @__PURE__ */ jsx23("p", __spreadProps(__spreadValues({ id: field == null ? void 0 : field.errorId, role: "alert" }, props), { children: children != null ? children : error }));
+}
+var FormControl = FormInput;
+function FormSubmit(_a) {
+  var _b = _a, {
+    type = "submit",
+    disabled
+  } = _b, props = __objRest(_b, [
+    "type",
+    "disabled"
+  ]);
+  const form = useFormContext();
+  useStoreSubscription(form);
+  return /* @__PURE__ */ jsx23(
+    "button",
+    __spreadValues({
+      type,
+      disabled: disabled != null ? disabled : form == null ? void 0 : form.isSubmitting()
+    }, props)
+  );
+}
+function FormReset(_a) {
+  var _b = _a, { onClick } = _b, props = __objRest(_b, ["onClick"]);
+  const form = useFormContext();
+  const handleClick = useCallback23(
+    (e) => {
+      form == null ? void 0 : form.reset();
+      onClick == null ? void 0 : onClick(e);
+    },
+    [form, onClick]
+  );
+  return /* @__PURE__ */ jsx23("button", __spreadValues({ type: "button", onClick: handleClick }, props));
+}
+function FormPush(_a) {
+  var _b = _a, { name, value, onClick } = _b, props = __objRest(_b, ["name", "value", "onClick"]);
+  const form = useFormContext();
+  const handleClick = useCallback23(
+    (e) => {
+      form == null ? void 0 : form.push(name, value);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [form, name, value, onClick]
+  );
+  return /* @__PURE__ */ jsx23("button", __spreadValues({ type: "button", onClick: handleClick }, props));
+}
+function FormRemove(_a) {
+  var _b = _a, {
+    name,
+    index,
+    onClick
+  } = _b, props = __objRest(_b, [
+    "name",
+    "index",
+    "onClick"
+  ]);
+  const form = useFormContext();
+  const handleClick = useCallback23(
+    (e) => {
+      form == null ? void 0 : form.remove(name, index);
+      onClick == null ? void 0 : onClick(e);
+    },
+    [form, name, index, onClick]
+  );
+  return /* @__PURE__ */ jsx23("button", __spreadValues({ type: "button", onClick: handleClick }, props));
+}
+function FormGroup(props) {
+  return /* @__PURE__ */ jsx23("fieldset", __spreadValues({}, props));
+}
+function FormGroupLabel(props) {
+  return /* @__PURE__ */ jsx23("legend", __spreadValues({}, props));
+}
+export {
+  AccordionContent,
+  AccordionItem,
+  AccordionRoot,
+  AccordionTrigger,
+  AlertDialogPanel,
+  Button,
+  Checkbox,
+  ComboboxGroup,
+  ComboboxGroupLabel,
+  ComboboxInput,
+  ComboboxItem,
+  ComboboxPopover,
+  ComboboxRoot,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  CommandRoot,
+  CommandSeparator,
+  Composite,
+  CompositeItem,
+  CompositeProvider,
+  CompositeRow,
+  DialogDescription,
+  DialogDisclosure,
+  DialogDismiss,
+  DialogHeading,
+  DialogPanel,
+  DialogRoot,
+  DisclosureContent,
+  DisclosureRoot,
+  DisclosureTrigger,
+  FormCheckbox,
+  FormControl,
+  FormDescription,
+  FormError,
+  FormField,
+  FormGroup,
+  FormGroupLabel,
+  FormInput,
+  FormLabel,
+  FormProvider,
+  FormPush,
+  FormRadio,
+  FormRadioGroup,
+  FormRemove,
+  FormReset,
+  FormRoot,
+  FormSelect,
+  FormSubmit,
+  FormSwitch,
+  FormTextarea,
+  MenuButtonArrow,
+  MenuItem,
+  MenuItemCheckbox,
+  MenuItemRadio,
+  MenuPopover,
+  MenuRoot,
+  MenuSeparator,
+  MenuTrigger,
+  MenubarContainer,
+  MenubarRoot,
+  Meter,
+  PopoverClose,
+  PopoverContent,
+  PopoverRoot,
+  PopoverTrigger,
+  Progress,
+  Radio,
+  RadioGroupRoot,
+  SelectItem,
+  SelectLabel,
+  SelectPopover,
+  SelectRoot,
+  SelectTrigger,
+  Separator,
+  Switch,
+  Tab,
+  TabList,
+  TabPanel,
+  TabsRoot,
+  Toggle,
+  ToggleGroup,
+  ToolbarButton,
+  ToolbarContainer,
+  ToolbarRoot,
+  ToolbarSeparator,
+  Tooltip,
+  TooltipAnchor,
+  TooltipProvider,
+  useCommandState,
+  useControllableState,
+  useDialogClose,
+  useEnterLeave,
+  useFieldValue,
+  useFloating,
+  useFocusVisible,
+  useFocusableWhenDisabled,
+  useFormContext,
+  useFormStore,
+  useId,
+  useMenubarContext,
+  useRadioGroupContext,
+  useRovingTabindex,
+  useScrollActiveDescendantIntoView
+};