@octaviaflow/core 3.1.0-beta.115 → 3.1.0-beta.117

package/dist/chunk-23K2RF7Z.js

@@ -0,0 +1,2694 @@
+import {
+  cn
+} from "./chunk-ZAUUGK2Y.js";
+
+// src/components/Accordion/Accordion.tsx
+import { ChevronDownIcon } from "@octaviaflow/icons";
+import { AnimatePresence, motion, useReducedMotion } from "framer-motion";
+import {
+  forwardRef,
+  useCallback,
+  useId,
+  useState
+} from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Accordion = forwardRef(function Accordion2({
+  items,
+  mode = "single",
+  value: controlledValue,
+  defaultValue,
+  onValueChange,
+  collapsible = true,
+  variant = "default",
+  size = "md",
+  disabled = false,
+  id: providedId,
+  className,
+  ...rest
+}, ref) {
+  const reactId = useId();
+  const baseId = providedId ?? `ods-accordion-${reactId}`;
+  const reducedMotion = useReducedMotion();
+  const [internalValue, setInternalValue] = useState(defaultValue ?? []);
+  const isControlled = controlledValue !== void 0;
+  const value = isControlled ? controlledValue : internalValue;
+  const valueSet = new Set(value);
+  const setValue = useCallback(
+    (next) => {
+      if (!isControlled) setInternalValue(next);
+      onValueChange?.(next);
+    },
+    [isControlled, onValueChange]
+  );
+  const toggleItem = useCallback(
+    (id) => {
+      const isOpen = valueSet.has(id);
+      if (mode === "multiple") {
+        const next = isOpen ? value.filter((v) => v !== id) : [...value, id];
+        setValue(next);
+        return;
+      }
+      if (isOpen) {
+        if (collapsible) setValue([]);
+        return;
+      }
+      setValue([id]);
+    },
+    [collapsible, mode, setValue, value, valueSet]
+  );
+  const handleKeyDown = (e, index) => {
+    const enabledIdx = items.map((it, i) => it.disabled ? -1 : i).filter((i) => i !== -1);
+    const curr = enabledIdx.indexOf(index);
+    const focusIdx = (i) => {
+      const target = enabledIdx[i];
+      if (target === void 0) return;
+      const btn = document.getElementById(`${baseId}-trigger-${items[target].id}`);
+      btn?.focus();
+    };
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      focusIdx((curr + 1) % enabledIdx.length);
+    } else if (e.key === "ArrowUp") {
+      e.preventDefault();
+      focusIdx((curr - 1 + enabledIdx.length) % enabledIdx.length);
+    } else if (e.key === "Home") {
+      e.preventDefault();
+      focusIdx(0);
+    } else if (e.key === "End") {
+      e.preventDefault();
+      focusIdx(enabledIdx.length - 1);
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ...rest,
+      ref,
+      id: baseId,
+      className: cn(
+        "ods-accordion",
+        `ods-accordion--${variant}`,
+        `ods-accordion--${size}`,
+        disabled && "ods-accordion--disabled",
+        className
+      ),
+      children: items.map((item, i) => {
+        const isOpen = valueSet.has(item.id);
+        const itemDisabled = item.disabled || disabled;
+        const triggerId = `${baseId}-trigger-${item.id}`;
+        const panelId = `${baseId}-panel-${item.id}`;
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: cn(
+              "ods-accordion__item",
+              isOpen && "ods-accordion__item--open",
+              itemDisabled && "ods-accordion__item--disabled"
+            ),
+            children: [
+              /* @__PURE__ */ jsxs(
+                "button",
+                {
+                  id: triggerId,
+                  type: "button",
+                  className: "ods-accordion__trigger",
+                  "aria-expanded": isOpen,
+                  "aria-controls": panelId,
+                  disabled: itemDisabled,
+                  onClick: () => toggleItem(item.id),
+                  onKeyDown: (e) => handleKeyDown(e, i),
+                  children: [
+                    item.icon && /* @__PURE__ */ jsx("span", { className: "ods-accordion__icon", "aria-hidden": "true", children: item.icon }),
+                    /* @__PURE__ */ jsxs("span", { className: "ods-accordion__label-wrap", children: [
+                      /* @__PURE__ */ jsx("span", { className: "ods-accordion__label", children: item.label }),
+                      item.description && /* @__PURE__ */ jsx("span", { className: "ods-accordion__description", children: item.description })
+                    ] }),
+                    item.trailing && /* @__PURE__ */ jsx("span", { className: "ods-accordion__trailing", onClick: (e) => e.stopPropagation(), children: item.trailing }),
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        className: cn("ods-accordion__chevron", isOpen && "ods-accordion__chevron--open"),
+                        "aria-hidden": "true",
+                        children: /* @__PURE__ */ jsx(ChevronDownIcon, { size: "sm", "aria-hidden": true })
+                      }
+                    )
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx(AnimatePresence, { initial: false, children: isOpen && /* @__PURE__ */ jsx(
+                motion.div,
+                {
+                  role: "region",
+                  id: panelId,
+                  "aria-labelledby": triggerId,
+                  className: "ods-accordion__panel",
+                  initial: reducedMotion ? false : { height: 0, opacity: 0 },
+                  animate: reducedMotion ? void 0 : { height: "auto", opacity: 1 },
+                  exit: reducedMotion ? void 0 : { height: 0, opacity: 0 },
+                  transition: reducedMotion ? { duration: 0 } : { duration: 0.18 },
+                  style: { overflow: "hidden" },
+                  children: /* @__PURE__ */ jsx("div", { className: "ods-accordion__content", children: item.content })
+                }
+              ) })
+            ]
+          },
+          item.id
+        );
+      })
+    }
+  );
+});
+Accordion.displayName = "Accordion";
+
+// src/components/Tooltip/Tooltip.tsx
+import { AnimatePresence as AnimatePresence2, motion as motion2 } from "framer-motion";
+import {
+  cloneElement,
+  isValidElement,
+  useCallback as useCallback2,
+  useEffect,
+  useId as useId2,
+  useLayoutEffect,
+  useRef,
+  useState as useState2
+} from "react";
+import { useTooltip, useTooltipTrigger } from "react-aria";
+import { createPortal } from "react-dom";
+
+// ../../node_modules/react-stately/dist/private/utils/useControlledState.mjs
+import $1CcWn$react, { useState as $1CcWn$useState, useRef as $1CcWn$useRef, useEffect as $1CcWn$useEffect, useReducer as $1CcWn$useReducer, useCallback as $1CcWn$useCallback } from "react";
+var $3e6197669829fe11$var$useEarlyEffect = typeof document !== "undefined" ? (0, $1CcWn$react)["useInsertionEffect"] ?? (0, $1CcWn$react).useLayoutEffect : () => {
+};
+function $3e6197669829fe11$export$40bfa8c7b0832715(value, defaultValue, onChange) {
+  let [stateValue, setStateValue] = (0, $1CcWn$useState)(value || defaultValue);
+  let valueRef = (0, $1CcWn$useRef)(stateValue);
+  let isControlledRef = (0, $1CcWn$useRef)(value !== void 0);
+  let isControlled = value !== void 0;
+  (0, $1CcWn$useEffect)(() => {
+    let wasControlled = isControlledRef.current;
+    if (wasControlled !== isControlled && process.env.NODE_ENV !== "production") console.warn(`WARN: A component changed from ${wasControlled ? "controlled" : "uncontrolled"} to ${isControlled ? "controlled" : "uncontrolled"}.`);
+    isControlledRef.current = isControlled;
+  }, [
+    isControlled
+  ]);
+  let currentValue = isControlled ? value : stateValue;
+  $3e6197669829fe11$var$useEarlyEffect(() => {
+    valueRef.current = currentValue;
+  });
+  let [, forceUpdate] = (0, $1CcWn$useReducer)(() => ({}), {});
+  let setValue = (0, $1CcWn$useCallback)((value2, ...args) => {
+    let newValue = typeof value2 === "function" ? value2(valueRef.current) : value2;
+    if (!Object.is(valueRef.current, newValue)) {
+      valueRef.current = newValue;
+      setStateValue(newValue);
+      forceUpdate();
+      onChange?.(newValue, ...args);
+    }
+  }, [
+    onChange
+  ]);
+  return [
+    currentValue,
+    setValue
+  ];
+}
+
+// ../../node_modules/react-stately/dist/private/form/useFormValidationState.mjs
+import { createContext as $8AuPP$createContext, useMemo as $8AuPP$useMemo, useContext as $8AuPP$useContext, useState as $8AuPP$useState, useRef as $8AuPP$useRef, useEffect as $8AuPP$useEffect } from "react";
+var $fd2148440a13ec26$export$aca958c65c314e6c = {
+  badInput: false,
+  customError: false,
+  patternMismatch: false,
+  rangeOverflow: false,
+  rangeUnderflow: false,
+  stepMismatch: false,
+  tooLong: false,
+  tooShort: false,
+  typeMismatch: false,
+  valueMissing: false,
+  valid: true
+};
+var $fd2148440a13ec26$var$CUSTOM_VALIDITY_STATE = {
+  ...$fd2148440a13ec26$export$aca958c65c314e6c,
+  customError: true,
+  valid: false
+};
+var $fd2148440a13ec26$export$dad6ae84456c676a = {
+  isInvalid: false,
+  validationDetails: $fd2148440a13ec26$export$aca958c65c314e6c,
+  validationErrors: []
+};
+var $fd2148440a13ec26$export$571b5131b7e65c11 = (0, $8AuPP$createContext)({});
+var $fd2148440a13ec26$export$a763b9476acd3eb = "__reactAriaFormValidationState";
+function $fd2148440a13ec26$export$fc1a364ae1f3ff10(props) {
+  if (props[$fd2148440a13ec26$export$a763b9476acd3eb]) {
+    let { realtimeValidation, displayValidation, updateValidation, resetValidation, commitValidation } = props[$fd2148440a13ec26$export$a763b9476acd3eb];
+    return {
+      realtimeValidation,
+      displayValidation,
+      updateValidation,
+      resetValidation,
+      commitValidation
+    };
+  }
+  return $fd2148440a13ec26$var$useFormValidationStateImpl(props);
+}
+function $fd2148440a13ec26$var$useFormValidationStateImpl(props) {
+  let { isInvalid, validationState, name, value, builtinValidation, validate, validationBehavior = "aria" } = props;
+  if (validationState) isInvalid ||= validationState === "invalid";
+  let controlledError = isInvalid !== void 0 ? {
+    isInvalid,
+    validationErrors: [],
+    validationDetails: $fd2148440a13ec26$var$CUSTOM_VALIDITY_STATE
+  } : null;
+  let clientError = (0, $8AuPP$useMemo)(() => {
+    if (!validate || value == null) return null;
+    let validateErrors = $fd2148440a13ec26$var$runValidate(validate, value);
+    return $fd2148440a13ec26$var$getValidationResult(validateErrors);
+  }, [
+    validate,
+    value
+  ]);
+  if (builtinValidation?.validationDetails.valid) builtinValidation = void 0;
+  let serverErrors = (0, $8AuPP$useContext)($fd2148440a13ec26$export$571b5131b7e65c11);
+  let serverErrorMessages = (0, $8AuPP$useMemo)(() => {
+    if (name) return Array.isArray(name) ? name.flatMap((name2) => $fd2148440a13ec26$var$asArray(serverErrors[name2])) : $fd2148440a13ec26$var$asArray(serverErrors[name]);
+    return [];
+  }, [
+    serverErrors,
+    name
+  ]);
+  let [lastServerErrors, setLastServerErrors] = (0, $8AuPP$useState)(serverErrors);
+  let [isServerErrorCleared, setServerErrorCleared] = (0, $8AuPP$useState)(false);
+  if (serverErrors !== lastServerErrors) {
+    setLastServerErrors(serverErrors);
+    setServerErrorCleared(false);
+  }
+  let serverError = (0, $8AuPP$useMemo)(() => $fd2148440a13ec26$var$getValidationResult(isServerErrorCleared ? [] : serverErrorMessages), [
+    isServerErrorCleared,
+    serverErrorMessages
+  ]);
+  let nextValidation = (0, $8AuPP$useRef)($fd2148440a13ec26$export$dad6ae84456c676a);
+  let [currentValidity, setCurrentValidity] = (0, $8AuPP$useState)($fd2148440a13ec26$export$dad6ae84456c676a);
+  let lastError = (0, $8AuPP$useRef)($fd2148440a13ec26$export$dad6ae84456c676a);
+  let commitValidation = () => {
+    if (!commitQueued) return;
+    setCommitQueued(false);
+    let error = clientError || builtinValidation || nextValidation.current;
+    if (!$fd2148440a13ec26$var$isEqualValidation(error, lastError.current)) {
+      lastError.current = error;
+      setCurrentValidity(error);
+    }
+  };
+  let [commitQueued, setCommitQueued] = (0, $8AuPP$useState)(false);
+  (0, $8AuPP$useEffect)(commitValidation);
+  let realtimeValidation = controlledError || serverError || clientError || builtinValidation || $fd2148440a13ec26$export$dad6ae84456c676a;
+  let displayValidation = validationBehavior === "native" ? controlledError || serverError || currentValidity : controlledError || serverError || clientError || builtinValidation || currentValidity;
+  return {
+    realtimeValidation,
+    displayValidation,
+    updateValidation(value2) {
+      if (validationBehavior === "aria" && !$fd2148440a13ec26$var$isEqualValidation(currentValidity, value2)) setCurrentValidity(value2);
+      else nextValidation.current = value2;
+    },
+    resetValidation() {
+      let error = $fd2148440a13ec26$export$dad6ae84456c676a;
+      if (!$fd2148440a13ec26$var$isEqualValidation(error, lastError.current)) {
+        lastError.current = error;
+        setCurrentValidity(error);
+      }
+      if (validationBehavior === "native") setCommitQueued(false);
+      setServerErrorCleared(true);
+    },
+    commitValidation() {
+      if (validationBehavior === "native") setCommitQueued(true);
+      setServerErrorCleared(true);
+    }
+  };
+}
+function $fd2148440a13ec26$var$asArray(v) {
+  if (!v) return [];
+  return Array.isArray(v) ? v : [
+    v
+  ];
+}
+function $fd2148440a13ec26$var$runValidate(validate, value) {
+  if (typeof validate === "function") {
+    let e = validate(value);
+    if (e && typeof e !== "boolean") return $fd2148440a13ec26$var$asArray(e);
+  }
+  return [];
+}
+function $fd2148440a13ec26$var$getValidationResult(errors) {
+  return errors.length ? {
+    isInvalid: true,
+    validationErrors: errors,
+    validationDetails: $fd2148440a13ec26$var$CUSTOM_VALIDITY_STATE
+  } : null;
+}
+function $fd2148440a13ec26$var$isEqualValidation(a, b) {
+  if (a === b) return true;
+  return !!a && !!b && a.isInvalid === b.isInvalid && a.validationErrors.length === b.validationErrors.length && a.validationErrors.every((a2, i) => a2 === b.validationErrors[i]) && Object.entries(a.validationDetails).every(([k, v]) => b.validationDetails[k] === v);
+}
+
+// ../../node_modules/react-stately/dist/private/collections/getChildNodes.mjs
+function $cd5ea4b915021f1d$export$1005530eda016c13(node, collection) {
+  if (typeof collection.getChildren === "function") return collection.getChildren(node.key);
+  return node.childNodes;
+}
+function $cd5ea4b915021f1d$export$fbdeaa6a76694f71(iterable) {
+  return $cd5ea4b915021f1d$export$5f3398f8733f90e2(iterable, 0);
+}
+function $cd5ea4b915021f1d$export$5f3398f8733f90e2(iterable, index) {
+  if (index < 0) return void 0;
+  let i = 0;
+  for (let item of iterable) {
+    if (i === index) return item;
+    i++;
+  }
+}
+function $cd5ea4b915021f1d$export$8c434b3a7a4dad6(collection, a, b) {
+  if (a.parentKey === b.parentKey) return a.index - b.index;
+  let aAncestors = [
+    ...$cd5ea4b915021f1d$var$getAncestors(collection, a),
+    a
+  ];
+  let bAncestors = [
+    ...$cd5ea4b915021f1d$var$getAncestors(collection, b),
+    b
+  ];
+  let firstNonMatchingAncestor = aAncestors.slice(0, bAncestors.length).findIndex((a2, i) => a2 !== bAncestors[i]);
+  if (firstNonMatchingAncestor !== -1) {
+    a = aAncestors[firstNonMatchingAncestor];
+    b = bAncestors[firstNonMatchingAncestor];
+    return a.index - b.index;
+  }
+  if (aAncestors.findIndex((node) => node === b) >= 0) return 1;
+  else if (bAncestors.findIndex((node) => node === a) >= 0) return -1;
+  return -1;
+}
+function $cd5ea4b915021f1d$var$getAncestors(collection, node) {
+  let parents = [];
+  let currNode = node;
+  while (currNode?.parentKey != null) {
+    currNode = collection.getItem(currNode.parentKey);
+    if (currNode) parents.unshift(currNode);
+  }
+  return parents;
+}
+
+// ../../node_modules/react-stately/dist/private/list/ListCollection.mjs
+var $f664a81d022446b5$export$d085fb9e920b5ca7 = class {
+  constructor(nodes) {
+    this.keyMap = /* @__PURE__ */ new Map();
+    this.firstKey = null;
+    this.lastKey = null;
+    this.iterable = nodes;
+    let visit = (node) => {
+      this.keyMap.set(node.key, node);
+      if (node.childNodes && node.type === "section") for (let child of node.childNodes) visit(child);
+    };
+    for (let node of nodes) visit(node);
+    let last = null;
+    let index = 0;
+    let size = 0;
+    for (let [key, node] of this.keyMap) {
+      if (last) {
+        last.nextKey = key;
+        node.prevKey = last.key;
+      } else {
+        this.firstKey = key;
+        node.prevKey = void 0;
+      }
+      if (node.type === "item") node.index = index++;
+      if (node.type === "section" || node.type === "item") size++;
+      last = node;
+      last.nextKey = void 0;
+    }
+    this._size = size;
+    this.lastKey = last?.key ?? null;
+  }
+  *[Symbol.iterator]() {
+    yield* this.iterable;
+  }
+  get size() {
+    return this._size;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(key) {
+    let node = this.keyMap.get(key);
+    return node ? node.prevKey ?? null : null;
+  }
+  getKeyAfter(key) {
+    let node = this.keyMap.get(key);
+    return node ? node.nextKey ?? null : null;
+  }
+  getFirstKey() {
+    return this.firstKey;
+  }
+  getLastKey() {
+    return this.lastKey;
+  }
+  getItem(key) {
+    return this.keyMap.get(key) ?? null;
+  }
+  at(idx) {
+    const keys = [
+      ...this.getKeys()
+    ];
+    return this.getItem(keys[idx]);
+  }
+  getChildren(key) {
+    let node = this.keyMap.get(key);
+    return node?.childNodes || [];
+  }
+};
+
+// ../../node_modules/react-stately/dist/private/selection/Selection.mjs
+var $8b2540e09867b15e$export$52baac22726c72bf = class _$8b2540e09867b15e$export$52baac22726c72bf extends Set {
+  constructor(keys, anchorKey, currentKey) {
+    super(keys);
+    if (keys instanceof _$8b2540e09867b15e$export$52baac22726c72bf) {
+      this.anchorKey = anchorKey ?? keys.anchorKey;
+      this.currentKey = currentKey ?? keys.currentKey;
+    } else {
+      this.anchorKey = anchorKey ?? null;
+      this.currentKey = currentKey ?? null;
+    }
+  }
+};
+
+// ../../node_modules/react-stately/dist/private/selection/useMultipleSelectionState.mjs
+import { useRef as $7w3VE$useRef, useState as $7w3VE$useState, useMemo as $7w3VE$useMemo, useEffect as $7w3VE$useEffect } from "react";
+function $60f19cefd567a3e4$var$equalSets(setA, setB) {
+  if (setA.size !== setB.size) return false;
+  for (let item of setA) {
+    if (!setB.has(item)) return false;
+  }
+  return true;
+}
+function $60f19cefd567a3e4$export$253fe78d46329472(props) {
+  let { selectionMode = "none", disallowEmptySelection = false, allowDuplicateSelectionEvents, selectionBehavior: selectionBehaviorProp = "toggle", disabledBehavior = "all" } = props;
+  let isFocusedRef = (0, $7w3VE$useRef)(false);
+  let [, setFocused] = (0, $7w3VE$useState)(false);
+  let focusedKeyRef = (0, $7w3VE$useRef)(null);
+  let childFocusStrategyRef = (0, $7w3VE$useRef)(null);
+  let [, setFocusedKey] = (0, $7w3VE$useState)(null);
+  let selectedKeysProp = (0, $7w3VE$useMemo)(() => $60f19cefd567a3e4$var$convertSelection(props.selectedKeys), [
+    props.selectedKeys
+  ]);
+  let defaultSelectedKeys = (0, $7w3VE$useMemo)(() => $60f19cefd567a3e4$var$convertSelection(props.defaultSelectedKeys, new (0, $8b2540e09867b15e$export$52baac22726c72bf)()), [
+    props.defaultSelectedKeys
+  ]);
+  let [selectedKeys, setSelectedKeys] = (0, $3e6197669829fe11$export$40bfa8c7b0832715)(selectedKeysProp, defaultSelectedKeys, props.onSelectionChange);
+  let disabledKeysProp = (0, $7w3VE$useMemo)(() => props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set(), [
+    props.disabledKeys
+  ]);
+  let [selectionBehavior, setSelectionBehavior] = (0, $7w3VE$useState)(selectionBehaviorProp);
+  if (selectionBehaviorProp === "replace" && selectionBehavior === "toggle" && typeof selectedKeys === "object" && selectedKeys.size === 0) setSelectionBehavior("replace");
+  let lastSelectionBehavior = (0, $7w3VE$useRef)(selectionBehaviorProp);
+  (0, $7w3VE$useEffect)(() => {
+    if (selectionBehaviorProp !== lastSelectionBehavior.current) {
+      setSelectionBehavior(selectionBehaviorProp);
+      lastSelectionBehavior.current = selectionBehaviorProp;
+    }
+  }, [
+    selectionBehaviorProp
+  ]);
+  return {
+    selectionMode,
+    disallowEmptySelection,
+    selectionBehavior,
+    setSelectionBehavior,
+    get isFocused() {
+      return isFocusedRef.current;
+    },
+    setFocused(f) {
+      isFocusedRef.current = f;
+      setFocused(f);
+    },
+    get focusedKey() {
+      return focusedKeyRef.current;
+    },
+    get childFocusStrategy() {
+      return childFocusStrategyRef.current;
+    },
+    setFocusedKey(k, childFocusStrategy = "first") {
+      focusedKeyRef.current = k;
+      childFocusStrategyRef.current = childFocusStrategy;
+      setFocusedKey(k);
+    },
+    selectedKeys,
+    setSelectedKeys(keys) {
+      if (allowDuplicateSelectionEvents || !$60f19cefd567a3e4$var$equalSets(keys, selectedKeys)) setSelectedKeys(keys);
+    },
+    disabledKeys: disabledKeysProp,
+    disabledBehavior
+  };
+}
+function $60f19cefd567a3e4$var$convertSelection(selection, defaultValue) {
+  if (!selection) return defaultValue;
+  return selection === "all" ? "all" : new (0, $8b2540e09867b15e$export$52baac22726c72bf)(selection);
+}
+
+// ../../node_modules/react-stately/dist/private/selection/SelectionManager.mjs
+var $4a07ac835f260f78$export$6c8a5aaad13c9852 = class _$4a07ac835f260f78$export$6c8a5aaad13c9852 {
+  constructor(collection, state, options) {
+    this.collection = collection;
+    this.state = state;
+    this.allowsCellSelection = options?.allowsCellSelection ?? false;
+    this._isSelectAll = null;
+    this.layoutDelegate = options?.layoutDelegate || null;
+    this.fullCollection = options?.fullCollection || null;
+  }
+  /**
+  * The type of selection that is allowed in the collection.
+  */
+  get selectionMode() {
+    return this.state.selectionMode;
+  }
+  /**
+  * Whether the collection allows empty selection.
+  */
+  get disallowEmptySelection() {
+    return this.state.disallowEmptySelection;
+  }
+  /**
+  * The selection behavior for the collection.
+  */
+  get selectionBehavior() {
+    return this.state.selectionBehavior;
+  }
+  /**
+  * Sets the selection behavior for the collection.
+  */
+  setSelectionBehavior(selectionBehavior) {
+    this.state.setSelectionBehavior(selectionBehavior);
+  }
+  /**
+  * Whether the collection is currently focused.
+  */
+  get isFocused() {
+    return this.state.isFocused;
+  }
+  /**
+  * Sets whether the collection is focused.
+  */
+  setFocused(isFocused) {
+    this.state.setFocused(isFocused);
+  }
+  /**
+  * The current focused key in the collection.
+  */
+  get focusedKey() {
+    return this.state.focusedKey;
+  }
+  /** Whether the first or last child of the focused key should receive focus. */
+  get childFocusStrategy() {
+    return this.state.childFocusStrategy;
+  }
+  /**
+  * Sets the focused key.
+  */
+  setFocusedKey(key, childFocusStrategy) {
+    if (key == null || this.collection.getItem(key)) this.state.setFocusedKey(key, childFocusStrategy);
+  }
+  /**
+  * The currently selected keys in the collection.
+  */
+  get selectedKeys() {
+    return this.state.selectedKeys === "all" ? new Set(this.getSelectAllKeys()) : this.state.selectedKeys;
+  }
+  /**
+  * The raw selection value for the collection.
+  * Either 'all' for select all, or a set of keys.
+  */
+  get rawSelection() {
+    return this.state.selectedKeys;
+  }
+  /**
+  * Returns whether a key is selected.
+  */
+  isSelected(key) {
+    if (this.state.selectionMode === "none") return false;
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return false;
+    return this.state.selectedKeys === "all" ? this.canSelectItem(mappedKey) : this.state.selectedKeys.has(mappedKey);
+  }
+  /**
+  * Whether the selection is empty.
+  */
+  get isEmpty() {
+    return this.state.selectedKeys !== "all" && this.state.selectedKeys.size === 0;
+  }
+  /**
+  * Whether all items in the collection are selected.
+  */
+  get isSelectAll() {
+    if (this.isEmpty) return false;
+    if (this.state.selectedKeys === "all") return true;
+    if (this._isSelectAll != null) return this._isSelectAll;
+    let allKeys = this.getSelectAllKeys();
+    let selectedKeys = this.state.selectedKeys;
+    this._isSelectAll = allKeys.every((k) => selectedKeys.has(k));
+    return this._isSelectAll;
+  }
+  get firstSelectedKey() {
+    let first = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!first || item && (0, $cd5ea4b915021f1d$export$8c434b3a7a4dad6)(this.collection, item, first) < 0) first = item;
+    }
+    return first?.key ?? null;
+  }
+  get lastSelectedKey() {
+    let last = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!last || item && (0, $cd5ea4b915021f1d$export$8c434b3a7a4dad6)(this.collection, item, last) > 0) last = item;
+    }
+    return last?.key ?? null;
+  }
+  get disabledKeys() {
+    return this.state.disabledKeys;
+  }
+  get disabledBehavior() {
+    return this.state.disabledBehavior;
+  }
+  /**
+  * Extends the selection to the given key.
+  */
+  extendSelection(toKey) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      this.replaceSelection(toKey);
+      return;
+    }
+    let mappedToKey = this.getKey(toKey);
+    if (mappedToKey == null) return;
+    let selection;
+    if (this.state.selectedKeys === "all") selection = new (0, $8b2540e09867b15e$export$52baac22726c72bf)([
+      mappedToKey
+    ], mappedToKey, mappedToKey);
+    else {
+      let selectedKeys = this.state.selectedKeys;
+      let anchorKey = selectedKeys.anchorKey ?? mappedToKey;
+      selection = new (0, $8b2540e09867b15e$export$52baac22726c72bf)(selectedKeys, anchorKey, mappedToKey);
+      for (let key of this.getKeyRange(anchorKey, selectedKeys.currentKey ?? mappedToKey)) selection.delete(key);
+      for (let key of this.getKeyRange(mappedToKey, anchorKey)) if (this.canSelectItem(key)) selection.add(key);
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getKeyRange(from, to) {
+    let fromItem = this.collection.getItem(from);
+    let toItem = this.collection.getItem(to);
+    if (fromItem && toItem) {
+      if ((0, $cd5ea4b915021f1d$export$8c434b3a7a4dad6)(this.collection, fromItem, toItem) <= 0) return this.getKeyRangeInternal(from, to);
+      return this.getKeyRangeInternal(to, from);
+    }
+    return [];
+  }
+  getKeyRangeInternal(from, to) {
+    if (this.layoutDelegate?.getKeyRange) return this.layoutDelegate.getKeyRange(from, to);
+    let keys = [];
+    let key = from;
+    while (key != null) {
+      let item = this.collection.getItem(key);
+      if (item && (item.type === "item" || item.type === "cell" && this.allowsCellSelection)) keys.push(key);
+      if (key === to) return keys;
+      key = this.collection.getKeyAfter(key);
+    }
+    return [];
+  }
+  getKey(key) {
+    let item = this.collection.getItem(key);
+    if (!item)
+      return key;
+    if (item.type === "cell" && this.allowsCellSelection) return key;
+    while (item && item.type !== "item" && item.parentKey != null) item = this.collection.getItem(item.parentKey);
+    if (!item || item.type !== "item") return null;
+    return item.key;
+  }
+  /**
+  * Toggles whether the given key is selected.
+  */
+  toggleSelection(key) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single" && !this.isSelected(key)) {
+      this.replaceSelection(key);
+      return;
+    }
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return;
+    let keys = new (0, $8b2540e09867b15e$export$52baac22726c72bf)(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+    if (keys.has(mappedKey)) keys.delete(mappedKey);
+    else if (this.canSelectItem(mappedKey)) {
+      keys.add(mappedKey);
+      keys.anchorKey = mappedKey;
+      keys.currentKey = mappedKey;
+    }
+    if (this.disallowEmptySelection && keys.size === 0) return;
+    this.state.setSelectedKeys(keys);
+  }
+  /**
+  * Replaces the selection with only the given key.
+  */
+  replaceSelection(key) {
+    if (this.selectionMode === "none") return;
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return;
+    let selection = this.canSelectItem(mappedKey) ? new (0, $8b2540e09867b15e$export$52baac22726c72bf)([
+      mappedKey
+    ], mappedKey, mappedKey) : new (0, $8b2540e09867b15e$export$52baac22726c72bf)();
+    this.state.setSelectedKeys(selection);
+  }
+  /**
+  * Replaces the selection with the given keys.
+  */
+  setSelectedKeys(keys) {
+    if (this.selectionMode === "none") return;
+    let selection = new (0, $8b2540e09867b15e$export$52baac22726c72bf)();
+    for (let key of keys) {
+      let mappedKey = this.getKey(key);
+      if (mappedKey != null) {
+        selection.add(mappedKey);
+        if (this.selectionMode === "single") break;
+      }
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getSelectAllKeys() {
+    let collection = this.fullCollection ?? this.collection;
+    let keys = [];
+    let addKeys = (key) => {
+      while (key != null) {
+        if (this.canSelectItemIn(key, collection)) {
+          let item = collection.getItem(key);
+          if (item?.type === "item") keys.push(key);
+          if (item?.hasChildNodes && (this.allowsCellSelection || item.type !== "item")) addKeys((0, $cd5ea4b915021f1d$export$fbdeaa6a76694f71)((0, $cd5ea4b915021f1d$export$1005530eda016c13)(item, collection))?.key ?? null);
+        }
+        key = collection.getKeyAfter(key);
+      }
+    };
+    addKeys(collection.getFirstKey());
+    return keys;
+  }
+  /**
+  * Selects all items in the collection.
+  */
+  selectAll() {
+    if (!this.isSelectAll && this.selectionMode === "multiple") this.state.setSelectedKeys("all");
+  }
+  /**
+  * Removes all keys from the selection.
+  */
+  clearSelection() {
+    if (!this.disallowEmptySelection && (this.state.selectedKeys === "all" || this.state.selectedKeys.size > 0)) this.state.setSelectedKeys(new (0, $8b2540e09867b15e$export$52baac22726c72bf)());
+  }
+  /**
+  * Toggles between select all and an empty selection.
+  */
+  toggleSelectAll() {
+    if (this.isSelectAll) this.clearSelection();
+    else this.selectAll();
+  }
+  select(key, e) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      if (this.isSelected(key) && !this.disallowEmptySelection) this.toggleSelection(key);
+      else this.replaceSelection(key);
+    } else if (this.selectionBehavior === "toggle" || e && (e.pointerType === "touch" || e.pointerType === "virtual"))
+      this.toggleSelection(key);
+    else this.replaceSelection(key);
+  }
+  /**
+  * Returns whether the current selection is equal to the given selection.
+  */
+  isSelectionEqual(selection) {
+    if (selection === this.state.selectedKeys) return true;
+    let selectedKeys = this.selectedKeys;
+    if (selection.size !== selectedKeys.size) return false;
+    for (let key of selection) {
+      if (!selectedKeys.has(key)) return false;
+    }
+    for (let key of selectedKeys) {
+      if (!selection.has(key)) return false;
+    }
+    return true;
+  }
+  canSelectItem(key) {
+    return this.canSelectItemIn(key, this.collection);
+  }
+  canSelectItemIn(key, collection) {
+    if (this.state.selectionMode === "none" || this.state.disabledKeys.has(key)) return false;
+    let item = collection.getItem(key);
+    if (!item || item?.props?.isDisabled || item.type === "cell" && !this.allowsCellSelection) return false;
+    return true;
+  }
+  isDisabled(key) {
+    return this.state.disabledBehavior === "all" && (this.state.disabledKeys.has(key) || !!this.collection.getItem(key)?.props?.isDisabled);
+  }
+  isLink(key) {
+    return !!this.collection.getItem(key)?.props?.href;
+  }
+  getItemProps(key) {
+    return this.collection.getItem(key)?.props;
+  }
+  withCollection(collection) {
+    return new _$4a07ac835f260f78$export$6c8a5aaad13c9852(collection, this.state, {
+      allowsCellSelection: this.allowsCellSelection,
+      layoutDelegate: this.layoutDelegate || void 0,
+      fullCollection: this.fullCollection ?? this.collection
+    });
+  }
+};
+
+// ../../node_modules/react-stately/dist/private/collections/CollectionBuilder.mjs
+import $jO8i1$react from "react";
+var $bda7a7e55e1ff206$export$bf788dd355e3a401 = class {
+  build(props, context) {
+    this.context = context;
+    return $bda7a7e55e1ff206$var$iterable(() => this.iterateCollection(props));
+  }
+  *iterateCollection(props) {
+    let { children, items } = props;
+    if ((0, $jO8i1$react).isValidElement(children) && children.type === (0, $jO8i1$react).Fragment) yield* this.iterateCollection({
+      children: children.props.children,
+      items
+    });
+    else if (typeof children === "function") {
+      if (!items) throw new Error("props.children was a function but props.items is missing");
+      let index = 0;
+      for (let item of items) {
+        yield* this.getFullNode({
+          value: item,
+          index
+        }, {
+          renderer: children
+        });
+        index++;
+      }
+    } else {
+      let items2 = [];
+      (0, $jO8i1$react).Children.forEach(children, (child) => {
+        if (child) items2.push(child);
+      });
+      let index = 0;
+      for (let item of items2) {
+        let nodes = this.getFullNode({
+          element: item,
+          index
+        }, {});
+        for (let node of nodes) {
+          index++;
+          yield node;
+        }
+      }
+    }
+  }
+  getKey(item, partialNode, state, parentKey) {
+    if (item.key != null) return item.key;
+    if (partialNode.type === "cell" && partialNode.key != null) return `${parentKey}${partialNode.key}`;
+    let v = partialNode.value;
+    if (v != null) {
+      let key = v.key ?? v.id;
+      if (key == null) throw new Error("No key found for item");
+      return key;
+    }
+    return parentKey ? `${parentKey}.${partialNode.index}` : `$.${partialNode.index}`;
+  }
+  getChildState(state, partialNode) {
+    return {
+      renderer: partialNode.renderer || state.renderer
+    };
+  }
+  *getFullNode(partialNode, state, parentKey, parentNode) {
+    if ((0, $jO8i1$react).isValidElement(partialNode.element) && partialNode.element.type === (0, $jO8i1$react).Fragment) {
+      let children = [];
+      (0, $jO8i1$react).Children.forEach(partialNode.element.props.children, (child) => {
+        children.push(child);
+      });
+      let index = partialNode.index ?? 0;
+      for (const child of children) yield* this.getFullNode({
+        element: child,
+        index: index++
+      }, state, parentKey, parentNode);
+      return;
+    }
+    let element = partialNode.element;
+    if (!element && partialNode.value && state && state.renderer) {
+      let cached = this.cache.get(partialNode.value);
+      if (cached && (!cached.shouldInvalidate || !cached.shouldInvalidate(this.context))) {
+        cached.index = partialNode.index;
+        cached.parentKey = parentNode ? parentNode.key : null;
+        yield cached;
+        return;
+      }
+      element = state.renderer(partialNode.value);
+    }
+    if ((0, $jO8i1$react).isValidElement(element)) {
+      let type = element.type;
+      if (typeof type !== "function" && typeof type.getCollectionNode !== "function") {
+        let name = element.type;
+        throw new Error(`Unknown element <${name}> in collection.`);
+      }
+      let childNodes = type.getCollectionNode(element.props, this.context);
+      let index = partialNode.index ?? 0;
+      let result = childNodes.next();
+      while (!result.done && result.value) {
+        let childNode = result.value;
+        partialNode.index = index;
+        let nodeKey = childNode.key ?? null;
+        if (nodeKey == null) nodeKey = childNode.element ? null : this.getKey(element, partialNode, state, parentKey);
+        let nodes = this.getFullNode({
+          ...childNode,
+          key: nodeKey,
+          index,
+          wrapper: $bda7a7e55e1ff206$var$compose(partialNode.wrapper, childNode.wrapper)
+        }, this.getChildState(state, childNode), parentKey ? `${parentKey}${element.key}` : element.key, parentNode);
+        let children = [
+          ...nodes
+        ];
+        for (let node2 of children) {
+          node2.value = childNode.value ?? partialNode.value ?? null;
+          if (node2.value) this.cache.set(node2.value, node2);
+          if (partialNode.type && node2.type !== partialNode.type) throw new Error(`Unsupported type <${$bda7a7e55e1ff206$var$capitalize(node2.type)}> in <${$bda7a7e55e1ff206$var$capitalize(parentNode?.type ?? "unknown parent type")}>. Only <${$bda7a7e55e1ff206$var$capitalize(partialNode.type)}> is supported.`);
+          index++;
+          yield node2;
+        }
+        result = childNodes.next(children);
+      }
+      return;
+    }
+    if (partialNode.key == null || partialNode.type == null) return;
+    let builder = this;
+    let node = {
+      type: partialNode.type,
+      props: partialNode.props,
+      key: partialNode.key,
+      parentKey: parentNode ? parentNode.key : null,
+      value: partialNode.value ?? null,
+      level: (parentNode?.level ?? 0) + (parentNode?.type === "item" ? 1 : 0),
+      index: partialNode.index,
+      rendered: partialNode.rendered,
+      textValue: partialNode.textValue ?? "",
+      "aria-label": partialNode["aria-label"],
+      wrapper: partialNode.wrapper,
+      shouldInvalidate: partialNode.shouldInvalidate,
+      hasChildNodes: partialNode.hasChildNodes || false,
+      childNodes: $bda7a7e55e1ff206$var$iterable(function* () {
+        if (!partialNode.hasChildNodes || !partialNode.childNodes) return;
+        let index = 0;
+        for (let child of partialNode.childNodes()) {
+          if (child.key != null)
+            child.key = `${node.key}${child.key}`;
+          let nodes = builder.getFullNode({
+            ...child,
+            index
+          }, builder.getChildState(state, child), node.key, node);
+          for (let node2 of nodes) {
+            index++;
+            yield node2;
+          }
+        }
+      })
+    };
+    yield node;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+};
+function $bda7a7e55e1ff206$var$iterable(iterator) {
+  let cache = [];
+  let iterable = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let item of cache) yield item;
+      if (!iterable) iterable = iterator();
+      for (let item of iterable) {
+        cache.push(item);
+        yield item;
+      }
+    }
+  };
+}
+function $bda7a7e55e1ff206$var$compose(outer, inner) {
+  if (outer && inner) return (element) => outer(inner(element));
+  if (outer) return outer;
+  if (inner) return inner;
+}
+function $bda7a7e55e1ff206$var$capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+
+// ../../node_modules/react-stately/dist/private/collections/useCollection.mjs
+import { useMemo as $emYU7$useMemo } from "react";
+function $d03379b88399b8c5$export$6cd28814d92fa9c9(props, factory, context) {
+  let builder = (0, $emYU7$useMemo)(() => new (0, $bda7a7e55e1ff206$export$bf788dd355e3a401)(), []);
+  let { children, items, collection } = props;
+  let result = (0, $emYU7$useMemo)(() => {
+    if (collection) return collection;
+    let nodes = builder.build({
+      children,
+      items
+    }, context);
+    return factory(nodes);
+  }, [
+    builder,
+    children,
+    items,
+    collection,
+    context,
+    factory
+  ]);
+  return result;
+}
+
+// ../../node_modules/react-stately/dist/private/list/useListState.mjs
+import { useMemo as $3yt54$useMemo, useCallback as $3yt54$useCallback, useRef as $3yt54$useRef, useEffect as $3yt54$useEffect } from "react";
+function $b14b6f590b50af39$export$2f645645f7bca764(props) {
+  let { filter, layoutDelegate } = props;
+  let selectionState = (0, $60f19cefd567a3e4$export$253fe78d46329472)(props);
+  let disabledKeys = (0, $3yt54$useMemo)(() => props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set(), [
+    props.disabledKeys
+  ]);
+  let factory = (0, $3yt54$useCallback)((nodes) => filter ? new (0, $f664a81d022446b5$export$d085fb9e920b5ca7)(filter(nodes)) : new (0, $f664a81d022446b5$export$d085fb9e920b5ca7)(nodes), [
+    filter
+  ]);
+  let context = (0, $3yt54$useMemo)(() => ({
+    suppressTextValueWarning: props.suppressTextValueWarning
+  }), [
+    props.suppressTextValueWarning
+  ]);
+  let collection = (0, $d03379b88399b8c5$export$6cd28814d92fa9c9)(props, factory, context);
+  let selectionManager = (0, $3yt54$useMemo)(() => new (0, $4a07ac835f260f78$export$6c8a5aaad13c9852)(collection, selectionState, {
+    layoutDelegate
+  }), [
+    collection,
+    selectionState,
+    layoutDelegate
+  ]);
+  $b14b6f590b50af39$var$useFocusedKeyReset(collection, selectionManager);
+  return {
+    collection,
+    disabledKeys,
+    selectionManager
+  };
+}
+function $b14b6f590b50af39$var$useFocusedKeyReset(collection, selectionManager) {
+  const cachedCollection = (0, $3yt54$useRef)(null);
+  (0, $3yt54$useEffect)(() => {
+    if (selectionManager.focusedKey != null && !collection.getItem(selectionManager.focusedKey) && cachedCollection.current) {
+      let key = cachedCollection.current.getKeyAfter(selectionManager.focusedKey);
+      let nextFocusedKey = null;
+      while (key != null) {
+        let node = collection.getItem(key);
+        if (node && node.type === "item" && !selectionManager.isDisabled(key)) {
+          nextFocusedKey = key;
+          break;
+        }
+        key = cachedCollection.current.getKeyAfter(key);
+      }
+      if (nextFocusedKey == null) {
+        key = cachedCollection.current.getKeyBefore(selectionManager.focusedKey);
+        while (key != null) {
+          let node = collection.getItem(key);
+          if (node && node.type === "item" && !selectionManager.isDisabled(key)) {
+            nextFocusedKey = key;
+            break;
+          }
+          key = cachedCollection.current.getKeyBefore(key);
+        }
+      }
+      selectionManager.setFocusedKey(nextFocusedKey);
+    }
+    cachedCollection.current = collection;
+  }, [
+    collection,
+    selectionManager
+  ]);
+}
+
+// ../../node_modules/react-stately/dist/private/overlays/useOverlayTriggerState.mjs
+import { useCallback as $kE40A$useCallback } from "react";
+function $f11fb0bcf1b2687a$export$61c6a8c84e605fb6(props) {
+  let [isOpen, setOpen] = (0, $3e6197669829fe11$export$40bfa8c7b0832715)(props.isOpen, props.defaultOpen || false, props.onOpenChange);
+  const open = (0, $kE40A$useCallback)(() => {
+    setOpen(true);
+  }, [
+    setOpen
+  ]);
+  const close = (0, $kE40A$useCallback)(() => {
+    setOpen(false);
+  }, [
+    setOpen
+  ]);
+  const toggle = (0, $kE40A$useCallback)(() => {
+    setOpen(!isOpen);
+  }, [
+    setOpen,
+    isOpen
+  ]);
+  return {
+    isOpen,
+    setOpen,
+    open,
+    close,
+    toggle
+  };
+}
+
+// ../../node_modules/react-stately/dist/private/collections/Item.mjs
+import $dJmKC$react from "react";
+function $05678f3aee5e7d1a$var$Item(props) {
+  return null;
+}
+$05678f3aee5e7d1a$var$Item.getCollectionNode = function* getCollectionNode(props, context) {
+  let { childItems, title, children } = props;
+  let rendered = props.title || props.children;
+  let textValue = props.textValue || (typeof rendered === "string" ? rendered : "") || props["aria-label"] || "";
+  if (!textValue && !context?.suppressTextValueWarning && process.env.NODE_ENV !== "production") console.warn("<Item> with non-plain text contents is unsupported by type to select for accessibility. Please add a `textValue` prop.");
+  yield {
+    type: "item",
+    props,
+    rendered,
+    textValue,
+    "aria-label": props["aria-label"],
+    hasChildNodes: $05678f3aee5e7d1a$var$hasChildItems(props),
+    *childNodes() {
+      if (childItems) for (let child of childItems) yield {
+        type: "item",
+        value: child
+      };
+      else if (title) {
+        let items = [];
+        (0, $dJmKC$react).Children.forEach(children, (child) => {
+          items.push({
+            type: "item",
+            element: child
+          });
+        });
+        yield* items;
+      }
+    }
+  };
+};
+function $05678f3aee5e7d1a$var$hasChildItems(props) {
+  if (props.hasChildItems != null) return props.hasChildItems;
+  if (props.childItems) return true;
+  if (props.title && (0, $dJmKC$react).Children.count(props.children) > 0) return true;
+  return false;
+}
+var $05678f3aee5e7d1a$export$6d08773d2e66f8f2 = $05678f3aee5e7d1a$var$Item;
+
+// ../../node_modules/react-stately/dist/private/list/useSingleSelectListState.mjs
+import { useMemo as $jhfZc$useMemo } from "react";
+function $0fdb127d377ffd84$export$e7f05e985daf4b5f(props) {
+  let [selectedKey, setSelectedKey] = (0, $3e6197669829fe11$export$40bfa8c7b0832715)(props.selectedKey, props.defaultSelectedKey ?? null, props.onSelectionChange);
+  let selectedKeys = (0, $jhfZc$useMemo)(() => selectedKey != null ? [
+    selectedKey
+  ] : [], [
+    selectedKey
+  ]);
+  let { collection, disabledKeys, selectionManager } = (0, $b14b6f590b50af39$export$2f645645f7bca764)({
+    ...props,
+    selectionMode: "single",
+    disallowEmptySelection: true,
+    allowDuplicateSelectionEvents: true,
+    selectedKeys,
+    onSelectionChange: (keys) => {
+      if (keys === "all") return;
+      let key = keys.values().next().value ?? null;
+      if (key === selectedKey && props.onSelectionChange) props.onSelectionChange(key);
+      setSelectedKey(key);
+    }
+  });
+  let selectedItem = selectedKey != null ? collection.getItem(selectedKey) : null;
+  return {
+    collection,
+    disabledKeys,
+    selectionManager,
+    selectedKey,
+    setSelectedKey,
+    selectedItem
+  };
+}
+
+// ../../node_modules/react-stately/dist/private/menu/useMenuTriggerState.mjs
+import { useState as $aoDK0$useState } from "react";
+function $e3403870bfb691da$export$79fefeb1c2091ac3(props) {
+  let overlayTriggerState = (0, $f11fb0bcf1b2687a$export$61c6a8c84e605fb6)(props);
+  let [focusStrategy, setFocusStrategy] = (0, $aoDK0$useState)(null);
+  let [expandedKeysStack, setExpandedKeysStack] = (0, $aoDK0$useState)([]);
+  let closeAll = () => {
+    setExpandedKeysStack([]);
+    overlayTriggerState.close();
+  };
+  let openSubmenu = (triggerKey, level) => {
+    setExpandedKeysStack((oldStack) => {
+      if (level > oldStack.length) return oldStack;
+      return [
+        ...oldStack.slice(0, level),
+        triggerKey
+      ];
+    });
+  };
+  let closeSubmenu = (triggerKey, level) => {
+    setExpandedKeysStack((oldStack) => {
+      let key = oldStack[level];
+      if (key === triggerKey) return oldStack.slice(0, level);
+      else return oldStack;
+    });
+  };
+  return {
+    focusStrategy,
+    ...overlayTriggerState,
+    open(focusStrategy2 = null) {
+      setFocusStrategy(focusStrategy2);
+      overlayTriggerState.open();
+    },
+    toggle(focusStrategy2 = null) {
+      setFocusStrategy(focusStrategy2);
+      overlayTriggerState.toggle();
+    },
+    close() {
+      closeAll();
+    },
+    expandedKeysStack,
+    openSubmenu,
+    closeSubmenu
+  };
+}
+
+// ../../node_modules/react-stately/dist/private/radio/useRadioGroupState.mjs
+import { useMemo as $6Hs9a$useMemo, useState as $6Hs9a$useState } from "react";
+var $384704861d32dbed$var$instance = Math.round(Math.random() * 1e10);
+var $384704861d32dbed$var$i = 0;
+function $384704861d32dbed$export$bca9d026f8e704eb(props) {
+  let name = (0, $6Hs9a$useMemo)(() => props.name || `radio-group-${$384704861d32dbed$var$instance}-${++$384704861d32dbed$var$i}`, [
+    props.name
+  ]);
+  let [selectedValue, setSelected] = (0, $3e6197669829fe11$export$40bfa8c7b0832715)(props.value, props.defaultValue ?? null, props.onChange);
+  let [initialValue] = (0, $6Hs9a$useState)(selectedValue);
+  let [lastFocusedValue, setLastFocusedValue] = (0, $6Hs9a$useState)(null);
+  let validation = (0, $fd2148440a13ec26$export$fc1a364ae1f3ff10)({
+    ...props,
+    value: selectedValue
+  });
+  let setSelectedValue = (value) => {
+    if (!props.isReadOnly && !props.isDisabled) {
+      setSelected(value);
+      validation.commitValidation();
+    }
+  };
+  let isInvalid = validation.displayValidation.isInvalid;
+  return {
+    ...validation,
+    name,
+    selectedValue,
+    defaultSelectedValue: props.value !== void 0 ? initialValue : props.defaultValue ?? null,
+    setSelectedValue,
+    lastFocusedValue,
+    setLastFocusedValue,
+    isDisabled: props.isDisabled || false,
+    isReadOnly: props.isReadOnly || false,
+    isRequired: props.isRequired || false,
+    validationState: props.validationState || (isInvalid ? "invalid" : null),
+    isInvalid
+  };
+}
+
+// ../../node_modules/react-stately/dist/private/select/useSelectState.mjs
+import { useState as $5t5rb$useState, useMemo as $5t5rb$useMemo } from "react";
+function $29256f53a2edafe9$export$5159ec8b34d4ec12(props) {
+  let { selectionMode = "single", shouldCloseOnSelect = selectionMode === "single" } = props;
+  let triggerState = (0, $f11fb0bcf1b2687a$export$61c6a8c84e605fb6)(props);
+  let [focusStrategy, setFocusStrategy] = (0, $5t5rb$useState)(null);
+  let defaultValue = (0, $5t5rb$useMemo)(() => {
+    return props.defaultValue !== void 0 ? props.defaultValue : selectionMode === "single" ? props.defaultSelectedKey ?? null : [];
+  }, [
+    props.defaultValue,
+    props.defaultSelectedKey,
+    selectionMode
+  ]);
+  let value = (0, $5t5rb$useMemo)(() => {
+    return props.value !== void 0 ? props.value : selectionMode === "single" ? props.selectedKey : void 0;
+  }, [
+    props.value,
+    props.selectedKey,
+    selectionMode
+  ]);
+  let [controlledValue, setControlledValue] = (0, $3e6197669829fe11$export$40bfa8c7b0832715)(value, defaultValue, props.onChange);
+  let displayValue = selectionMode === "single" && Array.isArray(controlledValue) ? controlledValue[0] : controlledValue;
+  let setValue = (value2) => {
+    if (selectionMode === "single") {
+      let key = Array.isArray(value2) ? value2[0] ?? null : value2;
+      setControlledValue(key);
+      if (key !== displayValue) props.onSelectionChange?.(key);
+    } else {
+      let keys = [];
+      if (Array.isArray(value2)) keys = value2;
+      else if (value2 != null) keys = [
+        value2
+      ];
+      setControlledValue(keys);
+    }
+  };
+  let listState = (0, $b14b6f590b50af39$export$2f645645f7bca764)({
+    ...props,
+    selectionMode,
+    disallowEmptySelection: selectionMode === "single",
+    allowDuplicateSelectionEvents: true,
+    selectedKeys: (0, $5t5rb$useMemo)(() => $29256f53a2edafe9$var$convertValue(displayValue), [
+      displayValue
+    ]),
+    onSelectionChange: (keys) => {
+      if (keys === "all") return;
+      if (selectionMode === "single") {
+        let key = keys.values().next().value ?? null;
+        setValue(key);
+      } else setValue([
+        ...keys
+      ]);
+      if (shouldCloseOnSelect) triggerState.close();
+      validationState.commitValidation();
+    }
+  });
+  let selectedKey = listState.selectionManager.firstSelectedKey;
+  let selectedItems = (0, $5t5rb$useMemo)(() => {
+    return [
+      ...listState.selectionManager.selectedKeys
+    ].map((key) => listState.collection.getItem(key)).filter((item) => item != null);
+  }, [
+    listState.selectionManager.selectedKeys,
+    listState.collection
+  ]);
+  let validationState = (0, $fd2148440a13ec26$export$fc1a364ae1f3ff10)({
+    ...props,
+    value: Array.isArray(displayValue) && displayValue.length === 0 ? null : displayValue
+  });
+  let [isFocused, setFocused] = (0, $5t5rb$useState)(false);
+  let [initialValue] = (0, $5t5rb$useState)(displayValue);
+  return {
+    ...validationState,
+    ...listState,
+    ...triggerState,
+    value: displayValue,
+    defaultValue: defaultValue ?? initialValue,
+    setValue,
+    selectedKey,
+    setSelectedKey: setValue,
+    selectedItem: selectedItems[0] ?? null,
+    selectedItems,
+    defaultSelectedKey: props.defaultSelectedKey ?? (props.selectionMode === "single" ? initialValue : null),
+    focusStrategy,
+    open(focusStrategy2 = null) {
+      if (listState.collection.size !== 0 || props.allowsEmptyCollection) {
+        setFocusStrategy(focusStrategy2);
+        triggerState.open();
+      }
+    },
+    toggle(focusStrategy2 = null) {
+      if (listState.collection.size !== 0 || props.allowsEmptyCollection) {
+        setFocusStrategy(focusStrategy2);
+        triggerState.toggle();
+      }
+    },
+    isFocused,
+    setFocused
+  };
+}
+function $29256f53a2edafe9$var$convertValue(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return [];
+  return Array.isArray(value) ? value : [
+    value
+  ];
+}
+
+// ../../node_modules/react-stately/dist/private/tabs/useTabListState.mjs
+import { useRef as $eOo4G$useRef, useEffect as $eOo4G$useEffect } from "react";
+function $caeb030f09a278a1$export$4ba071daf4e486(props) {
+  let state = (0, $0fdb127d377ffd84$export$e7f05e985daf4b5f)({
+    ...props,
+    onSelectionChange: props.onSelectionChange ? (key) => {
+      if (key != null) props.onSelectionChange?.(key);
+    } : void 0,
+    suppressTextValueWarning: true,
+    defaultSelectedKey: props.defaultSelectedKey ?? $caeb030f09a278a1$var$findDefaultSelectedKey(props.collection, props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set()) ?? void 0
+  });
+  let { selectionManager, collection, selectedKey: currentSelectedKey } = state;
+  let lastSelectedKey = (0, $eOo4G$useRef)(currentSelectedKey);
+  (0, $eOo4G$useEffect)(() => {
+    let selectedKey = currentSelectedKey;
+    if (props.selectedKey == null && (selectionManager.isEmpty || selectedKey == null || !collection.getItem(selectedKey))) {
+      selectedKey = $caeb030f09a278a1$var$findDefaultSelectedKey(collection, state.disabledKeys);
+      if (selectedKey != null)
+        selectionManager.setSelectedKeys([
+          selectedKey
+        ]);
+    }
+    if (selectedKey != null && selectionManager.focusedKey == null || !selectionManager.isFocused && selectedKey !== lastSelectedKey.current) selectionManager.setFocusedKey(selectedKey);
+    lastSelectedKey.current = selectedKey;
+  });
+  return {
+    ...state,
+    isDisabled: props.isDisabled || false
+  };
+}
+function $caeb030f09a278a1$var$findDefaultSelectedKey(collection, disabledKeys) {
+  let selectedKey = null;
+  if (collection) {
+    selectedKey = collection.getFirstKey();
+    while (selectedKey != null && (disabledKeys.has(selectedKey) || collection.getItem(selectedKey)?.props?.isDisabled) && selectedKey !== collection.getLastKey()) selectedKey = collection.getKeyAfter(selectedKey);
+    if (selectedKey != null && (disabledKeys.has(selectedKey) || collection.getItem(selectedKey)?.props?.isDisabled) && selectedKey === collection.getLastKey()) selectedKey = collection.getFirstKey();
+  }
+  return selectedKey;
+}
+
+// ../../node_modules/react-stately/dist/private/toggle/useToggleState.mjs
+import { useState as $dAajM$useState } from "react";
+function $fd3c5e01e837dc20$export$8042c6c013fd5226(props = {}) {
+  let { isReadOnly } = props;
+  let [isSelected, setSelected] = (0, $3e6197669829fe11$export$40bfa8c7b0832715)(props.isSelected, props.defaultSelected || false, props.onChange);
+  let [initialValue] = (0, $dAajM$useState)(isSelected);
+  function updateSelected(value) {
+    if (!isReadOnly) setSelected(value);
+  }
+  function toggleState() {
+    if (!isReadOnly) setSelected(!isSelected);
+  }
+  return {
+    isSelected,
+    defaultSelected: props.defaultSelected ?? initialValue,
+    setSelected: updateSelected,
+    toggle: toggleState
+  };
+}
+
+// ../../node_modules/react-stately/dist/private/tooltip/useTooltipTriggerState.mjs
+import { useMemo as $auOuY$useMemo, useRef as $auOuY$useRef, useEffect as $auOuY$useEffect } from "react";
+var $3834487504f4fc00$var$TOOLTIP_DELAY = 1500;
+var $3834487504f4fc00$var$TOOLTIP_COOLDOWN = 500;
+var $3834487504f4fc00$var$tooltips = {};
+var $3834487504f4fc00$var$tooltipId = 0;
+var $3834487504f4fc00$var$globalWarmedUp = false;
+var $3834487504f4fc00$var$globalWarmUpTimeout = null;
+var $3834487504f4fc00$var$globalCooldownTimeout = null;
+function $3834487504f4fc00$export$4d40659c25ecb50b(props = {}) {
+  let { delay = $3834487504f4fc00$var$TOOLTIP_DELAY, closeDelay = $3834487504f4fc00$var$TOOLTIP_COOLDOWN } = props;
+  let { isOpen, open, close } = (0, $f11fb0bcf1b2687a$export$61c6a8c84e605fb6)(props);
+  let id = (0, $auOuY$useMemo)(() => `${++$3834487504f4fc00$var$tooltipId}`, []);
+  let closeTimeout = (0, $auOuY$useRef)(null);
+  let closeCallback = (0, $auOuY$useRef)(close);
+  let ensureTooltipEntry = () => {
+    $3834487504f4fc00$var$tooltips[id] = hideTooltip;
+  };
+  let closeOpenTooltips = () => {
+    for (let hideTooltipId in $3834487504f4fc00$var$tooltips) if (hideTooltipId !== id) {
+      $3834487504f4fc00$var$tooltips[hideTooltipId](true);
+      delete $3834487504f4fc00$var$tooltips[hideTooltipId];
+    }
+  };
+  let showTooltip = () => {
+    if (closeTimeout.current) clearTimeout(closeTimeout.current);
+    closeTimeout.current = null;
+    closeOpenTooltips();
+    ensureTooltipEntry();
+    $3834487504f4fc00$var$globalWarmedUp = true;
+    open();
+    if ($3834487504f4fc00$var$globalWarmUpTimeout) {
+      clearTimeout($3834487504f4fc00$var$globalWarmUpTimeout);
+      $3834487504f4fc00$var$globalWarmUpTimeout = null;
+    }
+    if ($3834487504f4fc00$var$globalCooldownTimeout) {
+      clearTimeout($3834487504f4fc00$var$globalCooldownTimeout);
+      $3834487504f4fc00$var$globalCooldownTimeout = null;
+    }
+  };
+  let hideTooltip = (immediate) => {
+    if (immediate || closeDelay <= 0) {
+      if (closeTimeout.current) clearTimeout(closeTimeout.current);
+      closeTimeout.current = null;
+      closeCallback.current();
+    } else if (!closeTimeout.current) closeTimeout.current = setTimeout(() => {
+      closeTimeout.current = null;
+      closeCallback.current();
+    }, closeDelay);
+    if ($3834487504f4fc00$var$globalWarmUpTimeout) {
+      clearTimeout($3834487504f4fc00$var$globalWarmUpTimeout);
+      $3834487504f4fc00$var$globalWarmUpTimeout = null;
+    }
+    if ($3834487504f4fc00$var$globalWarmedUp) {
+      if ($3834487504f4fc00$var$globalCooldownTimeout) clearTimeout($3834487504f4fc00$var$globalCooldownTimeout);
+      $3834487504f4fc00$var$globalCooldownTimeout = setTimeout(() => {
+        delete $3834487504f4fc00$var$tooltips[id];
+        $3834487504f4fc00$var$globalCooldownTimeout = null;
+        $3834487504f4fc00$var$globalWarmedUp = false;
+      }, Math.max($3834487504f4fc00$var$TOOLTIP_COOLDOWN, closeDelay));
+    }
+  };
+  let warmupTooltip = () => {
+    closeOpenTooltips();
+    ensureTooltipEntry();
+    if (!isOpen && !$3834487504f4fc00$var$globalWarmedUp) {
+      if ($3834487504f4fc00$var$globalWarmUpTimeout) clearTimeout($3834487504f4fc00$var$globalWarmUpTimeout);
+      $3834487504f4fc00$var$globalWarmUpTimeout = setTimeout(() => {
+        $3834487504f4fc00$var$globalWarmUpTimeout = null;
+        $3834487504f4fc00$var$globalWarmedUp = true;
+        showTooltip();
+      }, delay);
+    } else if (!isOpen) showTooltip();
+  };
+  (0, $auOuY$useEffect)(() => {
+    closeCallback.current = close;
+  }, [
+    close
+  ]);
+  (0, $auOuY$useEffect)(() => {
+    return () => {
+      if (closeTimeout.current) clearTimeout(closeTimeout.current);
+      let tooltip = $3834487504f4fc00$var$tooltips[id];
+      if (tooltip) delete $3834487504f4fc00$var$tooltips[id];
+    };
+  }, [
+    id
+  ]);
+  return {
+    isOpen,
+    open: (immediate) => {
+      if (!immediate && delay > 0 && !closeTimeout.current) warmupTooltip();
+      else showTooltip();
+    },
+    close: hideTooltip
+  };
+}
+
+// ../../node_modules/react-stately/dist/private/tree/TreeCollection.mjs
+var $df1fcc684d3b021a$export$863faf230ee2118a = class {
+  constructor(nodes, { expandedKeys } = {}) {
+    this.keyMap = /* @__PURE__ */ new Map();
+    this.firstKey = null;
+    this.lastKey = null;
+    this.iterable = nodes;
+    expandedKeys = expandedKeys || /* @__PURE__ */ new Set();
+    let visit = (node) => {
+      this.keyMap.set(node.key, node);
+      if (node.childNodes && (node.type === "section" || expandedKeys.has(node.key))) for (let child of node.childNodes) visit(child);
+    };
+    for (let node of nodes) visit(node);
+    let last = null;
+    let index = 0;
+    for (let [key, node] of this.keyMap) {
+      if (last) {
+        last.nextKey = key;
+        node.prevKey = last.key;
+      } else {
+        this.firstKey = key;
+        node.prevKey = void 0;
+      }
+      if (node.type === "item") node.index = index++;
+      last = node;
+      last.nextKey = void 0;
+    }
+    this.lastKey = last?.key ?? null;
+  }
+  *[Symbol.iterator]() {
+    yield* this.iterable;
+  }
+  get size() {
+    return this.keyMap.size;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getKeyBefore(key) {
+    let node = this.keyMap.get(key);
+    return node ? node.prevKey ?? null : null;
+  }
+  getKeyAfter(key) {
+    let node = this.keyMap.get(key);
+    return node ? node.nextKey ?? null : null;
+  }
+  getFirstKey() {
+    return this.firstKey;
+  }
+  getLastKey() {
+    return this.lastKey;
+  }
+  getItem(key) {
+    return this.keyMap.get(key) ?? null;
+  }
+  at(idx) {
+    const keys = [
+      ...this.getKeys()
+    ];
+    return this.getItem(keys[idx]);
+  }
+};
+
+// ../../node_modules/react-stately/dist/private/tree/useTreeState.mjs
+import { useMemo as $aXIpm$useMemo, useCallback as $aXIpm$useCallback, useEffect as $aXIpm$useEffect } from "react";
+function $6b915bde6cd300dd$export$728d6ba534403756(props) {
+  let { onExpandedChange } = props;
+  let [expandedKeys, setExpandedKeys] = (0, $3e6197669829fe11$export$40bfa8c7b0832715)(props.expandedKeys ? new Set(props.expandedKeys) : void 0, props.defaultExpandedKeys ? new Set(props.defaultExpandedKeys) : /* @__PURE__ */ new Set(), onExpandedChange);
+  let selectionState = (0, $60f19cefd567a3e4$export$253fe78d46329472)(props);
+  let disabledKeys = (0, $aXIpm$useMemo)(() => props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set(), [
+    props.disabledKeys
+  ]);
+  let tree = (0, $d03379b88399b8c5$export$6cd28814d92fa9c9)(props, (0, $aXIpm$useCallback)((nodes) => new (0, $df1fcc684d3b021a$export$863faf230ee2118a)(nodes, {
+    expandedKeys
+  }), [
+    expandedKeys
+  ]), null);
+  (0, $aXIpm$useEffect)(() => {
+    if (selectionState.focusedKey != null && !tree.getItem(selectionState.focusedKey)) selectionState.setFocusedKey(null);
+  }, [
+    tree,
+    selectionState.focusedKey
+  ]);
+  let onToggle = (key) => {
+    setExpandedKeys($6b915bde6cd300dd$var$toggleKey(expandedKeys, key));
+  };
+  return {
+    collection: tree,
+    expandedKeys,
+    disabledKeys,
+    toggleKey: onToggle,
+    setExpandedKeys,
+    selectionManager: new (0, $4a07ac835f260f78$export$6c8a5aaad13c9852)(tree, selectionState)
+  };
+}
+function $6b915bde6cd300dd$var$toggleKey(set, key) {
+  let res = new Set(set);
+  if (res.has(key)) res.delete(key);
+  else res.add(key);
+  return res;
+}
+
+// src/components/Tooltip/Tooltip.tsx
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FLIP = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+function placeOn(rect, tipRect, position, offset) {
+  const cx = rect.left + rect.width / 2;
+  const cy = rect.top + rect.height / 2;
+  switch (position) {
+    case "top":
+      return {
+        top: rect.top - tipRect.height - offset,
+        left: cx - tipRect.width / 2
+      };
+    case "bottom":
+      return { top: rect.bottom + offset, left: cx - tipRect.width / 2 };
+    case "left":
+      return {
+        top: cy - tipRect.height / 2,
+        left: rect.left - tipRect.width - offset
+      };
+    case "right":
+      return { top: cy - tipRect.height / 2, left: rect.right + offset };
+  }
+}
+function computePosition(rect, tipRect, position, offset, viewport) {
+  const tryAt = (p) => {
+    const c = placeOn(rect, tipRect, p, offset);
+    const fits = c.top >= 0 && c.left >= 0 && c.top + tipRect.height <= viewport.height && c.left + tipRect.width <= viewport.width;
+    return { ...c, position: p, fits };
+  };
+  const preferred = tryAt(position);
+  if (preferred.fits) return preferred;
+  const flipped = tryAt(FLIP[position]);
+  if (flipped.fits) return flipped;
+  const fallback = preferred;
+  const clampedLeft = Math.max(4, Math.min(fallback.left, viewport.width - tipRect.width - 4));
+  const clampedTop = Math.max(4, Math.min(fallback.top, viewport.height - tipRect.height - 4));
+  return { top: clampedTop, left: clampedLeft, position: fallback.position };
+}
+var animVariants = {
+  top: { initial: { opacity: 0, y: 4 }, animate: { opacity: 1, y: 0 } },
+  bottom: { initial: { opacity: 0, y: -4 }, animate: { opacity: 1, y: 0 } },
+  left: { initial: { opacity: 0, x: 4 }, animate: { opacity: 1, x: 0 } },
+  right: { initial: { opacity: 0, x: -4 }, animate: { opacity: 1, x: 0 } }
+};
+function TooltipContent({
+  state,
+  content,
+  position,
+  triggerRef,
+  className,
+  offset,
+  tooltipId
+}) {
+  const { tooltipProps } = useTooltip({ isOpen: state.isOpen }, state);
+  const tipRef = useRef(null);
+  const [coords, setCoords] = useState2(null);
+  const reposition = useCallback2(() => {
+    if (!triggerRef.current || !tipRef.current) return;
+    const trigRect = triggerRef.current.getBoundingClientRect();
+    const tipRect = tipRef.current.getBoundingClientRect();
+    const viewport = {
+      width: window.innerWidth || document.documentElement.clientWidth,
+      height: window.innerHeight || document.documentElement.clientHeight
+    };
+    setCoords(computePosition(trigRect, tipRect, position, offset, viewport));
+  }, [triggerRef, position, offset]);
+  useLayoutEffect(() => {
+    if (!state.isOpen) return;
+    reposition();
+    const id = requestAnimationFrame(reposition);
+    return () => cancelAnimationFrame(id);
+  }, [state.isOpen, reposition]);
+  useEffect(() => {
+    if (!state.isOpen) return;
+    const handler = () => reposition();
+    window.addEventListener("scroll", handler, true);
+    window.addEventListener("resize", handler);
+    return () => {
+      window.removeEventListener("scroll", handler, true);
+      window.removeEventListener("resize", handler);
+    };
+  }, [state.isOpen, reposition]);
+  const resolvedPos = coords?.position ?? position;
+  const variants = animVariants[resolvedPos];
+  const {
+    onDrag: _onDrag,
+    onDragStart: _onDragStart,
+    onDragEnd: _onDragEnd,
+    onAnimationStart: _onAnimationStart,
+    ...safeTipProps
+  } = tooltipProps;
+  const portalContent = /* @__PURE__ */ jsx2(AnimatePresence2, { children: state.isOpen && /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: "ods-tooltip__wrapper",
+      style: {
+        position: "fixed",
+        zIndex: 1500,
+        top: coords?.top ?? -9999,
+        left: coords?.left ?? -9999,
+        visibility: coords ? "visible" : "hidden",
+        pointerEvents: "none"
+      },
+      children: /* @__PURE__ */ jsxs2(
+        motion2.div,
+        {
+          ref: tipRef,
+          ...safeTipProps,
+          id: tooltipId,
+          role: "tooltip",
+          "data-position": resolvedPos,
+          className: cn("ods-tooltip", className),
+          initial: variants.initial,
+          animate: variants.animate,
+          exit: { opacity: 0 },
+          transition: { duration: 0.15, ease: "easeOut" },
+          children: [
+            content,
+            /* @__PURE__ */ jsx2("span", { className: "ods-tooltip__arrow", "aria-hidden": "true" })
+          ]
+        }
+      )
+    }
+  ) });
+  if (typeof document === "undefined") return null;
+  return createPortal(portalContent, document.body);
+}
+function mergeRefs(...refs) {
+  return (node) => {
+    for (const r of refs) {
+      if (!r) continue;
+      if (typeof r === "function") r(node);
+      else r.current = node;
+    }
+  };
+}
+function mergeHandler(childHandler, ariaHandler) {
+  if (!childHandler && !ariaHandler) return void 0;
+  return (e) => {
+    childHandler?.(e);
+    if (!e.defaultPrevented) ariaHandler?.(e);
+  };
+}
+function Tooltip({
+  content,
+  position = "top",
+  delay = 200,
+  offset = 8,
+  disabled = false,
+  id: providedId,
+  children,
+  className
+}) {
+  const reactId = useId2();
+  const tooltipId = providedId ?? `ods-tooltip-${reactId}`;
+  const triggerRef = useRef(null);
+  const state = $3834487504f4fc00$export$4d40659c25ecb50b({ delay });
+  const { triggerProps } = useTooltipTrigger({ delay, isDisabled: disabled }, state, triggerRef);
+  if (!isValidElement(children)) {
+    return /* @__PURE__ */ jsx2(Fragment, { children });
+  }
+  const childProps = children.props;
+  const childRef = childProps.ref ?? children.ref;
+  const merged = { ...childProps };
+  for (const [key, value] of Object.entries(triggerProps)) {
+    if (key.startsWith("on") && typeof value === "function") {
+      merged[key] = mergeHandler(childProps[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+  merged.ref = mergeRefs(triggerRef, childRef);
+  merged["aria-describedby"] = [childProps["aria-describedby"], tooltipId].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    cloneElement(children, merged),
+    !disabled && /* @__PURE__ */ jsx2(
+      TooltipContent,
+      {
+        state,
+        content,
+        position,
+        triggerRef,
+        offset,
+        className,
+        tooltipId
+      }
+    )
+  ] });
+}
+Tooltip.displayName = "Tooltip";
+
+// src/components/Button/Button.tsx
+import { motion as motion3, useReducedMotion as useReducedMotion2 } from "framer-motion";
+import {
+  forwardRef as forwardRef3,
+  useImperativeHandle,
+  useRef as useRef2
+} from "react";
+import { useButton } from "react-aria";
+
+// src/utils/a11y.ts
+import { isValidElement as isValidElement2 } from "react";
+function hasRenderableText(node) {
+  if (node === null || node === void 0 || typeof node === "boolean") return false;
+  if (typeof node === "string") return node.trim().length > 0;
+  if (typeof node === "number") return true;
+  if (Array.isArray(node)) return node.some(hasRenderableText);
+  if (isValidElement2(node)) {
+    return hasRenderableText(node.props.children);
+  }
+  return false;
+}
+function getRenderableText(node) {
+  if (node === null || node === void 0 || typeof node === "boolean") return "";
+  if (typeof node === "string") return node;
+  if (typeof node === "number") return String(node);
+  if (Array.isArray(node)) return node.map(getRenderableText).join("");
+  if (isValidElement2(node)) {
+    return getRenderableText(node.props.children);
+  }
+  return "";
+}
+function resolveAccessibleName(input) {
+  if (input.ariaLabelledby) {
+    return { "aria-labelledby": input.ariaLabelledby };
+  }
+  if (input.ariaLabel) {
+    return { "aria-label": input.ariaLabel };
+  }
+  if (typeof input.label === "string" && input.label.trim().length > 0) {
+    return { "aria-label": input.label };
+  }
+  for (const candidate of input.fallbacks ?? []) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return { "aria-label": candidate };
+    }
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.error(
+      `[@octaviaflow/core ${input.componentName}] No accessible name. Pass a string \`label\`, or \`aria-label\`, or \`aria-labelledby\` so screen readers can announce this control.`
+    );
+  }
+  return { "aria-label": `Unlabeled ${input.componentName}` };
+}
+
+// src/utils/Slot.tsx
+import {
+  Children,
+  cloneElement as cloneElement2,
+  forwardRef as forwardRef2,
+  isValidElement as isValidElement3
+} from "react";
+
+// src/utils/composeRefs.ts
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") {
+        ref(node);
+      } else if (ref != null) {
+        ref.current = node;
+      }
+    }
+  };
+}
+
+// src/utils/Slot.tsx
+var Slot = forwardRef2(function Slot2({ children, ...slotProps }, forwardedRef) {
+  if (!isValidElement3(children)) {
+    return null;
+  }
+  const child = Children.only(children);
+  const childProps = child.props ?? {};
+  const childRef = child.ref;
+  return cloneElement2(child, {
+    ...mergeProps(slotProps, childProps),
+    ref: forwardedRef ? composeRefs(forwardedRef, childRef) : childRef
+  });
+});
+function mergeProps(slotProps, childProps) {
+  const merged = { ...slotProps, ...childProps };
+  for (const key of Object.keys(slotProps)) {
+    const slotValue = slotProps[key];
+    const childValue = childProps[key];
+    if (/^on[A-Z]/.test(key) && typeof slotValue === "function" && typeof childValue === "function") {
+      merged[key] = (...args) => {
+        slotValue(...args);
+        const event = args[0];
+        if (event?.defaultPrevented) return;
+        childValue(...args);
+      };
+      continue;
+    }
+    if (key === "className") {
+      merged.className = [slotValue, childValue].filter(Boolean).join(" ");
+      continue;
+    }
+    if (key === "style") {
+      merged.style = {
+        ...slotValue,
+        ...childValue
+      };
+    }
+  }
+  return merged;
+}
+
+// src/components/Button/Button.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var Button = forwardRef3(function Button2({
+  variant = "primary",
+  size = "md",
+  loading = false,
+  loadingText,
+  loadingLabel = "Loading",
+  disabled = false,
+  leftIcon,
+  rightIcon,
+  fullWidth = false,
+  pressed,
+  asChild = false,
+  className,
+  children,
+  type,
+  cursor,
+  style,
+  ...props
+}, forwardedRef) {
+  const ref = useRef2(null);
+  useImperativeHandle(forwardedRef, () => ref.current);
+  const isDisabled = disabled || loading;
+  const prefersReducedMotion = useReducedMotion2();
+  const hasAction = Boolean(props.onClick) || type === "submit" || type === "reset";
+  const resolvedCursor = cursor ?? (disabled ? "not-allowed" : loading ? "progress" : hasAction ? "pointer" : "default");
+  const resolvedType = type ?? "button";
+  const hasVisibleText = hasRenderableText(children);
+  const needsAriaName = !hasVisibleText && !asChild;
+  const ariaNameProps = needsAriaName ? resolveAccessibleName({
+    ariaLabel: props["aria-label"],
+    ariaLabelledby: props["aria-labelledby"],
+    componentName: "Button"
+  }) : void 0;
+  const onClick = props.onClick;
+  const onPress = onClick ? (press) => {
+    const event = press;
+    if (typeof event.stopPropagation !== "function") event.stopPropagation = () => {
+    };
+    if (typeof event.preventDefault !== "function") event.preventDefault = () => {
+    };
+    if (event.currentTarget === void 0) event.currentTarget = event.target;
+    onClick(event);
+  } : void 0;
+  const { buttonProps } = useButton(
+    {
+      isDisabled,
+      onPress,
+      type: resolvedType,
+      ...ariaNameProps ?? {}
+    },
+    ref
+  );
+  const { onDrag, onDragStart, onDragEnd, onAnimationStart, ...safeButtonProps } = buttonProps;
+  const {
+    onClick: _onClick,
+    onKeyDown: _onKeyDown,
+    onKeyUp: _onKeyUp,
+    onMouseDown: _onMouseDown,
+    onPointerDown: _onPointerDown,
+    onPointerUp: _onPointerUp,
+    onFocus: _onFocus,
+    onBlur: _onBlur,
+    ...passthroughProps
+  } = props;
+  const rootClassName = cn(
+    "ods-btn",
+    `ods-btn--${variant}`,
+    `ods-btn--${size}`,
+    loading && "ods-btn--loading",
+    fullWidth && "ods-btn--full",
+    pressed && "ods-btn--pressed",
+    className
+  );
+  if (asChild) {
+    return /* @__PURE__ */ jsx3(
+      Slot,
+      {
+        ...passthroughProps,
+        ref: forwardedRef,
+        className: rootClassName,
+        style: { cursor: resolvedCursor, ...style },
+        "aria-pressed": pressed,
+        "aria-disabled": isDisabled || void 0,
+        children
+      }
+    );
+  }
+  const visibleLabel = loading && loadingText !== void 0 ? loadingText : children;
+  return /* @__PURE__ */ jsx3(
+    motion3.button,
+    {
+      ...passthroughProps,
+      ...safeButtonProps,
+      type: resolvedType,
+      ref,
+      className: rootClassName,
+      style: { cursor: resolvedCursor, ...style },
+      "data-loading": loading || void 0,
+      "aria-busy": loading || void 0,
+      "aria-pressed": pressed,
+      whileTap: isDisabled || prefersReducedMotion ? void 0 : { scale: 0.97 },
+      transition: { duration: 0.1 },
+      children: /* @__PURE__ */ jsxs3("span", { className: "ods-btn__content", children: [
+        loading ? /* @__PURE__ */ jsx3(
+          "span",
+          {
+            className: "ods-btn__icon ods-btn__icon--left ods-btn__icon--spinner",
+            role: "status",
+            "aria-label": loadingLabel,
+            children: /* @__PURE__ */ jsx3("svg", { viewBox: "0 0 24 24", "aria-hidden": "true", children: /* @__PURE__ */ jsx3(
+              "circle",
+              {
+                cx: "12",
+                cy: "12",
+                r: "10",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2.5",
+                strokeLinecap: "round",
+                strokeDasharray: "32",
+                strokeDashoffset: "12"
+              }
+            ) })
+          }
+        ) : leftIcon && /* @__PURE__ */ jsx3("span", { className: "ods-btn__icon ods-btn__icon--left", children: leftIcon }),
+        visibleLabel != null && visibleLabel !== false && /* @__PURE__ */ jsx3("span", { className: "ods-btn__label", children: visibleLabel }),
+        rightIcon && !loading && /* @__PURE__ */ jsx3("span", { className: "ods-btn__icon ods-btn__icon--right", children: rightIcon })
+      ] })
+    }
+  );
+});
+Button.displayName = "Button";
+
+// src/components/Input/Input.tsx
+import { CloseIcon } from "@octaviaflow/icons";
+import {
+  forwardRef as forwardRef4,
+  useId as useId3,
+  useImperativeHandle as useImperativeHandle2,
+  useRef as useRef3
+} from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var CLEAR_GLYPH = /* @__PURE__ */ jsx4(CloseIcon, { width: 12, height: 12, "aria-hidden": "true" });
+var Input = forwardRef4(
+  ({
+    type = "text",
+    size = "md",
+    error = false,
+    errorMessage,
+    label,
+    helperText,
+    leftIcon,
+    rightIcon,
+    clearable,
+    onClear,
+    shortcutHint,
+    disabled = false,
+    required,
+    id,
+    className,
+    value,
+    defaultValue,
+    onChange,
+    onKeyDown,
+    ...props
+  }, forwardedRef) => {
+    const innerRef = useRef3(null);
+    useImperativeHandle2(forwardedRef, () => innerRef.current);
+    const reactId = useId3();
+    const inputId = id ?? `${reactId}-input`;
+    const errorId = `${reactId}-err`;
+    const helperId = `${reactId}-help`;
+    const isControlled = value !== void 0;
+    const isClearable = (clearable ?? type === "search") && !disabled;
+    const isSearch = type === "search";
+    const currentValue = isControlled ? String(value ?? "") : innerRef.current?.value ?? String(defaultValue ?? "");
+    const showClear = isClearable && currentValue.length > 0;
+    const clearValue = () => {
+      const el = innerRef.current;
+      if (el && !isControlled) {
+        const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set;
+        setter?.call(el, "");
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+      }
+      onClear?.();
+      el?.focus();
+    };
+    const handleClear = (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      clearValue();
+    };
+    const handleKeyDown = (e) => {
+      onKeyDown?.(e);
+      if (e.defaultPrevented) return;
+      if (isClearable && isSearch && e.key === "Escape" && currentValue) {
+        e.preventDefault();
+        clearValue();
+      }
+    };
+    const describedBy = error && errorMessage ? errorId : helperText ? helperId : void 0;
+    return /* @__PURE__ */ jsxs4(
+      "div",
+      {
+        className: cn(
+          "ods-input",
+          `ods-input--${size}`,
+          error && "ods-input--error",
+          disabled && "ods-input--disabled",
+          isSearch && "ods-input--search",
+          className
+        ),
+        children: [
+          label && /* @__PURE__ */ jsxs4("label", { htmlFor: inputId, className: "ods-input__label", children: [
+            label,
+            required && /* @__PURE__ */ jsx4("span", { className: "ods-input__required", "aria-hidden": "true", children: "*" })
+          ] }),
+          /* @__PURE__ */ jsxs4("div", { className: "ods-input__wrapper", children: [
+            leftIcon && /* @__PURE__ */ jsx4("span", { className: "ods-input__icon--left", "aria-hidden": "true", children: leftIcon }),
+            /* @__PURE__ */ jsx4(
+              "input",
+              {
+                ...props,
+                id: inputId,
+                ref: innerRef,
+                type,
+                disabled,
+                required,
+                value,
+                defaultValue,
+                onChange,
+                onKeyDown: handleKeyDown,
+                className: cn(
+                  "ods-input__field",
+                  leftIcon && "ods-input__field--with-left-icon",
+                  (rightIcon || showClear || shortcutHint) && "ods-input__field--with-right-icon",
+                  showClear && shortcutHint && "ods-input__field--with-right-actions"
+                ),
+                "aria-invalid": error || void 0,
+                "aria-required": required || void 0,
+                "aria-describedby": describedBy
+              }
+            ),
+            /* @__PURE__ */ jsxs4("span", { className: "ods-input__right", children: [
+              showClear && /* @__PURE__ */ jsx4(
+                "button",
+                {
+                  type: "button",
+                  className: "ods-input__clear",
+                  onClick: handleClear,
+                  "aria-label": "Clear",
+                  tabIndex: -1,
+                  children: CLEAR_GLYPH
+                }
+              ),
+              shortcutHint && !showClear && /* @__PURE__ */ jsx4("span", { className: "ods-input__kbd", "aria-hidden": "true", children: shortcutHint }),
+              rightIcon && !showClear && !shortcutHint && /* @__PURE__ */ jsx4("span", { className: "ods-input__icon--right", "aria-hidden": "true", children: rightIcon })
+            ] })
+          ] }),
+          error && errorMessage && /* @__PURE__ */ jsx4("div", { id: errorId, className: "ods-input__error-message", role: "alert", children: errorMessage }),
+          !error && helperText && /* @__PURE__ */ jsx4("div", { id: helperId, className: "ods-input__helper", children: helperText })
+        ]
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+
+// src/components/Select/Select.tsx
+import { CheckmarkIcon, ChevronDownIcon as ChevronDownIcon2 } from "@octaviaflow/icons";
+import { AnimatePresence as AnimatePresence3, motion as motion4 } from "framer-motion";
+import {
+  forwardRef as forwardRef5,
+  useCallback as useCallback3,
+  useEffect as useEffect2,
+  useId as useId4,
+  useMemo,
+  useRef as useRef4,
+  useState as useState3
+} from "react";
+import { HiddenSelect, useButton as useButton2, useListBox, useOption, useSelect } from "react-aria";
+import { createPortal as createPortal2 } from "react-dom";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function OverflowTooltip({
+  enabled,
+  content,
+  children
+}) {
+  if (!enabled || content == null || content === "") return children;
+  return /* @__PURE__ */ jsx5(Tooltip, { content, children });
+}
+function ListBox(props) {
+  const ref = useRef4(null);
+  const { listBoxRef = ref, state, showCheckmark, showOverflowTooltips } = props;
+  const { listBoxProps } = useListBox(props, state, listBoxRef);
+  return /* @__PURE__ */ jsx5("ul", { ...listBoxProps, ref: listBoxRef, className: "ods-select__options", children: [...state.collection].map((item) => /* @__PURE__ */ jsx5(
+    Option,
+    {
+      item,
+      state,
+      showCheckmark,
+      showOverflowTooltips
+    },
+    item.key
+  )) });
+}
+function Option({
+  item,
+  state,
+  showCheckmark,
+  showOverflowTooltips
+}) {
+  const ref = useRef4(null);
+  const { optionProps, isSelected, isFocused, isDisabled } = useOption(
+    { key: item.key },
+    state,
+    ref
+  );
+  const raw = item.value;
+  const option = raw?.value ?? raw;
+  const tooltipContent = option?.description ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    /* @__PURE__ */ jsx5("span", { children: option.label }),
+    /* @__PURE__ */ jsx5("br", {}),
+    /* @__PURE__ */ jsx5("span", { style: { opacity: 0.75 }, children: option.description })
+  ] }) : option?.label;
+  return /* @__PURE__ */ jsx5(OverflowTooltip, { enabled: !!showOverflowTooltips, content: tooltipContent, children: /* @__PURE__ */ jsxs5(
+    "li",
+    {
+      ...optionProps,
+      ref,
+      className: cn(
+        "ods-select__option",
+        isFocused && "ods-select__option--highlighted",
+        isSelected && "ods-select__option--selected",
+        isDisabled && "ods-select__option--disabled"
+      ),
+      children: [
+        option?.icon && /* @__PURE__ */ jsx5("span", { className: "ods-select__option-icon", children: option.icon }),
+        /* @__PURE__ */ jsxs5("span", { className: "ods-select__option-text", children: [
+          /* @__PURE__ */ jsx5("span", { className: "ods-select__option-label", children: item.rendered }),
+          option?.description && /* @__PURE__ */ jsx5("span", { className: "ods-select__option-desc", children: option.description })
+        ] }),
+        isSelected && showCheckmark && /* @__PURE__ */ jsx5("span", { className: "ods-select__check", "aria-hidden": "true", children: /* @__PURE__ */ jsx5(CheckmarkIcon, { size: "xs", tone: "accent" }) })
+      ]
+    }
+  ) });
+}
+var DEFAULT_SELECT_PLACEHOLDER = "Select an option...";
+var Select = forwardRef5(function Select2({
+  options,
+  value,
+  defaultValue,
+  onChange,
+  placeholder = DEFAULT_SELECT_PLACEHOLDER,
+  searchable = false,
+  label,
+  error = false,
+  errorMessage,
+  helperText,
+  disabled = false,
+  size = "md",
+  className,
+  name,
+  required,
+  id: providedId,
+  form,
+  autoFocus,
+  "aria-label": ariaLabel,
+  "aria-labelledby": ariaLabelledBy,
+  "aria-describedby": consumerDescribedBy,
+  showCheckmark = false,
+  closeOnOutsideClick = true,
+  showOverflowTooltips = false,
+  dropdownMinWidth
+}, forwardedRef) {
+  const triggerRef = useRef4(null);
+  const listBoxRef = useRef4(null);
+  const dropdownRef = useRef4(null);
+  const searchRef = useRef4(null);
+  const [searchQuery, setSearchQuery] = useState3("");
+  const [dropdownPos, setDropdownPos] = useState3({ left: 0, width: 0, maxHeight: 240, direction: "down" });
+  const setTriggerRef = (node) => {
+    triggerRef.current = node;
+    if (typeof forwardedRef === "function") forwardedRef(node);
+    else if (forwardedRef) forwardedRef.current = node;
+  };
+  const reactId = useId4();
+  const baseId = providedId ?? `ods-select-${reactId}`;
+  const hintId = error || helperText ? `${baseId}-hint` : void 0;
+  const describedBy = [consumerDescribedBy, hintId].filter(Boolean).join(" ") || void 0;
+  const filteredOptions = useMemo(() => {
+    if (!searchable || !searchQuery) return options;
+    const q = searchQuery.toLowerCase();
+    return options.filter(
+      (o) => o.label.toLowerCase().includes(q) || o.description?.toLowerCase().includes(q)
+    );
+  }, [options, searchQuery, searchable]);
+  const ariaNameProps = useMemo(
+    () => resolveAccessibleName({
+      label,
+      ariaLabel,
+      ariaLabelledby: ariaLabelledBy,
+      componentName: "Select",
+      fallbacks: [
+        placeholder && placeholder !== DEFAULT_SELECT_PLACEHOLDER ? placeholder : void 0
+      ]
+    }),
+    [label, ariaLabel, ariaLabelledBy, placeholder]
+  );
+  const ariaProps = useMemo(() => {
+    const items = filteredOptions.map((o) => ({
+      key: o.value,
+      label: o.label,
+      value: o,
+      isDisabled: o.disabled
+    }));
+    const props = {
+      // Visible string label when present; otherwise rely on the aria-*
+      // props for screen-reader name.
+      label: typeof label === "string" ? label : void 0,
+      ...ariaNameProps,
+      items,
+      children: (item) => /* @__PURE__ */ jsx5($05678f3aee5e7d1a$export$6d08773d2e66f8f2, { textValue: item.label, children: item.label }, item.key),
+      isDisabled: disabled,
+      onSelectionChange: (key) => {
+        onChange?.(String(key));
+        setSearchQuery("");
+      }
+    };
+    if (value !== void 0) {
+      props.selectedKey = value;
+    }
+    if (defaultValue !== void 0) {
+      props.defaultSelectedKey = defaultValue;
+    }
+    return props;
+  }, [filteredOptions, label, disabled, value, defaultValue, onChange, ariaNameProps]);
+  const state = $29256f53a2edafe9$export$5159ec8b34d4ec12(ariaProps);
+  const { triggerProps, menuProps } = useSelect(ariaProps, state, triggerRef);
+  const { buttonProps } = useButton2(triggerProps, triggerRef);
+  const updatePosition = useCallback3(() => {
+    if (!triggerRef.current) return;
+    const rect = triggerRef.current.getBoundingClientRect();
+    const viewportH = window.innerHeight;
+    const margin = 8;
+    const gap = 4;
+    const spaceBelow = viewportH - rect.bottom - gap - margin;
+    const spaceAbove = rect.top - gap - margin;
+    const PREFERRED_MIN = 200;
+    const openUp = spaceBelow < PREFERRED_MIN && spaceAbove > spaceBelow;
+    setDropdownPos({
+      ...openUp ? { bottom: viewportH - rect.top + gap } : { top: rect.bottom + gap },
+      left: rect.left,
+      width: rect.width,
+      maxHeight: Math.max(120, openUp ? spaceAbove : spaceBelow),
+      direction: openUp ? "up" : "down"
+    });
+  }, []);
+  useEffect2(() => {
+    if (state.isOpen) {
+      updatePosition();
+      window.addEventListener("scroll", updatePosition, true);
+      window.addEventListener("resize", updatePosition);
+      return () => {
+        window.removeEventListener("scroll", updatePosition, true);
+        window.removeEventListener("resize", updatePosition);
+      };
+    }
+  }, [state.isOpen, updatePosition]);
+  useEffect2(() => {
+    if (state.isOpen && searchable && searchRef.current) {
+      requestAnimationFrame(() => searchRef.current?.focus());
+    }
+  }, [state.isOpen, searchable]);
+  useEffect2(() => {
+    if (!state.isOpen || !closeOnOutsideClick) return;
+    const onPointer = (e) => {
+      const target = e.target;
+      if (dropdownRef.current?.contains(target)) return;
+      if (triggerRef.current?.contains(target)) return;
+      state.close();
+    };
+    const onKey = (e) => {
+      if (e.key === "Escape") state.close();
+    };
+    document.addEventListener("mousedown", onPointer);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onPointer);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [state.isOpen, state.close, closeOnOutsideClick]);
+  const selectedOption = options.find((o) => o.value === String(state.selectedKey ?? ""));
+  const wasOpenBeforePressRef = useRef4(false);
+  const handleTriggerPointerDown = (e) => {
+    wasOpenBeforePressRef.current = state.isOpen;
+    const baseHandler = buttonProps.onPointerDown;
+    baseHandler?.(e);
+  };
+  const handleTriggerClick = (e) => {
+    const baseHandler = buttonProps.onClick;
+    baseHandler?.(e);
+    if (wasOpenBeforePressRef.current && state.isOpen) {
+      state.close();
+    }
+    wasOpenBeforePressRef.current = false;
+  };
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: cn(
+        "ods-select",
+        `ods-select--${size}`,
+        error && "ods-select--error",
+        disabled && "ods-select--disabled",
+        className
+      ),
+      children: [
+        label && /* @__PURE__ */ jsx5("label", { className: "ods-select__label", htmlFor: baseId, children: label }),
+        /* @__PURE__ */ jsx5(HiddenSelect, { state, triggerRef, label, name }),
+        /* @__PURE__ */ jsxs5(
+          "button",
+          {
+            ...buttonProps,
+            onPointerDown: handleTriggerPointerDown,
+            onClick: handleTriggerClick,
+            ref: setTriggerRef,
+            id: baseId,
+            form,
+            autoFocus,
+            "aria-label": ariaLabel,
+            "aria-labelledby": ariaLabelledBy,
+            "aria-describedby": describedBy,
+            "aria-required": required || void 0,
+            "aria-invalid": error ? true : void 0,
+            className: cn("ods-select__trigger", state.isOpen && "ods-select__trigger--open"),
+            children: [
+              /* @__PURE__ */ jsx5("span", { className: "ods-select__value", children: selectedOption ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+                selectedOption.icon && /* @__PURE__ */ jsx5("span", { className: "ods-select__value-icon", children: selectedOption.icon }),
+                selectedOption.label
+              ] }) : /* @__PURE__ */ jsx5("span", { className: "ods-select__placeholder", children: placeholder }) }),
+              /* @__PURE__ */ jsx5(
+                "span",
+                {
+                  className: cn("ods-select__chevron", state.isOpen && "ods-select__chevron--open"),
+                  "aria-hidden": "true",
+                  children: /* @__PURE__ */ jsx5(ChevronDownIcon2, { size: "xs" })
+                }
+              )
+            ]
+          }
+        ),
+        typeof document !== "undefined" && createPortal2(
+          /* @__PURE__ */ jsx5(AnimatePresence3, { children: state.isOpen && /* @__PURE__ */ jsxs5(
+            motion4.div,
+            {
+              ref: dropdownRef,
+              "data-ods-floating": "",
+              className: "ods-select__dropdown",
+              style: {
+                position: "fixed",
+                ...dropdownPos.top !== void 0 && { top: dropdownPos.top },
+                ...dropdownPos.bottom !== void 0 && { bottom: dropdownPos.bottom },
+                left: dropdownPos.left,
+                // `minWidth` (not `width`) keeps the popover at
+                // least as wide as the trigger — preserves visual
+                // alignment — but allows the consumer to widen it
+                // explicitly when option labels demand more room
+                // (pass `dropdownMinWidth` to set a higher floor).
+                // Avoids the previous `max-content` recipe which
+                // made the popover grow uncomfortably wide on
+                // searchable / long-option menus.
+                minWidth: Math.max(dropdownPos.width, dropdownMinWidth ?? 0),
+                // Bound the popover to the available viewport edge so
+                // it never spills off-screen on tall pages. Pairs with
+                // `overflow-y: auto` from the .ods-select__dropdown
+                // SCSS so long option lists scroll internally.
+                maxHeight: dropdownPos.maxHeight
+              },
+              initial: { opacity: 0, scale: 0.95 },
+              animate: { opacity: 1, scale: 1 },
+              exit: { opacity: 0, scale: 0.95 },
+              transition: { duration: 0.2, ease: [0.16, 1, 0.3, 1] },
+              children: [
+                searchable && /* @__PURE__ */ jsx5("div", { className: "ods-select__search-wrap", children: /* @__PURE__ */ jsx5(
+                  "input",
+                  {
+                    ref: searchRef,
+                    className: "ods-select__search",
+                    type: "text",
+                    placeholder: "Search...",
+                    value: searchQuery,
+                    onChange: (e) => setSearchQuery(e.target.value),
+                    "aria-label": "Search options",
+                    onKeyDown: (e) => {
+                      if (e.key === "Escape") {
+                        state.close();
+                      }
+                    }
+                  }
+                ) }),
+                /* @__PURE__ */ jsx5(
+                  ListBox,
+                  {
+                    ...menuProps,
+                    listBoxRef,
+                    state,
+                    showCheckmark,
+                    showOverflowTooltips
+                  }
+                ),
+                filteredOptions.length === 0 && /* @__PURE__ */ jsx5("div", { className: "ods-select__empty", children: "No results found" })
+              ]
+            }
+          ) }),
+          document.body
+        ),
+        error && errorMessage ? /* @__PURE__ */ jsx5("span", { id: hintId, className: "ods-select__error", role: "alert", children: errorMessage }) : helperText ? /* @__PURE__ */ jsx5("span", { id: hintId, className: "ods-select__hint", children: helperText }) : null
+      ]
+    }
+  );
+});
+Select.displayName = "Select";
+
+// src/components/Spinner/Spinner.tsx
+import { forwardRef as forwardRef6 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var SIZE_PX = {
+  sm: 16,
+  md: 24,
+  lg: 32,
+  xl: 48
+};
+var Spinner = forwardRef6(function Spinner2({ size = "md", tone = "accent", label = "Loading", className, style, ...rest }, ref) {
+  const px = typeof size === "number" ? size : SIZE_PX[size];
+  const isKeyword = typeof size === "string";
+  return /* @__PURE__ */ jsx6(
+    "svg",
+    {
+      ...rest,
+      ref,
+      className: cn(
+        "ods-spinner",
+        isKeyword && `ods-spinner--${size}`,
+        `ods-spinner--${tone}`,
+        className
+      ),
+      width: px,
+      height: px,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      role: "status",
+      "aria-label": label,
+      style,
+      children: /* @__PURE__ */ jsx6(
+        "circle",
+        {
+          cx: "12",
+          cy: "12",
+          r: "10",
+          strokeWidth: "3",
+          strokeLinecap: "round",
+          strokeDasharray: "31.4 31.4",
+          className: "ods-spinner__circle"
+        }
+      )
+    }
+  );
+});
+Spinner.displayName = "Spinner";
+
+export {
+  Accordion,
+  Slot,
+  $05678f3aee5e7d1a$export$6d08773d2e66f8f2,
+  $e3403870bfb691da$export$79fefeb1c2091ac3,
+  $384704861d32dbed$export$bca9d026f8e704eb,
+  $caeb030f09a278a1$export$4ba071daf4e486,
+  $fd3c5e01e837dc20$export$8042c6c013fd5226,
+  $6b915bde6cd300dd$export$728d6ba534403756,
+  getRenderableText,
+  resolveAccessibleName,
+  Tooltip,
+  Button,
+  Input,
+  Select,
+  Spinner
+};
+//# sourceMappingURL=chunk-23K2RF7Z.js.map