@aussieljk/forkbook 0.0.1-5 → 0.0.1-7

package/dist/_browser-chunks/{chunk-FVSEPWWX.js → chunk-DAUHYZUB.js}

@@ -2,102 +2,17 @@ import {
   __export
 } from "./chunk-IMSF75WX.js";
 
-// ../../node_modules/@base-ui/react/tabs/index.parts.mjs
-var index_parts_exports = {};
-__export(index_parts_exports, {
-  Indicator: () => TabsIndicator,
-  List: () => TabsList,
-  Panel: () => TabsPanel,
-  Root: () => TabsRoot,
-  Tab: () => TabsTab
-});
-
-// ../../node_modules/@base-ui/react/tabs/root/TabsRoot.mjs
-import * as React11 from "react";
-
-// ../../node_modules/@base-ui/utils/useControlled.mjs
-import * as React from "react";
-
-// ../../node_modules/@base-ui/utils/createLogOnce.mjs
-var loggedMessages;
-process.env.NODE_ENV !== "production" && (loggedMessages = /* @__PURE__ */ new Set());
-function createLogOnce(severity, prefix) {
-  return function(...messages) {
-    if (process.env.NODE_ENV !== "production") {
-      let message = messages.join(" "), output = prefix ? `${prefix}: ${message}` : message, key = `${severity}:${output}`;
-      loggedMessages.has(key) || (loggedMessages.add(key), severity === "warn" ? console.warn(output) : console.error(output));
-    }
-  };
-}
-
-// ../../node_modules/@base-ui/utils/error.mjs
-var error = createLogOnce("error", "Base UI");
-
-// ../../node_modules/@base-ui/utils/useControlled.mjs
-function useControlled({
-  controlled,
-  default: defaultProp,
-  name,
-  state = "value"
-}) {
-  let {
-    current: isControlled
-  } = React.useRef(controlled !== void 0), [valueState, setValue] = React.useState(() => defaultProp), value = isControlled && controlled !== void 0 ? controlled : valueState;
-  if (process.env.NODE_ENV !== "production") {
-    React.useEffect(() => {
-      isControlled !== (controlled !== void 0) && error([`A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
-`));
-    }, [state, name, controlled]);
-    let {
-      current: defaultValue
-    } = React.useRef(defaultProp);
-    React.useEffect(() => {
-      !isControlled && serializeToDevModeString(defaultValue) !== serializeToDevModeString(defaultProp) && error([`A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join(`
-`));
-    }, [defaultProp]);
-  }
-  let setValueIfUncontrolled = React.useCallback((newValue) => {
-    isControlled || setValue(newValue);
-  }, []);
-  return [value, setValueIfUncontrolled];
-}
-function serializeToDevModeString(input) {
-  let nextId = 0, seen = /* @__PURE__ */ new WeakMap();
-  try {
-    return JSON.stringify(input, function(key, value) {
-      if (!(key === "_owner" && this != null && typeof this == "object" && "$$typeof" in this)) {
-        if (typeof value == "bigint")
-          return `__bigint__:${value}`;
-        if (value !== null && typeof value == "object") {
-          let id = seen.get(value);
-          if (id !== void 0)
-            return `__object__:${id}`;
-          seen.set(value, nextId), nextId += 1;
-        }
-        return value;
-      }
-    }) ?? `__top__:${typeof input}`;
-  } catch {
-    return "__unserializable__";
-  }
-}
-
-// ../../node_modules/@base-ui/utils/useIsoLayoutEffect.mjs
-import * as React2 from "react";
-var noop = () => {
-}, useIsoLayoutEffect = typeof document < "u" ? React2.useLayoutEffect : noop;
-
 // ../../node_modules/@base-ui/utils/safeReact.mjs
-import * as React3 from "react";
+import * as React from "react";
 var SafeReact = {
-  ...React3
+  ...React
 };
 
 // ../../node_modules/@base-ui/utils/useRefWithInit.mjs
-import * as React4 from "react";
+import * as React2 from "react";
 var UNINITIALIZED = {};
 function useRefWithInit(init, initArg) {
-  let ref = React4.useRef(UNINITIALIZED);
+  let ref = React2.useRef(UNINITIALIZED);
   return ref.current === UNINITIALIZED && (ref.current = init(initArg)), ref;
 }
 
@@ -130,8 +45,17 @@ function assertNotCalled() {
     );
 }
 
+// ../../node_modules/@base-ui/utils/formatErrorMessage.mjs
+function createFormatErrorMessage(baseUrl, prefix) {
+  return function(code, ...args) {
+    let url = new URL(baseUrl);
+    return url.searchParams.set("code", code.toString()), args.forEach((arg) => url.searchParams.append("args[]", arg)), `${prefix} error #${code}; visit ${url} for the full message.`;
+  };
+}
+var formatErrorMessage = createFormatErrorMessage("https://base-ui.com/production-error", "Base UI"), formatErrorMessage_default = formatErrorMessage;
+
 // ../../node_modules/@base-ui/react/internals/useRenderElement.mjs
-import * as React7 from "react";
+import * as React5 from "react";
 
 // ../../node_modules/@base-ui/utils/useMergedRefs.mjs
 function useMergedRefs(a, b, c, d) {
@@ -153,7 +77,7 @@ function didChange(forkRef, a, b, c, d) {
   return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
 }
 function didChangeN(forkRef, newRefs) {
-  return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index2) => ref !== newRefs[index2]);
+  return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) => ref !== newRefs[index]);
 }
 function update(forkRef, refs) {
   if (forkRef.refs = refs, refs.every((ref) => ref == null)) {
@@ -202,18 +126,18 @@ function update(forkRef, refs) {
 }
 
 // ../../node_modules/@base-ui/utils/getReactElementRef.mjs
-import * as React6 from "react";
+import * as React4 from "react";
 
 // ../../node_modules/@base-ui/utils/reactVersion.mjs
-import * as React5 from "react";
-var majorVersion = parseInt(React5.version, 10);
+import * as React3 from "react";
+var majorVersion = parseInt(React3.version, 10);
 function isReactVersionAtLeast(reactVersionToCheck) {
   return majorVersion >= reactVersionToCheck;
 }
 
 // ../../node_modules/@base-ui/utils/getReactElementRef.mjs
 function getReactElementRef(element) {
-  if (!React6.isValidElement(element))
+  if (!React4.isValidElement(element))
     return null;
   let reactElement = element, propsWithRef = reactElement.props;
   return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
@@ -232,6 +156,18 @@ function mergeObjects(a, b) {
     };
 }
 
+// ../../node_modules/@base-ui/utils/createLogOnce.mjs
+var loggedMessages;
+process.env.NODE_ENV !== "production" && (loggedMessages = /* @__PURE__ */ new Set());
+function createLogOnce(severity, prefix) {
+  return function(...messages) {
+    if (process.env.NODE_ENV !== "production") {
+      let message = messages.join(" "), output = prefix ? `${prefix}: ${message}` : message, key = `${severity}:${output}`;
+      loggedMessages.has(key) || (loggedMessages.add(key), severity === "warn" ? console.warn(output) : console.error(output));
+    }
+  };
+}
+
 // ../../node_modules/@base-ui/utils/warn.mjs
 var warn = createLogOnce("warn", "Base UI");
 
@@ -378,9 +314,9 @@ function useRenderElementProps(componentProps, params, renderProp) {
     state = EMPTY_OBJECT,
     ref,
     props,
-    stateAttributesMapping: stateAttributesMapping3,
+    stateAttributesMapping,
     enabled = !0
-  } = params, className = enabled ? resolveClassName(classNameProp, state) : void 0, style = enabled ? resolveStyle(styleProp, state) : void 0, stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping3) : EMPTY_OBJECT, resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0, outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
+  } = params, className = enabled ? resolveClassName(classNameProp, state) : void 0, style = enabled ? resolveStyle(styleProp, state) : void 0, stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT, resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0, outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
   return typeof document < "u" && (enabled ? Array.isArray(ref) ? outProps.ref = useMergedRefsN([outProps.ref, getReactElementRef(renderProp), ...ref]) : outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref) : useMergedRefs(null, null)), enabled ? (className !== void 0 && (outProps.className = mergeClassNames(outProps.className, className)), style !== void 0 && (outProps.style = mergeObjects(outProps.style, style)), outProps) : EMPTY_OBJECT;
 }
 function resolveRenderFunctionProps(props) {
@@ -390,18 +326,18 @@ var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), COMPONENT_IDENTI
 function unwrapLazyRenderProp(render) {
   if (render?.$$typeof !== REACT_LAZY_TYPE)
     return render;
-  let unwrapped = React7.Children.toArray(render)[0];
-  return React7.isValidElement(unwrapped) ? unwrapped : render;
+  let unwrapped = React5.Children.toArray(render)[0];
+  return React5.isValidElement(unwrapped) ? unwrapped : render;
 }
 function evaluateRenderProp(element, render, props, state) {
   if (render) {
     if (typeof render == "function")
       return process.env.NODE_ENV !== "production" && warnIfRenderPropLooksLikeComponent(render), render(props, state);
     let mergedProps = mergeProps(props, render.props);
-    if (mergedProps.ref = props.ref, process.env.NODE_ENV !== "production" && !React7.isValidElement(render))
+    if (mergedProps.ref = props.ref, process.env.NODE_ENV !== "production" && !React5.isValidElement(render))
       throw new Error(["Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.", "A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.", "https://base-ui.com/r/invalid-render-prop"].join(`
 `));
-    return React7.cloneElement(render, mergedProps);
+    return React5.cloneElement(render, mergedProps);
   }
   return renderTag(element, props);
 }
@@ -418,382 +354,43 @@ function renderTag(Tag, props) {
     alt: "",
     ...props,
     key: props.key
-  }) : React7.createElement(Tag, props);
+  }) : React5.createElement(Tag, props);
 }
 
-// ../../node_modules/@base-ui/react/internals/composite/list/CompositeList.mjs
-import * as React9 from "react";
-
-// ../../node_modules/@base-ui/react/internals/composite/list/CompositeListContext.mjs
-import * as React8 from "react";
-var CompositeListContext = React8.createContext({
-  register: () => {
-  },
-  unregister: () => {
-  },
-  subscribeMapChange: () => () => {
-  },
-  nextIndexRef: {
-    current: 0
-  }
-});
-process.env.NODE_ENV !== "production" && (CompositeListContext.displayName = "CompositeListContext");
-function useCompositeListContext() {
-  return React8.useContext(CompositeListContext);
-}
+// ../../node_modules/@base-ui/utils/useId.mjs
+import * as React7 from "react";
 
-// ../../node_modules/@base-ui/react/internals/composite/list/CompositeList.mjs
-import { jsx as _jsx } from "react/jsx-runtime";
-function CompositeList(props) {
-  let {
-    children,
-    elementsRef,
-    labelsRef,
-    onMapChange: onMapChangeProp
-  } = props, onMapChange = useStableCallback(onMapChangeProp), [, setMapTick] = React9.useState(0), listeners = useRefWithInit(createListeners).current, map = useRefWithInit(createMap).current, nextIndexRef = React9.useRef(0), isDirtyRef = React9.useRef(!0), itemsRef = React9.useRef(null), mutationObserverRef = React9.useRef(null), scheduleMapUpdate = useStableCallback(() => {
-    isDirtyRef.current || (isDirtyRef.current = !0, setMapTick((tick) => tick + 1));
-  }), register = useStableCallback((node, registration) => {
-    map.set(node, registration), scheduleMapUpdate();
-  }), unregister = useStableCallback((node) => {
-    map.delete(node), scheduleMapUpdate();
-  }), syncRefs = useStableCallback((items) => {
-    let nextMap = /* @__PURE__ */ new Map();
-    return elementsRef.current.length = 0, labelsRef && (labelsRef.current.length = 0), items.forEach((item) => {
-      nextMap.set(item.element, {
-        ...item.registration.metadata ?? {},
-        index: item.index
-      }), elementsRef.current[item.index] = item.element, labelsRef && (labelsRef.current[item.index] = item.registration.label !== void 0 ? item.registration.label : item.registration.textRef?.current?.textContent ?? item.element.textContent);
-    }), nextIndexRef.current = elementsRef.current.length, nextMap;
-  });
-  function observe(sortedNodes) {
-    if (mutationObserverRef.current?.disconnect(), mutationObserverRef.current = null, typeof MutationObserver != "function" || sortedNodes.length < 2)
-      return;
-    let mutationObserver = new MutationObserver((entries) => {
-      if (!hasMovedNode(entries))
-        return;
-      let previousConnectedNode = null;
-      for (let node of sortedNodes)
-        if (node.isConnected) {
-          if (previousConnectedNode && sortByDocumentPosition(previousConnectedNode, node) > 0) {
-            mutationObserver.disconnect(), scheduleMapUpdate();
-            return;
-          }
-          previousConnectedNode = node;
-        }
-    });
-    mutationObserverRef.current = mutationObserver;
-    let roots = /* @__PURE__ */ new Set();
-    for (let i = 1; i < sortedNodes.length; i += 1) {
-      let root = getCommonAncestor(sortedNodes[i - 1], sortedNodes[i]);
-      root && roots.add(root);
-    }
-    roots.forEach((root) => mutationObserver.observe(root, {
-      childList: !0
-    }));
-  }
-  let flush = useStableCallback(() => {
-    let [items, automaticNodes] = getCompositeListSnapshot(map), nextMap = syncRefs(items), previousItems = itemsRef.current, changed = !previousItems || previousItems.length !== items.length || items.some((item, index2) => {
-      let previousItem = previousItems[index2];
-      return item.index !== previousItem.index || item.element !== previousItem.element || item.registration.index !== previousItem.registration.index || item.registration.metadata !== previousItem.registration.metadata;
-    });
-    observe(automaticNodes), itemsRef.current = items, isDirtyRef.current = !1, changed && (listeners.forEach((listener) => listener(nextMap)), onMapChange(nextMap));
-  });
-  useIsoLayoutEffect(() => (!isDirtyRef.current && itemsRef.current && syncRefs(itemsRef.current), () => {
-    elementsRef.current = [], labelsRef && (labelsRef.current = []);
-  }), [elementsRef, labelsRef, syncRefs]), useIsoLayoutEffect(() => {
-    isDirtyRef.current && flush();
-  }), useIsoLayoutEffect(() => () => {
-    mutationObserverRef.current?.disconnect(), isDirtyRef.current = !0;
+// ../../node_modules/@base-ui/utils/useForcedRerendering.mjs
+import * as React6 from "react";
+function useForcedRerendering() {
+  let [, setState] = React6.useState({});
+  return React6.useCallback(() => {
+    setState({});
   }, []);
-  let subscribeMapChange = useStableCallback((fn) => (listeners.add(fn), () => {
-    listeners.delete(fn);
-  })), contextValue = React9.useMemo(() => ({
-    register,
-    unregister,
-    subscribeMapChange,
-    nextIndexRef
-  }), [register, unregister, subscribeMapChange, nextIndexRef]);
-  return _jsx(CompositeListContext.Provider, {
-    value: contextValue,
-    children
-  });
-}
-function createMap() {
-  return /* @__PURE__ */ new Map();
-}
-function createListeners() {
-  return /* @__PURE__ */ new Set();
-}
-function getCompositeListSnapshot(map) {
-  let reservedIndices = /* @__PURE__ */ new Set(), items = [], automaticItems = [];
-  map.forEach((registration, node) => {
-    if (!node.isConnected)
-      return;
-    let index2 = registration.index, item = {
-      index: index2 ?? -1,
-      element: node,
-      registration
-    };
-    index2 === null ? automaticItems.push(item) : index2 >= 0 && (reservedIndices.add(index2), items.push(item));
-  });
-  let nextAutomaticIndex = 0;
-  return automaticItems.sort((a, b) => sortByDocumentPosition(a.element, b.element)), automaticItems.forEach((item) => {
-    for (; reservedIndices.has(nextAutomaticIndex); )
-      nextAutomaticIndex += 1;
-    item.index = nextAutomaticIndex, items.push(item), nextAutomaticIndex += 1;
-  }), reservedIndices.size > 0 && items.sort((a, b) => a.index - b.index), [items, automaticItems.map((item) => item.element)];
-}
-function getCommonAncestor(firstNode, lastNode) {
-  let ancestor = firstNode.parentElement;
-  for (; ancestor && !ancestor.contains(lastNode); )
-    ancestor = ancestor.parentElement;
-  return ancestor;
-}
-function hasMovedNode(entries) {
-  for (let entry of entries)
-    for (let i = 0; i < entry.removedNodes.length; i += 1)
-      if (entry.removedNodes[i].isConnected)
-        return !0;
-  return !1;
-}
-function sortByDocumentPosition(a, b) {
-  return a.nextElementSibling === b ? -1 : b.nextElementSibling === a ? 1 : a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
-}
-
-// ../../node_modules/@base-ui/utils/formatErrorMessage.mjs
-function createFormatErrorMessage(baseUrl, prefix) {
-  return function(code, ...args) {
-    let url = new URL(baseUrl);
-    return url.searchParams.set("code", code.toString()), args.forEach((arg) => url.searchParams.append("args[]", arg)), `${prefix} error #${code}; visit ${url} for the full message.`;
-  };
 }
-var formatErrorMessage = createFormatErrorMessage("https://base-ui.com/production-error", "Base UI"), formatErrorMessage_default = formatErrorMessage;
 
-// ../../node_modules/@base-ui/react/tabs/root/TabsRootContext.mjs
-import * as React10 from "react";
-var TabsRootContext = React10.createContext(void 0);
-process.env.NODE_ENV !== "production" && (TabsRootContext.displayName = "TabsRootContext");
-function useTabsRootContext() {
-  let context = React10.useContext(TabsRootContext);
-  if (context === void 0)
-    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TabsRootContext is missing. Tabs parts must be placed within <Tabs.Root>." : formatErrorMessage_default(64));
-  return context;
+// ../../node_modules/@base-ui/utils/useId.mjs
+var globalId = 0;
+function useGlobalId(idOverride, prefix = "mui") {
+  let defaultId = React7.useRef(void 0), forceRerender = useForcedRerendering(), id = idOverride ?? defaultId.current;
+  return React7.useEffect(() => {
+    defaultId.current == null && (globalId += 1, defaultId.current = `${prefix}-${globalId}`, idOverride == null && forceRerender());
+  }, [idOverride, prefix, forceRerender]), id;
 }
-
-// ../../node_modules/@base-ui/react/tabs/root/TabsRootDataAttributes.mjs
-var activationDirection = "data-activation-direction";
-
-// ../../node_modules/@base-ui/react/tabs/root/stateAttributesMapping.mjs
-var tabsStateAttributesMapping = {
-  tabActivationDirection: (dir) => ({
-    [activationDirection]: dir
-  })
-};
-
-// ../../node_modules/@base-ui/react/internals/createBaseUIEventDetails.mjs
-function createChangeEventDetails(reason, event, trigger, customProperties) {
-  let canceled = !1, allowPropagation = !1, custom = customProperties ?? EMPTY_OBJECT;
-  return {
-    reason,
-    event: event ?? new Event("base-ui"),
-    cancel() {
-      canceled = !0;
-    },
-    allowPropagation() {
-      allowPropagation = !0;
-    },
-    get isCanceled() {
-      return canceled;
-    },
-    get isPropagationAllowed() {
-      return allowPropagation;
-    },
-    trigger,
-    ...custom
-  };
+var maybeReactUseId = SafeReact.useId;
+function useId(idOverride, prefix) {
+  if (maybeReactUseId !== void 0) {
+    let reactId = maybeReactUseId();
+    return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+  }
+  return useGlobalId(idOverride, prefix);
 }
 
-// ../../node_modules/@base-ui/react/internals/reason-parts.mjs
-var reason_parts_exports = {};
-__export(reason_parts_exports, {
-  cancelOpen: () => cancelOpen,
-  chipRemovePress: () => chipRemovePress,
-  clearPress: () => clearPress,
-  closePress: () => closePress,
-  closeWatcher: () => closeWatcher,
-  decrementPress: () => decrementPress,
-  disabled: () => disabled,
-  drag: () => drag,
-  escapeKey: () => escapeKey,
-  focusOut: () => focusOut,
-  imperativeAction: () => imperativeAction,
-  incrementPress: () => incrementPress,
-  initial: () => initial,
-  inputBlur: () => inputBlur,
-  inputChange: () => inputChange,
-  inputClear: () => inputClear,
-  inputPaste: () => inputPaste,
-  inputPress: () => inputPress,
-  itemPress: () => itemPress,
-  keyboard: () => keyboard,
-  linkPress: () => linkPress,
-  listNavigation: () => listNavigation,
-  missing: () => missing,
-  none: () => none,
-  outsidePress: () => outsidePress,
-  pointer: () => pointer,
-  popupClose: () => popupClose,
-  scrub: () => scrub,
-  siblingOpen: () => siblingOpen,
-  swipe: () => swipe,
-  trackPress: () => trackPress,
-  triggerFocus: () => triggerFocus,
-  triggerHover: () => triggerHover,
-  triggerPress: () => triggerPress,
-  wheel: () => wheel,
-  windowResize: () => windowResize
-});
-var none = "none", triggerPress = "trigger-press", triggerHover = "trigger-hover", triggerFocus = "trigger-focus", outsidePress = "outside-press", itemPress = "item-press", closePress = "close-press", linkPress = "link-press", clearPress = "clear-press", chipRemovePress = "chip-remove-press", trackPress = "track-press", incrementPress = "increment-press", decrementPress = "decrement-press", inputChange = "input-change", inputClear = "input-clear", inputBlur = "input-blur", inputPaste = "input-paste", inputPress = "input-press", focusOut = "focus-out", escapeKey = "escape-key", closeWatcher = "close-watcher", listNavigation = "list-navigation", keyboard = "keyboard", pointer = "pointer", drag = "drag", wheel = "wheel", scrub = "scrub", popupClose = "popup-close", cancelOpen = "cancel-open", siblingOpen = "sibling-open", disabled = "disabled", missing = "missing", initial = "initial", imperativeAction = "imperative-action", swipe = "swipe", windowResize = "window-resize";
-
-// ../../node_modules/@base-ui/react/tabs/root/TabsRoot.mjs
-import { jsx as _jsx2 } from "react/jsx-runtime";
-var TabsRoot = React11.forwardRef(function(componentProps, forwardedRef) {
-  let {
-    className,
-    defaultValue: defaultValueProp = 0,
-    onValueChange: onValueChangeProp,
-    orientation = "horizontal",
-    render,
-    value: valueProp,
-    style,
-    ...elementProps
-  } = componentProps, hasExplicitDefaultValueProp = componentProps.defaultValue !== void 0, tabPanelRefs = React11.useRef([]), [mountedTabPanels, setMountedTabPanels] = React11.useState(() => /* @__PURE__ */ new Map()), [value, setValue] = useControlled({
-    controlled: valueProp,
-    default: defaultValueProp,
-    name: "Tabs",
-    state: "value"
-  }), isControlled = valueProp !== void 0, [tabMap, setTabMap] = React11.useState(() => /* @__PURE__ */ new Map()), lastKnownTabElementRef = React11.useRef(void 0), getTabElementBySelectedValue = React11.useCallback((selectedValue) => findTabElement(tabMap, selectedValue), [tabMap]), [activationDirectionState, setActivationDirectionState] = React11.useState(() => ({
-    previousValue: value,
-    tabActivationDirection: "none"
-  })), {
-    previousValue,
-    tabActivationDirection: committedTabActivationDirection
-  } = activationDirectionState, tabActivationDirection = committedTabActivationDirection, directionComputationIncomplete = !1;
-  previousValue !== value && (tabActivationDirection = computeActivationDirection(previousValue, value, orientation, tabMap), directionComputationIncomplete = previousValue != null && value != null && getTabElementBySelectedValue(value) == null);
-  let nextPreviousValue = directionComputationIncomplete ? previousValue : value, shouldSyncActivationDirectionState = previousValue !== nextPreviousValue || committedTabActivationDirection !== tabActivationDirection;
-  useIsoLayoutEffect(() => {
-    shouldSyncActivationDirectionState && setActivationDirectionState({
-      previousValue: nextPreviousValue,
-      tabActivationDirection
-    });
-  }, [nextPreviousValue, shouldSyncActivationDirectionState, tabActivationDirection]);
-  let onValueChange = useStableCallback((newValue, eventDetails) => {
-    let activationDirection2 = computeActivationDirection(value, newValue, orientation, tabMap);
-    eventDetails.activationDirection = activationDirection2, onValueChangeProp?.(newValue, eventDetails), !eventDetails.isCanceled && setValue(() => newValue);
-  }), notifyAutomaticValueChange = useStableCallback((nextValue, reason) => {
-    onValueChangeProp?.(nextValue, createChangeEventDetails(reason, void 0, void 0, {
-      activationDirection: "none"
-    }));
-  }), registerMountedTabPanel = useStableCallback((panelValue, panelId) => (setMountedTabPanels((prev) => {
-    let next = new Map(prev);
-    return next.set(panelValue, panelId), next;
-  }), () => {
-    setMountedTabPanels((prev) => {
-      if (prev.get(panelValue) !== panelId)
-        return prev;
-      let next = new Map(prev);
-      return next.delete(panelValue), next;
-    });
-  })), getTabPanelIdByValue = React11.useCallback((tabValue) => mountedTabPanels.get(tabValue), [mountedTabPanels]), getTabIdByPanelValue = React11.useCallback((tabPanelValue) => {
-    for (let tabMetadata of tabMap.values())
-      if (tabPanelValue === tabMetadata.value)
-        return tabMetadata.id;
-  }, [tabMap]), tabsContextValue = React11.useMemo(() => ({
-    getTabElementBySelectedValue,
-    getTabIdByPanelValue,
-    getTabPanelIdByValue,
-    onValueChange,
-    orientation,
-    registerMountedTabPanel,
-    setTabMap,
-    tabActivationDirection,
-    value
-  }), [getTabElementBySelectedValue, getTabIdByPanelValue, getTabPanelIdByValue, onValueChange, orientation, registerMountedTabPanel, setTabMap, tabActivationDirection, value]), selectedTabMetadata = React11.useMemo(() => {
-    for (let tabMetadata of tabMap.values())
-      if (tabMetadata.value === value)
-        return tabMetadata;
-  }, [tabMap, value]), firstEnabledTabValue = React11.useMemo(() => {
-    for (let tabMetadata of tabMap.values())
-      if (!tabMetadata.disabled)
-        return tabMetadata.value;
-  }, [tabMap]), shouldNotifyInitialValueChangeRef = React11.useRef(!hasExplicitDefaultValueProp), initialDefaultValueRef = React11.useRef(defaultValueProp), shouldHonorDisabledDefaultValueRef = React11.useRef(hasExplicitDefaultValueProp), didRegisterTabsRef = React11.useRef(!1);
-  useIsoLayoutEffect(() => {
-    if (isControlled)
-      return;
-    function commitAutomaticValueChange(fallbackValue, fallbackReason) {
-      setValue(() => fallbackValue), setActivationDirectionState({
-        previousValue: fallbackValue,
-        tabActivationDirection: "none"
-      }), notifyAutomaticValueChange(fallbackValue, fallbackReason), shouldNotifyInitialValueChangeRef.current = !1;
-    }
-    if (tabMap.size === 0) {
-      didRegisterTabsRef.current && value !== null && !lastKnownTabElementRef.current?.isConnected && commitAutomaticValueChange(null, reason_parts_exports.missing);
-      return;
-    }
-    didRegisterTabsRef.current = !0, lastKnownTabElementRef.current = tabMap.keys().next().value;
-    let selectionIsDisabled = selectedTabMetadata?.disabled, selectionIsMissing = selectedTabMetadata == null && value !== null;
-    if (!selectionIsDisabled && value === initialDefaultValueRef.current && (shouldHonorDisabledDefaultValueRef.current = !1), shouldHonorDisabledDefaultValueRef.current && selectionIsDisabled && value === initialDefaultValueRef.current)
-      return;
-    let shouldNotifyInitialValueChange = shouldNotifyInitialValueChangeRef.current;
-    if (selectionIsDisabled || selectionIsMissing) {
-      let fallbackValue = firstEnabledTabValue ?? null;
-      if (value === fallbackValue) {
-        shouldNotifyInitialValueChangeRef.current = !1;
-        return;
-      }
-      let fallbackReason = reason_parts_exports.missing;
-      shouldNotifyInitialValueChange ? fallbackReason = reason_parts_exports.initial : selectionIsDisabled && (fallbackReason = reason_parts_exports.disabled), commitAutomaticValueChange(fallbackValue, fallbackReason);
-      return;
-    }
-    shouldNotifyInitialValueChange && selectedTabMetadata != null && (notifyAutomaticValueChange(value, reason_parts_exports.initial), shouldNotifyInitialValueChangeRef.current = !1);
-  }, [firstEnabledTabValue, isControlled, notifyAutomaticValueChange, selectedTabMetadata, setValue, tabMap, value]);
-  let element = useRenderElement("div", componentProps, {
-    state: {
-      orientation,
-      tabActivationDirection
-    },
-    ref: forwardedRef,
-    props: elementProps,
-    stateAttributesMapping: tabsStateAttributesMapping
-  });
-  return _jsx2(TabsRootContext.Provider, {
-    value: tabsContextValue,
-    children: _jsx2(CompositeList, {
-      elementsRef: tabPanelRefs,
-      children: element
-    })
-  });
-});
-process.env.NODE_ENV !== "production" && (TabsRoot.displayName = "TabsRoot");
-function findTabElement(tabMap, value) {
-  for (let [tabElement, tabMetadata] of tabMap.entries())
-    if (value === tabMetadata.value)
-      return tabElement;
-  return null;
-}
-function computeActivationDirection(oldValue, newValue, orientation, tabMap) {
-  if (oldValue == null || newValue == null)
-    return "none";
-  let [positionProp, backward, forward] = orientation === "horizontal" ? ["left", "left", "right"] : ["top", "up", "down"], oldTab = findTabElement(tabMap, oldValue), newTab = findTabElement(tabMap, newValue);
-  if (oldTab == null || newTab == null)
-    return oldTab !== newTab && (typeof oldValue == "number" || typeof oldValue == "string") && typeof oldValue == typeof newValue ? newValue > oldValue ? forward : backward : "none";
-  let oldPosition = oldTab.getBoundingClientRect()[positionProp], newPosition = newTab.getBoundingClientRect()[positionProp];
-  return newPosition < oldPosition ? backward : newPosition > oldPosition ? forward : "none";
+// ../../node_modules/@base-ui/react/internals/useBaseUiId.mjs
+function useBaseUiId(idOverride) {
+  return useId(idOverride, "base-ui");
 }
 
-// ../../node_modules/@base-ui/react/tabs/tab/TabsTab.mjs
-import * as React20 from "react";
-
 // ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
 function hasWindow() {
   return typeof window < "u";
@@ -909,61 +506,350 @@ function getFrameElement(win) {
   return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
 
-// ../../node_modules/@base-ui/utils/owner.mjs
-function ownerDocument(node) {
-  return node?.ownerDocument || document;
-}
+// ../../node_modules/@base-ui/react/utils/CommonPopupDataAttributes.mjs
+var CommonPopupDataAttributes_exports = {};
+__export(CommonPopupDataAttributes_exports, {
+  align: () => align,
+  anchorHidden: () => anchorHidden,
+  closed: () => closed,
+  endingStyle: () => endingStyle2,
+  open: () => open,
+  side: () => side,
+  startingStyle: () => startingStyle2
+});
 
-// ../../node_modules/@base-ui/utils/useId.mjs
-import * as React13 from "react";
+// ../../node_modules/@base-ui/react/internals/TransitionStatusDataAttributes.mjs
+var TransitionStatusDataAttributes_exports = {};
+__export(TransitionStatusDataAttributes_exports, {
+  endingStyle: () => endingStyle,
+  startingStyle: () => startingStyle
+});
+var startingStyle = "data-starting-style", endingStyle = "data-ending-style";
 
-// ../../node_modules/@base-ui/utils/useForcedRerendering.mjs
-import * as React12 from "react";
-function useForcedRerendering() {
-  let [, setState] = React12.useState({});
-  return React12.useCallback(() => {
-    setState({});
-  }, []);
-}
+// ../../node_modules/@base-ui/react/utils/CommonPopupDataAttributes.mjs
+var open = "data-open", closed = "data-closed", startingStyle2 = startingStyle, endingStyle2 = endingStyle, anchorHidden = "data-anchor-hidden", side = "data-side", align = "data-align";
 
-// ../../node_modules/@base-ui/utils/useId.mjs
-var globalId = 0;
-function useGlobalId(idOverride, prefix = "mui") {
-  let defaultId = React13.useRef(void 0), forceRerender = useForcedRerendering(), id = idOverride ?? defaultId.current;
-  return React13.useEffect(() => {
-    defaultId.current == null && (globalId += 1, defaultId.current = `${prefix}-${globalId}`, idOverride == null && forceRerender());
-  }, [idOverride, prefix, forceRerender]), id;
+// ../../node_modules/@base-ui/react/utils/CommonTriggerDataAttributes.mjs
+var CommonTriggerDataAttributes_exports = {};
+__export(CommonTriggerDataAttributes_exports, {
+  popupOpen: () => popupOpen,
+  pressed: () => pressed
+});
+var popupOpen = "data-popup-open", pressed = "data-pressed";
+
+// ../../node_modules/@base-ui/react/internals/stateAttributesMapping.mjs
+var STARTING_HOOK = {
+  [startingStyle]: ""
+}, ENDING_HOOK = {
+  [endingStyle]: ""
+}, transitionStatusMapping = {
+  transitionStatus(value) {
+    return value === "starting" ? STARTING_HOOK : value === "ending" ? ENDING_HOOK : null;
+  }
+};
+
+// ../../node_modules/@base-ui/react/utils/popupStateMapping.mjs
+var TRIGGER_HOOK = {
+  [popupOpen]: ""
+}, PRESSABLE_TRIGGER_HOOK = {
+  [popupOpen]: "",
+  [pressed]: ""
+}, POPUP_OPEN_HOOK = {
+  [open]: ""
+}, POPUP_CLOSED_HOOK = {
+  [closed]: ""
+}, ANCHOR_HIDDEN_HOOK = {
+  [anchorHidden]: ""
+}, triggerOpenStateMapping = {
+  open(value) {
+    return value ? TRIGGER_HOOK : null;
+  }
+}, pressableTriggerOpenStateMapping = {
+  open(value) {
+    return value ? PRESSABLE_TRIGGER_HOOK : null;
+  }
+}, popupStateMapping = {
+  open(value) {
+    return value ? POPUP_OPEN_HOOK : POPUP_CLOSED_HOOK;
+  },
+  anchorHidden(value) {
+    return value ? ANCHOR_HIDDEN_HOOK : null;
+  }
+}, popupTransitionStateMapping = {
+  ...popupStateMapping,
+  ...transitionStatusMapping
+};
+
+// ../../node_modules/@base-ui/react/tooltip/trigger/TooltipTriggerDataAttributes.mjs
+var popupOpen2 = CommonTriggerDataAttributes_exports.popupOpen, triggerDisabled = "data-trigger-disabled";
+
+// ../../node_modules/@base-ui/react/internals/createBaseUIEventDetails.mjs
+function createChangeEventDetails(reason, event, trigger, customProperties) {
+  let canceled = !1, allowPropagation = !1, custom = customProperties ?? EMPTY_OBJECT;
+  return {
+    reason,
+    event: event ?? new Event("base-ui"),
+    cancel() {
+      canceled = !0;
+    },
+    allowPropagation() {
+      allowPropagation = !0;
+    },
+    get isCanceled() {
+      return canceled;
+    },
+    get isPropagationAllowed() {
+      return allowPropagation;
+    },
+    trigger,
+    ...custom
+  };
 }
-var maybeReactUseId = SafeReact.useId;
-function useId(idOverride, prefix) {
-  if (maybeReactUseId !== void 0) {
-    let reactId = maybeReactUseId();
-    return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+
+// ../../node_modules/@base-ui/react/internals/reason-parts.mjs
+var reason_parts_exports = {};
+__export(reason_parts_exports, {
+  cancelOpen: () => cancelOpen,
+  chipRemovePress: () => chipRemovePress,
+  clearPress: () => clearPress,
+  closePress: () => closePress,
+  closeWatcher: () => closeWatcher,
+  decrementPress: () => decrementPress,
+  disabled: () => disabled,
+  drag: () => drag,
+  escapeKey: () => escapeKey,
+  focusOut: () => focusOut,
+  imperativeAction: () => imperativeAction,
+  incrementPress: () => incrementPress,
+  initial: () => initial,
+  inputBlur: () => inputBlur,
+  inputChange: () => inputChange,
+  inputClear: () => inputClear,
+  inputPaste: () => inputPaste,
+  inputPress: () => inputPress,
+  itemPress: () => itemPress,
+  keyboard: () => keyboard,
+  linkPress: () => linkPress,
+  listNavigation: () => listNavigation,
+  missing: () => missing,
+  none: () => none,
+  outsidePress: () => outsidePress,
+  pointer: () => pointer,
+  popupClose: () => popupClose,
+  scrub: () => scrub,
+  siblingOpen: () => siblingOpen,
+  swipe: () => swipe,
+  trackPress: () => trackPress,
+  triggerFocus: () => triggerFocus,
+  triggerHover: () => triggerHover,
+  triggerPress: () => triggerPress,
+  wheel: () => wheel,
+  windowResize: () => windowResize
+});
+var none = "none", triggerPress = "trigger-press", triggerHover = "trigger-hover", triggerFocus = "trigger-focus", outsidePress = "outside-press", itemPress = "item-press", closePress = "close-press", linkPress = "link-press", clearPress = "clear-press", chipRemovePress = "chip-remove-press", trackPress = "track-press", incrementPress = "increment-press", decrementPress = "decrement-press", inputChange = "input-change", inputClear = "input-clear", inputBlur = "input-blur", inputPaste = "input-paste", inputPress = "input-press", focusOut = "focus-out", escapeKey = "escape-key", closeWatcher = "close-watcher", listNavigation = "list-navigation", keyboard = "keyboard", pointer = "pointer", drag = "drag", wheel = "wheel", scrub = "scrub", popupClose = "popup-close", cancelOpen = "cancel-open", siblingOpen = "sibling-open", disabled = "disabled", missing = "missing", initial = "initial", imperativeAction = "imperative-action", swipe = "swipe", windowResize = "window-resize";
+
+// ../../node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
+import * as React9 from "react";
+
+// ../../node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
+import * as ReactDOM from "react-dom";
+
+// ../../node_modules/@base-ui/utils/useOnMount.mjs
+import * as React8 from "react";
+function useOnMount(fn) {
+  React8.useEffect(fn, EMPTY_ARRAY);
+}
+
+// ../../node_modules/@base-ui/utils/useAnimationFrame.mjs
+var EMPTY = null, LAST_RAF = globalThis.requestAnimationFrame, Scheduler = class {
+  /* This implementation uses an array as a backing data-structure for frame callbacks.
+   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+   * be much more efficient if there is a call pattern that alterns as
+   * "request-cancel-request-cancel-…".
+   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = !1;
+  tick = (timestamp) => {
+    this.isScheduled = !1;
+    let currentCallbacks = this.callbacks, currentCallbacksCount = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, currentCallbacksCount > 0)
+      for (let i = 0; i < currentCallbacks.length; i += 1)
+        currentCallbacks[i]?.(timestamp);
+  };
+  request(fn) {
+    let id = this.nextId;
+    this.nextId += 1, this.callbacks.push(fn), this.callbacksCount += 1;
+    let didRAFChange = process.env.NODE_ENV !== "production" && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, !0);
+    return (!this.isScheduled || didRAFChange) && (requestAnimationFrame(this.tick), this.isScheduled = !0), id;
   }
-  return useGlobalId(idOverride, prefix);
+  cancel(id) {
+    let index = id - this.startId;
+    index < 0 || index >= this.callbacks.length || this.callbacks[index] !== null && (this.callbacks[index] = null, this.callbacksCount -= 1);
+  }
+}, scheduler = new Scheduler();
+var AnimationFrame = class _AnimationFrame {
+  static create() {
+    return new _AnimationFrame();
+  }
+  static request(fn) {
+    return scheduler.request(fn);
+  }
+  static cancel(id) {
+    return scheduler.cancel(id);
+  }
+  currentId = EMPTY;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(fn) {
+    this.cancel(), this.currentId = scheduler.request(() => {
+      this.currentId = EMPTY, fn();
+    });
+  }
+  cancel = () => {
+    this.currentId !== EMPTY && (scheduler.cancel(this.currentId), this.currentId = EMPTY);
+  };
+  disposeEffect = () => this.cancel;
+};
+function useAnimationFrame() {
+  let timeout = useRefWithInit(AnimationFrame.create).current;
+  return useOnMount(timeout.disposeEffect), timeout;
 }
 
-// ../../node_modules/@base-ui/react/internals/useBaseUiId.mjs
-function useBaseUiId(idOverride) {
-  return useId(idOverride, "base-ui");
+// ../../node_modules/@base-ui/react/utils/resolveRef.mjs
+function resolveRef(maybeRef) {
+  return maybeRef == null ? maybeRef : "current" in maybeRef ? maybeRef.current : maybeRef;
+}
+
+// ../../node_modules/@base-ui/react/utils/getFiniteAnimations.mjs
+function getFiniteAnimations(element, options) {
+  return element.getAnimations(options).filter((animation) => {
+    let timing = animation.effect?.getTiming();
+    return timing?.duration !== 1 / 0 && timing?.iterations !== 1 / 0;
+  });
+}
+
+// ../../node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
+var pendingCallbacks = null;
+function flushBeforePaint(fn) {
+  if (!pendingCallbacks) {
+    let callbacks = [];
+    pendingCallbacks = callbacks, queueMicrotask(() => {
+      pendingCallbacks = null, ReactDOM.flushSync(() => {
+        for (let callback of callbacks)
+          callback();
+      });
+    });
+  }
+  pendingCallbacks.push(fn);
+}
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = !1, batch = !1) {
+  let frame = useAnimationFrame();
+  return useStableCallback((fnToExecute, signal = null) => {
+    frame.cancel();
+    let element = resolveRef(elementOrRef);
+    if (element == null)
+      return;
+    let resolvedElement = element, done = () => {
+      if (!batch) {
+        ReactDOM.flushSync(fnToExecute);
+        return;
+      }
+      flushBeforePaint(() => {
+        signal?.aborted || fnToExecute();
+      });
+    };
+    if (typeof resolvedElement.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
+      fnToExecute();
+      return;
+    }
+    function exec() {
+      Promise.all(getFiniteAnimations(resolvedElement).map((animation) => animation.finished.then(NOOP))).then(() => {
+        signal?.aborted || done();
+      }, () => {
+        if (signal?.aborted)
+          return;
+        if (getFiniteAnimations(resolvedElement).some((animation) => animation.pending || animation.playState !== "finished")) {
+          exec();
+          return;
+        }
+        done();
+      });
+    }
+    if (waitForStartingStyleRemoved) {
+      let startingStyleAttribute = startingStyle;
+      if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+        frame.request(exec);
+        return;
+      }
+      let attributeObserver = new MutationObserver(() => {
+        resolvedElement.hasAttribute(startingStyleAttribute) || (attributeObserver.disconnect(), exec());
+      });
+      attributeObserver.observe(resolvedElement, {
+        attributes: !0,
+        attributeFilter: [startingStyleAttribute]
+      }), signal?.addEventListener("abort", () => attributeObserver.disconnect(), {
+        once: !0
+      });
+      return;
+    }
+    frame.request(exec);
+  });
+}
+
+// ../../node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
+function useOpenChangeComplete(parameters) {
+  let {
+    enabled = !0,
+    open: open2,
+    ref,
+    batch = !1,
+    onComplete: onCompleteParam
+  } = parameters, onComplete = useStableCallback(onCompleteParam), runOnceAnimationsFinish = useAnimationsFinished(ref, open2, batch);
+  React9.useEffect(() => {
+    if (!enabled)
+      return;
+    let abortController = new AbortController();
+    return runOnceAnimationsFinish(onComplete, abortController.signal), () => {
+      abortController.abort();
+    };
+  }, [enabled, open2, onComplete, runOnceAnimationsFinish]);
+}
+
+// ../../node_modules/@base-ui/utils/inertValue.mjs
+function inertValue(value) {
+  return isReactVersionAtLeast(19) ? value : value ? "true" : void 0;
 }
 
 // ../../node_modules/@base-ui/react/internals/use-button/useButton.mjs
-import * as React16 from "react";
+import * as React13 from "react";
+
+// ../../node_modules/@base-ui/utils/error.mjs
+var error = createLogOnce("error", "Base UI");
+
+// ../../node_modules/@base-ui/utils/useIsoLayoutEffect.mjs
+import * as React10 from "react";
+var noop = () => {
+}, useIsoLayoutEffect = typeof document < "u" ? React10.useLayoutEffect : noop;
 
 // ../../node_modules/@base-ui/react/internals/composite/root/CompositeRootContext.mjs
-import * as React14 from "react";
-var CompositeRootContext = React14.createContext(void 0);
+import * as React11 from "react";
+var CompositeRootContext = React11.createContext(void 0);
 process.env.NODE_ENV !== "production" && (CompositeRootContext.displayName = "CompositeRootContext");
 function useCompositeRootContext(optional = !1) {
-  let context = React14.useContext(CompositeRootContext);
+  let context = React11.useContext(CompositeRootContext);
   if (context === void 0 && !optional)
     throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>." : formatErrorMessage_default(16));
   return context;
 }
 
 // ../../node_modules/@base-ui/react/utils/useFocusableWhenDisabled.mjs
-import * as React15 from "react";
+import * as React12 from "react";
 function useFocusableWhenDisabled(parameters) {
   let {
     focusableWhenDisabled,
@@ -973,7 +859,7 @@ function useFocusableWhenDisabled(parameters) {
     isNativeButton
   } = parameters, isFocusableComposite = composite && focusableWhenDisabled !== !1, isNonFocusableComposite = composite && focusableWhenDisabled === !1;
   return {
-    props: React15.useMemo(() => {
+    props: React12.useMemo(() => {
       let additionalProps = {
         // allow Tabbing away from focusableWhenDisabled elements
         onKeyDown(event) {
@@ -985,6 +871,11 @@ function useFocusableWhenDisabled(parameters) {
   };
 }
 
+// ../../node_modules/@base-ui/utils/owner.mjs
+function ownerDocument(node) {
+  return node?.ownerDocument || document;
+}
+
 // ../../node_modules/@base-ui/react/utils/dispatchClickWithModifiers.mjs
 function dispatchClickWithModifiers(target, sourceEvent, {
   detail = 0,
@@ -1011,7 +902,7 @@ function useButton(parameters = {}) {
     tabIndex = 0,
     native: isNativeButton = !0,
     composite: compositeProp
-  } = parameters, elementRef = React16.useRef(null), compositeRootContext = useCompositeRootContext(!0), isCompositeItem = compositeProp ?? compositeRootContext !== void 0, {
+  } = parameters, elementRef = React13.useRef(null), compositeRootContext = useCompositeRootContext(!0), isCompositeItem = compositeProp ?? compositeRootContext !== void 0, {
     props: focusableWhenDisabledProps
   } = useFocusableWhenDisabled({
     focusableWhenDisabled,
@@ -1020,7 +911,7 @@ function useButton(parameters = {}) {
     tabIndex,
     isNativeButton
   });
-  process.env.NODE_ENV !== "production" && React16.useEffect(() => {
+  process.env.NODE_ENV !== "production" && React13.useEffect(() => {
     if (!elementRef.current)
       return;
     let isButtonTag = isButtonElement(elementRef.current);
@@ -1034,12 +925,12 @@ function useButton(parameters = {}) {
       error(`A component that acts as a button expected a non-<button> because the \`nativeButton\` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as \`role\` or \`aria-disabled\`). Use a non-<button> in the \`render\` prop, or set \`nativeButton\` to \`true\`.${ownerStackMessage}`);
     }
   }, [isNativeButton]);
-  let updateDisabled = React16.useCallback(() => {
+  let updateDisabled = React13.useCallback(() => {
     let element = elementRef.current;
     isButtonElement(element) && isCompositeItem && disabled2 && focusableWhenDisabledProps.disabled === void 0 && element.disabled && (element.disabled = !1);
   }, [disabled2, focusableWhenDisabledProps.disabled, isCompositeItem]);
   useIsoLayoutEffect(updateDisabled, [updateDisabled]);
-  let getButtonProps = React16.useCallback((externalProps = {}) => {
+  let getButtonProps = React13.useCallback((externalProps = {}) => {
     let {
       onClick: externalOnClick,
       onMouseDown: externalOnMouseDown,
@@ -1111,93 +1002,6 @@ function isValidLinkElement(elem) {
   return isHTMLElement(elem) && elem.tagName === "A" && !!elem.href;
 }
 
-// ../../node_modules/@base-ui/react/internals/composite/constants.mjs
-var ACTIVE_COMPOSITE_ITEM = "data-composite-item-active";
-
-// ../../node_modules/@base-ui/react/internals/composite/item/useCompositeItem.mjs
-import * as React18 from "react";
-
-// ../../node_modules/@base-ui/react/internals/composite/list/useCompositeListItem.mjs
-import * as React17 from "react";
-function useCompositeListItem(params = {}) {
-  let {
-    guess,
-    label,
-    metadata,
-    textRef,
-    index: externalIndex
-  } = params, {
-    register,
-    unregister,
-    subscribeMapChange,
-    nextIndexRef
-  } = useCompositeListContext(), indexRef = React17.useRef(-1), [internalIndex, setInternalIndex] = React17.useState(externalIndex == null && guess ? () => {
-    if (indexRef.current === -1) {
-      let newIndex = nextIndexRef.current;
-      nextIndexRef.current += 1, indexRef.current = newIndex;
-    }
-    return indexRef.current;
-  } : -1), index2 = externalIndex ?? internalIndex, componentRef = React17.useRef(null), ref = React17.useCallback((node) => {
-    let previousNode = componentRef.current;
-    previousNode && unregister(previousNode), componentRef.current = node, node && register(node, {
-      metadata: metadata ?? null,
-      index: externalIndex ?? null,
-      label,
-      textRef
-    });
-  }, [externalIndex, register, unregister, metadata, label, textRef]);
-  return useIsoLayoutEffect(() => {
-    if (externalIndex == null)
-      return subscribeMapChange((map) => {
-        let i = componentRef.current ? map.get(componentRef.current)?.index : null;
-        i != null && setInternalIndex(i);
-      });
-  }, [externalIndex, subscribeMapChange]), {
-    ref,
-    index: index2
-  };
-}
-
-// ../../node_modules/@base-ui/react/internals/composite/item/useCompositeItem.mjs
-function useCompositeItem(params = {}) {
-  let {
-    highlightItemOnHover,
-    highlightedIndex,
-    onHighlightedIndexChange
-  } = useCompositeRootContext(), {
-    ref,
-    index: index2
-  } = useCompositeListItem(params), isHighlighted = highlightedIndex === index2, itemRef = React18.useRef(null), mergedRef = useMergedRefs(ref, itemRef);
-  return {
-    compositeProps: {
-      tabIndex: isHighlighted ? 0 : -1,
-      onFocus() {
-        onHighlightedIndexChange(index2);
-      },
-      onMouseMove() {
-        let item = itemRef.current;
-        if (!highlightItemOnHover || !item)
-          return;
-        let disabled2 = item.hasAttribute("disabled") || item.ariaDisabled === "true";
-        !isHighlighted && !disabled2 && item.focus();
-      }
-    },
-    compositeRef: mergedRef,
-    index: index2
-  };
-}
-
-// ../../node_modules/@base-ui/react/tabs/list/TabsListContext.mjs
-import * as React19 from "react";
-var TabsListContext = React19.createContext(void 0);
-process.env.NODE_ENV !== "production" && (TabsListContext.displayName = "TabsListContext");
-function useTabsListContext() {
-  let context = React19.useContext(TabsListContext);
-  if (context === void 0)
-    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TabsListContext is missing. TabsList parts must be placed within <Tabs.List>." : formatErrorMessage_default(65));
-  return context;
-}
-
 // ../../node_modules/@base-ui/utils/platform/parts.mjs
 var parts_exports = {};
 __export(parts_exports, {
@@ -1279,125 +1083,50 @@ var jsdom = /jsdom|happydom/.test(lowerUserAgent);
 
 // ../../node_modules/@base-ui/utils/platform/media-query.mjs
 var media_query_exports = {};
-__export(media_query_exports, {
-  iOS: () => iOS
-});
-var iOS = "@supports (-webkit-touch-callout: none)";
-
-// ../../node_modules/@base-ui/utils/shadowDom.mjs
-function activeElement(doc) {
-  let element = doc.activeElement;
-  for (; element?.shadowRoot?.activeElement != null; )
-    element = element.shadowRoot.activeElement;
-  return element;
-}
-function contains(parent, child) {
-  if (!parent || !child)
-    return !1;
-  let rootNode = child.getRootNode?.();
-  if (parent.contains(child))
-    return !0;
-  if (rootNode && isShadowRoot(rootNode)) {
-    let next = child;
-    for (; next; ) {
-      if (parent === next)
-        return !0;
-      next = next.parentNode || next.host;
-    }
-  }
-  return !1;
-}
-function closest(node, selector) {
-  let current = node;
-  for (; current; ) {
-    if (isElement(current) && current.matches(selector))
-      return current;
-    current = current.assignedSlot ?? current.parentNode ?? (isShadowRoot(current) ? current.host : null);
-  }
-  return null;
-}
-function getTarget(event) {
-  return "composedPath" in event ? event.composedPath()[0] ?? event.target : event.target;
-}
-
-// ../../node_modules/@base-ui/react/floating-ui-react/utils/constants.mjs
-var FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
-var TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
-
-// ../../node_modules/@base-ui/react/internals/TransitionStatusDataAttributes.mjs
-var TransitionStatusDataAttributes_exports = {};
-__export(TransitionStatusDataAttributes_exports, {
-  endingStyle: () => endingStyle,
-  startingStyle: () => startingStyle
-});
-var startingStyle = "data-starting-style", endingStyle = "data-ending-style";
-
-// ../../node_modules/@base-ui/react/internals/stateAttributesMapping.mjs
-var STARTING_HOOK = {
-  [startingStyle]: ""
-}, ENDING_HOOK = {
-  [endingStyle]: ""
-}, transitionStatusMapping = {
-  transitionStatus(value) {
-    return value === "starting" ? STARTING_HOOK : value === "ending" ? ENDING_HOOK : null;
-  }
-};
-
-// ../../node_modules/@base-ui/react/utils/CommonPopupDataAttributes.mjs
-var CommonPopupDataAttributes_exports = {};
-__export(CommonPopupDataAttributes_exports, {
-  align: () => align,
-  anchorHidden: () => anchorHidden,
-  closed: () => closed,
-  endingStyle: () => endingStyle2,
-  open: () => open,
-  side: () => side,
-  startingStyle: () => startingStyle2
-});
-var open = "data-open", closed = "data-closed", startingStyle2 = startingStyle, endingStyle2 = endingStyle, anchorHidden = "data-anchor-hidden", side = "data-side", align = "data-align";
-
-// ../../node_modules/@base-ui/react/utils/CommonTriggerDataAttributes.mjs
-var CommonTriggerDataAttributes_exports = {};
-__export(CommonTriggerDataAttributes_exports, {
-  popupOpen: () => popupOpen,
-  pressed: () => pressed
+__export(media_query_exports, {
+  iOS: () => iOS
 });
-var popupOpen = "data-popup-open", pressed = "data-pressed";
+var iOS = "@supports (-webkit-touch-callout: none)";
 
-// ../../node_modules/@base-ui/react/utils/popupStateMapping.mjs
-var TRIGGER_HOOK = {
-  [popupOpen]: ""
-}, PRESSABLE_TRIGGER_HOOK = {
-  [popupOpen]: "",
-  [pressed]: ""
-}, POPUP_OPEN_HOOK = {
-  [open]: ""
-}, POPUP_CLOSED_HOOK = {
-  [closed]: ""
-}, ANCHOR_HIDDEN_HOOK = {
-  [anchorHidden]: ""
-}, triggerOpenStateMapping = {
-  open(value) {
-    return value ? TRIGGER_HOOK : null;
-  }
-}, pressableTriggerOpenStateMapping = {
-  open(value) {
-    return value ? PRESSABLE_TRIGGER_HOOK : null;
+// ../../node_modules/@base-ui/utils/shadowDom.mjs
+function activeElement(doc) {
+  let element = doc.activeElement;
+  for (; element?.shadowRoot?.activeElement != null; )
+    element = element.shadowRoot.activeElement;
+  return element;
+}
+function contains(parent, child) {
+  if (!parent || !child)
+    return !1;
+  let rootNode = child.getRootNode?.();
+  if (parent.contains(child))
+    return !0;
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    for (; next; ) {
+      if (parent === next)
+        return !0;
+      next = next.parentNode || next.host;
+    }
   }
-}, popupStateMapping = {
-  open(value) {
-    return value ? POPUP_OPEN_HOOK : POPUP_CLOSED_HOOK;
-  },
-  anchorHidden(value) {
-    return value ? ANCHOR_HIDDEN_HOOK : null;
+  return !1;
+}
+function closest(node, selector) {
+  let current = node;
+  for (; current; ) {
+    if (isElement(current) && current.matches(selector))
+      return current;
+    current = current.assignedSlot ?? current.parentNode ?? (isShadowRoot(current) ? current.host : null);
   }
-}, popupTransitionStateMapping = {
-  ...popupStateMapping,
-  ...transitionStatusMapping
-};
+  return null;
+}
+function getTarget(event) {
+  return "composedPath" in event ? event.composedPath()[0] ?? event.target : event.target;
+}
 
-// ../../node_modules/@base-ui/react/tooltip/trigger/TooltipTriggerDataAttributes.mjs
-var popupOpen2 = CommonTriggerDataAttributes_exports.popupOpen, triggerDisabled = "data-trigger-disabled";
+// ../../node_modules/@base-ui/react/floating-ui-react/utils/constants.mjs
+var FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
+var TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
 
 // ../../node_modules/@base-ui/react/floating-ui-react/utils/element.mjs
 function isTargetInsideEnabledTrigger(target, triggerElements) {
@@ -1588,8 +1317,8 @@ function rectToClientRect(rect) {
 }
 
 // ../../node_modules/@base-ui/react/floating-ui-react/utils/composite.mjs
-function isIndexOutOfListBounds(list, index2) {
-  return index2 < 0 || index2 >= list.length;
+function isIndexOutOfListBounds(list, index) {
+  return index < 0 || index >= list.length;
 }
 function getMinListIndex(listRef, disabledIndices) {
   return findNonDisabledListIndex(listRef.current, {
@@ -1609,16 +1338,16 @@ function findNonDisabledListIndex(list, {
   disabledIndices,
   amount = 1
 } = {}) {
-  let index2 = startingIndex;
+  let index = startingIndex;
   do
-    index2 += decrement ? -amount : amount;
-  while (index2 >= 0 && index2 <= list.length - 1 && isListIndexDisabled(list, index2, disabledIndices));
-  return index2;
+    index += decrement ? -amount : amount;
+  while (index >= 0 && index <= list.length - 1 && isListIndexDisabled(list, index, disabledIndices));
+  return index;
 }
-function isListIndexDisabled(list, index2, disabledIndices) {
-  if (typeof disabledIndices == "function" ? disabledIndices(index2) : disabledIndices?.includes(index2) ?? !1)
+function isListIndexDisabled(list, index, disabledIndices) {
+  if (typeof disabledIndices == "function" ? disabledIndices(index) : disabledIndices?.includes(index) ?? !1)
     return !0;
-  let element = list[index2];
+  let element = list[index];
   return element ? !isElementVisible(element) || element.matches(":disabled") ? !0 : !disabledIndices && (element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") : !1;
 }
 function isHiddenByStyles(styles) {
@@ -1726,662 +1455,50 @@ function tabbable(container) {
   let candidates = focusable(container);
   return candidates.filter((element) => getTabIndex(element) >= 0 && isTabbableRadio(element, candidates));
 }
-function getTabbableIn(container, dir) {
-  let list = tabbable(container), len = list.length;
-  if (len === 0)
-    return;
-  let active = activeElement(ownerDocument(container)), index2 = list.indexOf(active), nextIndex = index2 === -1 ? dir === 1 ? 0 : len - 1 : index2 + dir;
-  return list[nextIndex];
-}
-function getNextTabbable(referenceElement) {
-  return getTabbableIn(ownerDocument(referenceElement).body, 1) || referenceElement;
-}
-function getPreviousTabbable(referenceElement) {
-  return getTabbableIn(ownerDocument(referenceElement).body, -1) || referenceElement;
-}
-function getTabbableNearElement(referenceElement, direction, exclude) {
-  if (!referenceElement)
-    return null;
-  let list = [];
-  appendCandidates(ownerDocument(referenceElement).body, list);
-  let index2 = list.indexOf(referenceElement);
-  if (index2 === -1)
-    return null;
-  let candidates = list.filter(isFocusableElement);
-  for (let offset = 1; offset < list.length; offset += 1) {
-    let element = list[(index2 + direction * offset + list.length) % list.length];
-    if (!contains(exclude, element) && isTabbable(element) && isTabbableRadio(element, candidates))
-      return element;
-  }
-  return list[index2];
-}
-function isOutsideEvent(event, container) {
-  let containerElement = container || event.currentTarget, relatedTarget = event.relatedTarget;
-  return !relatedTarget || !contains(containerElement, relatedTarget);
-}
-function disableFocusInside(container) {
-  tabbable(container).forEach((element) => {
-    element.dataset.tabindex = element.getAttribute("tabindex") || "", element.setAttribute("tabindex", "-1");
-  });
-}
-function enableFocusInside(container) {
-  let elements = [];
-  appendMatchingElements(container, "[data-tabindex]", elements), elements.forEach((element) => {
-    let tabindex = element.dataset.tabindex;
-    delete element.dataset.tabindex, tabindex ? element.setAttribute("tabindex", tabindex) : element.removeAttribute("tabindex");
-  });
-}
-
-// ../../node_modules/@base-ui/react/tabs/tab/TabsTab.mjs
-var TabsTab = React20.forwardRef(function(componentProps, forwardedRef) {
-  let {
-    className,
-    disabled: disabled2 = !1,
-    render,
-    value,
-    id: idProp,
-    nativeButton = !0,
-    style,
-    ...elementProps
-  } = componentProps, {
-    value: activeTabValue,
-    getTabPanelIdByValue,
-    onValueChange,
-    orientation,
-    tabActivationDirection
-  } = useTabsRootContext(), {
-    activateOnFocus,
-    registerTabResizeObserverElement,
-    tabsListElement
-  } = useTabsListContext(), {
-    highlightedIndex,
-    onHighlightedIndexChange
-  } = useCompositeRootContext(), id = useBaseUiId(idProp), tabMetadata = React20.useMemo(() => ({
-    disabled: disabled2,
-    id,
-    value
-  }), [disabled2, id, value]), {
-    compositeProps,
-    compositeRef,
-    index: index2
-    // hook is used instead of the CompositeItem component
-    // because the index is needed for Tab internals
-  } = useCompositeItem({
-    metadata: tabMetadata
-  }), active = value === activeTabValue, isNavigatingRef = React20.useRef(!1), unobserveTabElementRef = React20.useRef(null), observeTabElement = useStableCallback((element2) => {
-    unobserveTabElementRef.current?.(), unobserveTabElementRef.current = element2 ? registerTabResizeObserverElement(element2) : null;
-  });
-  useIsoLayoutEffect(() => {
-    if (isNavigatingRef.current) {
-      isNavigatingRef.current = !1;
-      return;
-    }
-    if (!(active && index2 > -1 && highlightedIndex !== index2))
-      return;
-    let listElement = tabsListElement;
-    if (listElement != null) {
-      let activeEl = activeElement(ownerDocument(listElement));
-      if (activeEl && contains(listElement, activeEl))
-        return;
-    }
-    disabled2 || onHighlightedIndexChange(index2);
-  }, [active, index2, highlightedIndex, onHighlightedIndexChange, disabled2, tabsListElement]);
-  let {
-    getButtonProps,
-    buttonRef
-  } = useButton({
-    disabled: disabled2,
-    native: nativeButton,
-    focusableWhenDisabled: !0
-  }), tabPanelId = getTabPanelIdByValue(value), isPressingRef = React20.useRef(!1), isMainButtonRef = React20.useRef(!1);
-  function activate(event) {
-    onValueChange(value, createChangeEventDetails(reason_parts_exports.none, event.nativeEvent, void 0, {
-      activationDirection: "none"
-    }));
-  }
-  function onClick(event) {
-    active || disabled2 || activate(event);
-  }
-  function onFocus(event) {
-    active || disabled2 || activateOnFocus && (!isPressingRef.current || // keyboard or touch focus
-    isMainButtonRef.current) && activate(event);
-  }
-  function onPointerDown(event) {
-    if (active || disabled2)
-      return;
-    isPressingRef.current = !0, isMainButtonRef.current = event.button === 0;
-    let doc = ownerDocument(event.currentTarget);
-    function handlePointerEnd() {
-      isPressingRef.current = !1, isMainButtonRef.current = !1, doc.removeEventListener("pointerup", handlePointerEnd), doc.removeEventListener("pointercancel", handlePointerEnd);
-    }
-    doc.addEventListener("pointerup", handlePointerEnd), doc.addEventListener("pointercancel", handlePointerEnd);
-  }
-  return useRenderElement("button", componentProps, {
-    state: {
-      disabled: disabled2,
-      active,
-      orientation,
-      tabActivationDirection
-    },
-    ref: [forwardedRef, buttonRef, compositeRef, observeTabElement],
-    props: [compositeProps, {
-      role: "tab",
-      "aria-controls": tabPanelId,
-      "aria-selected": active,
-      id,
-      onClick,
-      onFocus,
-      onPointerDown,
-      [ACTIVE_COMPOSITE_ITEM]: active ? "" : void 0,
-      onKeyDownCapture() {
-        isNavigatingRef.current = !0;
-      }
-    }, elementProps, getButtonProps],
-    stateAttributesMapping: tabsStateAttributesMapping
-  });
-});
-process.env.NODE_ENV !== "production" && (TabsTab.displayName = "TabsTab");
-
-// ../../node_modules/@base-ui/react/tabs/indicator/TabsIndicator.mjs
-import * as React24 from "react";
-
-// ../../node_modules/@base-ui/react/internals/PrehydrationScript.mjs
-import "react";
-
-// ../../node_modules/@base-ui/utils/hydration.mjs
-import * as React21 from "react";
-import { useSyncExternalStore } from "use-sync-external-store/shim";
-var emptySubscribe = () => () => {
-}, getTrue = () => !0, getFalse = () => !1;
-function useIsHydratedModern() {
-  return useSyncExternalStore(emptySubscribe, getTrue, getFalse);
-}
-function useIsHydratedLegacy() {
-  let [hydrated, setHydrated] = React21.useState(!1);
-  return React21.useEffect(() => {
-    setHydrated(!0);
-  }, []), hydrated;
-}
-var useIsHydrated = isReactVersionAtLeast(18) ? useIsHydratedModern : useIsHydratedLegacy;
-function useIsHydrating() {
-  return !useIsHydrated();
-}
-
-// ../../node_modules/@base-ui/react/internals/csp-context/CSPContext.mjs
-import * as React22 from "react";
-var CSPContext = React22.createContext(void 0);
-process.env.NODE_ENV !== "production" && (CSPContext.displayName = "CSPContext");
-var DEFAULT_CSP_CONTEXT_VALUE = {
-  disableStyleElements: !1
-};
-function useCSPContext() {
-  return React22.useContext(CSPContext) ?? DEFAULT_CSP_CONTEXT_VALUE;
-}
-
-// ../../node_modules/@base-ui/react/internals/PrehydrationScript.mjs
-import { jsx as _jsx3 } from "react/jsx-runtime";
-function PrehydrationScript(props) {
-  let {
-    script: script2
-  } = props, {
-    nonce
-  } = useCSPContext();
-  return useIsHydrating() ? _jsx3("script", {
-    nonce,
-    dangerouslySetInnerHTML: {
-      __html: script2
-    },
-    suppressHydrationWarning: !0
-  }) : null;
-}
-
-// ../../node_modules/@base-ui/react/utils/getCssDimensions.mjs
-function getCssDimensions(element) {
-  let css = getComputedStyle2(element), width = parseFloat(css.width) || 0, height = parseFloat(css.height) || 0, hasOffset = isHTMLElement(element), offsetWidth = hasOffset ? element.offsetWidth : width, offsetHeight = hasOffset ? element.offsetHeight : height;
-  return (round(width) !== offsetWidth || round(height) !== offsetHeight) && (width = offsetWidth, height = offsetHeight), {
-    width,
-    height
-  };
-}
-
-// ../../node_modules/@base-ui/react/utils/getElementTransform.mjs
-function getElementTransform(element, computedStyle) {
-  let transform = (computedStyle ?? getWindow(element).getComputedStyle(element)).transform, translateX = 0, translateY = 0, scale = 1;
-  if (transform && transform !== "none") {
-    let matrix = transform.match(/matrix(?:3d)?\(([^)]+)\)/);
-    if (matrix) {
-      let values = matrix[1].split(", ").map(parseFloat);
-      values.length === 6 ? (translateX = values[4], translateY = values[5], scale = Math.sqrt(values[0] * values[0] + values[1] * values[1])) : values.length === 16 && (translateX = values[12], translateY = values[13], scale = values[0]);
-    }
-  }
-  return {
-    x: translateX,
-    y: translateY,
-    scale
-  };
-}
-
-// ../../node_modules/@base-ui/react/tabs/indicator/TabsIndicatorCssVars.mjs
-var activeTabLeft = "--active-tab-left", activeTabRight = "--active-tab-right", activeTabTop = "--active-tab-top", activeTabBottom = "--active-tab-bottom", activeTabWidth = "--active-tab-width", activeTabHeight = "--active-tab-height";
-
-// ../../node_modules/@base-ui/react/tabs/indicator/TabsIndicator.mjs
-import { jsx as _jsx4, jsxs as _jsxs } from "react/jsx-runtime";
-var _PrehydrationScript, stateAttributesMapping = {
-  ...tabsStateAttributesMapping,
-  activeTabPosition: () => null,
-  activeTabSize: () => null
-}, MAX_LAYOUT_ROUNDING_ERROR = 2, TabsIndicator = React24.forwardRef(function(componentProps, forwardedRef) {
-  let {
-    className,
-    render,
-    renderBeforeHydration = !1,
-    style: styleProp,
-    ...elementProps
-  } = componentProps, {
-    getTabElementBySelectedValue,
-    orientation,
-    tabActivationDirection,
-    value
-  } = useTabsRootContext(), {
-    tabsListElement,
-    registerIndicatorUpdateListener
-  } = useTabsListContext(), rerender = useForcedRerendering();
-  React24.useEffect(() => registerIndicatorUpdateListener(rerender), [registerIndicatorUpdateListener, rerender]);
-  let left = 0, right = 0, top = 0, bottom = 0, width = 0, height = 0, isTabSelected = !1;
-  if (value != null && tabsListElement != null) {
-    let activeTab = getTabElementBySelectedValue(value);
-    if (activeTab != null) {
-      isTabSelected = !0;
-      let {
-        width: computedWidth,
-        height: computedHeight
-      } = getCssDimensions(activeTab), {
-        width: tabListWidth,
-        height: tabListHeight
-      } = getCssDimensions(tabsListElement), tabRect = activeTab.getBoundingClientRect(), tabsListRect = tabsListElement.getBoundingClientRect(), scaleX = tabListWidth > 0 ? tabsListRect.width / tabListWidth : 1, scaleY = tabListHeight > 0 ? tabsListRect.height / tabListHeight : 1, layoutOffset = getLayoutOffset(activeTab, tabsListElement);
-      left = layoutOffset.left, top = layoutOffset.top;
-      let rectLeft = (tabRect.left - tabsListRect.left) / scaleX + tabsListElement.scrollLeft - tabsListElement.clientLeft, rectTop = (tabRect.top - tabsListRect.top) / scaleY + tabsListElement.scrollTop - tabsListElement.clientTop, tabTranslation = getActiveTabTranslation(activeTab);
-      Math.abs(rectLeft - tabTranslation.x - left) <= MAX_LAYOUT_ROUNDING_ERROR && Math.abs(rectTop - tabTranslation.y - top) <= MAX_LAYOUT_ROUNDING_ERROR && (left = rectLeft, top = rectTop), width = computedWidth, height = computedHeight, right = tabsListElement.scrollWidth - left - width, bottom = tabsListElement.scrollHeight - top - height;
-    }
-  }
-  let activeTabPosition = isTabSelected ? {
-    left,
-    right,
-    top,
-    bottom
-  } : null, activeTabSize = isTabSelected ? {
-    width,
-    height
-  } : null, style = isTabSelected ? {
-    [activeTabLeft]: `${left}px`,
-    [activeTabRight]: `${right}px`,
-    [activeTabTop]: `${top}px`,
-    [activeTabBottom]: `${bottom}px`,
-    [activeTabWidth]: `${width}px`,
-    [activeTabHeight]: `${height}px`
-  } : void 0, displayIndicator = isTabSelected && width > 0 && height > 0, element = useRenderElement("span", componentProps, {
-    state: {
-      orientation,
-      activeTabPosition,
-      activeTabSize,
-      tabActivationDirection
-    },
-    ref: forwardedRef,
-    props: [{
-      role: "presentation",
-      style,
-      hidden: !displayIndicator
-      // do not display the indicator before the layout is settled
-    }, elementProps, {
-      suppressHydrationWarning: !0
-    }],
-    stateAttributesMapping
-  });
-  return value == null ? null : _jsxs(React24.Fragment, {
-    children: [element, renderBeforeHydration && (_PrehydrationScript || (_PrehydrationScript = _jsx4(PrehydrationScript, {
-      script: ""
-    })))]
-  });
-});
-process.env.NODE_ENV !== "production" && (TabsIndicator.displayName = "TabsIndicator");
-function getLayoutOffset(element, ancestor) {
-  let elementOffset = getCumulativeOffset(element), ancestorOffset = getCumulativeOffset(ancestor), left = elementOffset.left - ancestorOffset.left - ancestor.clientLeft, top = elementOffset.top - ancestorOffset.top - ancestor.clientTop, node = getParentNode(element);
-  for (; isHTMLElement(node) && node !== ancestor && !isLastTraversableNode(node); )
-    left -= node.scrollLeft, top -= node.scrollTop, node = getParentNode(node);
-  return {
-    left,
-    top
-  };
-}
-function getCumulativeOffset(element) {
-  let left = 0, top = 0, currentElement = element;
-  for (; currentElement != null; ) {
-    left += currentElement.offsetLeft, top += currentElement.offsetTop;
-    let offsetParent = currentElement.offsetParent;
-    offsetParent != null && (left += offsetParent.clientLeft, top += offsetParent.clientTop), currentElement = offsetParent;
-  }
-  return {
-    left,
-    top
-  };
-}
-function getActiveTabTranslation(element) {
-  let computedStyle = getWindow(element).getComputedStyle(element), {
-    x,
-    y
-  } = getElementTransform(element, computedStyle), translateX = x, translateY = y, {
-    translate
-  } = computedStyle;
-  if (translate && translate !== "none") {
-    let parts = translate.split(" ");
-    translateX += resolveTranslateLength(parts[0], element.offsetWidth), translateY += resolveTranslateLength(parts[1], element.offsetHeight);
-  }
-  return {
-    x: translateX,
-    y: translateY
-  };
-}
-function resolveTranslateLength(value, referenceSize) {
-  if (!value)
-    return 0;
-  let numeric = parseFloat(value);
-  return Number.isFinite(numeric) ? value.endsWith("%") ? numeric / 100 * referenceSize : numeric : 0;
-}
-
-// ../../node_modules/@base-ui/react/tabs/panel/TabsPanel.mjs
-import * as React28 from "react";
-
-// ../../node_modules/@base-ui/utils/inertValue.mjs
-function inertValue(value) {
-  return isReactVersionAtLeast(19) ? value : value ? "true" : void 0;
-}
-
-// ../../node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
-import * as React26 from "react";
-
-// ../../node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
-import * as ReactDOM from "react-dom";
-
-// ../../node_modules/@base-ui/utils/useOnMount.mjs
-import * as React25 from "react";
-function useOnMount(fn) {
-  React25.useEffect(fn, EMPTY_ARRAY);
-}
-
-// ../../node_modules/@base-ui/utils/useAnimationFrame.mjs
-var EMPTY = null, LAST_RAF = globalThis.requestAnimationFrame, Scheduler = class {
-  /* This implementation uses an array as a backing data-structure for frame callbacks.
-   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
-   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
-   * be much more efficient if there is a call pattern that alterns as
-   * "request-cancel-request-cancel-…".
-   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
-   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
-  callbacks = [];
-  callbacksCount = 0;
-  nextId = 1;
-  startId = 1;
-  isScheduled = !1;
-  tick = (timestamp) => {
-    this.isScheduled = !1;
-    let currentCallbacks = this.callbacks, currentCallbacksCount = this.callbacksCount;
-    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, currentCallbacksCount > 0)
-      for (let i = 0; i < currentCallbacks.length; i += 1)
-        currentCallbacks[i]?.(timestamp);
-  };
-  request(fn) {
-    let id = this.nextId;
-    this.nextId += 1, this.callbacks.push(fn), this.callbacksCount += 1;
-    let didRAFChange = process.env.NODE_ENV !== "production" && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, !0);
-    return (!this.isScheduled || didRAFChange) && (requestAnimationFrame(this.tick), this.isScheduled = !0), id;
-  }
-  cancel(id) {
-    let index2 = id - this.startId;
-    index2 < 0 || index2 >= this.callbacks.length || this.callbacks[index2] !== null && (this.callbacks[index2] = null, this.callbacksCount -= 1);
-  }
-}, scheduler = new Scheduler();
-var AnimationFrame = class _AnimationFrame {
-  static create() {
-    return new _AnimationFrame();
-  }
-  static request(fn) {
-    return scheduler.request(fn);
-  }
-  static cancel(id) {
-    return scheduler.cancel(id);
-  }
-  currentId = EMPTY;
-  /**
-   * Executes `fn` after `delay`, clearing any previously scheduled call.
-   */
-  request(fn) {
-    this.cancel(), this.currentId = scheduler.request(() => {
-      this.currentId = EMPTY, fn();
-    });
-  }
-  cancel = () => {
-    this.currentId !== EMPTY && (scheduler.cancel(this.currentId), this.currentId = EMPTY);
-  };
-  disposeEffect = () => this.cancel;
-};
-function useAnimationFrame() {
-  let timeout = useRefWithInit(AnimationFrame.create).current;
-  return useOnMount(timeout.disposeEffect), timeout;
+function getTabbableIn(container, dir) {
+  let list = tabbable(container), len = list.length;
+  if (len === 0)
+    return;
+  let active = activeElement(ownerDocument(container)), index = list.indexOf(active), nextIndex = index === -1 ? dir === 1 ? 0 : len - 1 : index + dir;
+  return list[nextIndex];
 }
-
-// ../../node_modules/@base-ui/react/utils/resolveRef.mjs
-function resolveRef(maybeRef) {
-  return maybeRef == null ? maybeRef : "current" in maybeRef ? maybeRef.current : maybeRef;
+function getNextTabbable(referenceElement) {
+  return getTabbableIn(ownerDocument(referenceElement).body, 1) || referenceElement;
 }
-
-// ../../node_modules/@base-ui/react/utils/getFiniteAnimations.mjs
-function getFiniteAnimations(element, options) {
-  return element.getAnimations(options).filter((animation) => {
-    let timing = animation.effect?.getTiming();
-    return timing?.duration !== 1 / 0 && timing?.iterations !== 1 / 0;
-  });
+function getPreviousTabbable(referenceElement) {
+  return getTabbableIn(ownerDocument(referenceElement).body, -1) || referenceElement;
 }
-
-// ../../node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
-var pendingCallbacks = null;
-function flushBeforePaint(fn) {
-  if (!pendingCallbacks) {
-    let callbacks = [];
-    pendingCallbacks = callbacks, queueMicrotask(() => {
-      pendingCallbacks = null, ReactDOM.flushSync(() => {
-        for (let callback of callbacks)
-          callback();
-      });
-    });
+function getTabbableNearElement(referenceElement, direction, exclude) {
+  if (!referenceElement)
+    return null;
+  let list = [];
+  appendCandidates(ownerDocument(referenceElement).body, list);
+  let index = list.indexOf(referenceElement);
+  if (index === -1)
+    return null;
+  let candidates = list.filter(isFocusableElement);
+  for (let offset = 1; offset < list.length; offset += 1) {
+    let element = list[(index + direction * offset + list.length) % list.length];
+    if (!contains(exclude, element) && isTabbable(element) && isTabbableRadio(element, candidates))
+      return element;
   }
-  pendingCallbacks.push(fn);
-}
-function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = !1, batch = !1) {
-  let frame = useAnimationFrame();
-  return useStableCallback((fnToExecute, signal = null) => {
-    frame.cancel();
-    let element = resolveRef(elementOrRef);
-    if (element == null)
-      return;
-    let resolvedElement = element, done = () => {
-      if (!batch) {
-        ReactDOM.flushSync(fnToExecute);
-        return;
-      }
-      flushBeforePaint(() => {
-        signal?.aborted || fnToExecute();
-      });
-    };
-    if (typeof resolvedElement.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
-      fnToExecute();
-      return;
-    }
-    function exec() {
-      Promise.all(getFiniteAnimations(resolvedElement).map((animation) => animation.finished.then(NOOP))).then(() => {
-        signal?.aborted || done();
-      }, () => {
-        if (signal?.aborted)
-          return;
-        if (getFiniteAnimations(resolvedElement).some((animation) => animation.pending || animation.playState !== "finished")) {
-          exec();
-          return;
-        }
-        done();
-      });
-    }
-    if (waitForStartingStyleRemoved) {
-      let startingStyleAttribute = startingStyle;
-      if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
-        frame.request(exec);
-        return;
-      }
-      let attributeObserver = new MutationObserver(() => {
-        resolvedElement.hasAttribute(startingStyleAttribute) || (attributeObserver.disconnect(), exec());
-      });
-      attributeObserver.observe(resolvedElement, {
-        attributes: !0,
-        attributeFilter: [startingStyleAttribute]
-      }), signal?.addEventListener("abort", () => attributeObserver.disconnect(), {
-        once: !0
-      });
-      return;
-    }
-    frame.request(exec);
-  });
+  return list[index];
 }
-
-// ../../node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
-function useOpenChangeComplete(parameters) {
-  let {
-    enabled = !0,
-    open: open2,
-    ref,
-    batch = !1,
-    onComplete: onCompleteParam
-  } = parameters, onComplete = useStableCallback(onCompleteParam), runOnceAnimationsFinish = useAnimationsFinished(ref, open2, batch);
-  React26.useEffect(() => {
-    if (!enabled)
-      return;
-    let abortController = new AbortController();
-    return runOnceAnimationsFinish(onComplete, abortController.signal), () => {
-      abortController.abort();
-    };
-  }, [enabled, open2, onComplete, runOnceAnimationsFinish]);
+function isOutsideEvent(event, container) {
+  let containerElement = container || event.currentTarget, relatedTarget = event.relatedTarget;
+  return !relatedTarget || !contains(containerElement, relatedTarget);
 }
-
-// ../../node_modules/@base-ui/react/internals/useTransitionStatus.mjs
-import * as React27 from "react";
-function useTransitionStatus(open2, enableIdleState = !1, deferEndingState = !1, animateInitialOpen = !1) {
-  let [transitionStatus, setTransitionStatus] = React27.useState(open2 && enableIdleState ? "idle" : void 0), [mounted, setMounted] = React27.useState(open2 && !animateInitialOpen);
-  return open2 && !mounted && (setMounted(!0), setTransitionStatus("starting")), !open2 && mounted && transitionStatus !== "ending" && !deferEndingState && setTransitionStatus("ending"), !open2 && !mounted && transitionStatus === "ending" && setTransitionStatus(void 0), useIsoLayoutEffect(() => {
-    if (!open2 && mounted && transitionStatus !== "ending" && deferEndingState) {
-      let frame = AnimationFrame.request(() => {
-        setTransitionStatus("ending");
-      });
-      return () => {
-        AnimationFrame.cancel(frame);
-      };
-    }
-  }, [open2, mounted, transitionStatus, deferEndingState]), useIsoLayoutEffect(() => {
-    if (!open2 || enableIdleState || transitionStatus === void 0)
-      return;
-    let frame = AnimationFrame.request(() => {
-      setTransitionStatus(void 0);
-    });
-    return () => {
-      AnimationFrame.cancel(frame);
-    };
-  }, [enableIdleState, open2, transitionStatus]), useIsoLayoutEffect(() => {
-    if (!open2 || !enableIdleState)
-      return;
-    open2 && mounted && transitionStatus !== "idle" && setTransitionStatus("starting");
-    let frame = AnimationFrame.request(() => {
-      setTransitionStatus("idle");
-    });
-    return () => {
-      AnimationFrame.cancel(frame);
-    };
-  }, [enableIdleState, open2, mounted, transitionStatus]), {
-    mounted,
-    setMounted,
-    transitionStatus
-  };
+function disableFocusInside(container) {
+  tabbable(container).forEach((element) => {
+    element.dataset.tabindex = element.getAttribute("tabindex") || "", element.setAttribute("tabindex", "-1");
+  });
 }
-
-// ../../node_modules/@base-ui/react/tabs/panel/TabsPanelDataAttributes.mjs
-var index = "data-index";
-var startingStyle3 = TransitionStatusDataAttributes_exports.startingStyle, endingStyle3 = TransitionStatusDataAttributes_exports.endingStyle;
-
-// ../../node_modules/@base-ui/react/tabs/panel/TabsPanel.mjs
-var stateAttributesMapping2 = {
-  ...tabsStateAttributesMapping,
-  ...transitionStatusMapping
-}, TabsPanel = React28.forwardRef(function(componentProps, forwardedRef) {
-  let {
-    className,
-    value,
-    render,
-    keepMounted = !1,
-    style,
-    ...elementProps
-  } = componentProps, {
-    value: selectedValue,
-    getTabIdByPanelValue,
-    orientation,
-    tabActivationDirection,
-    registerMountedTabPanel
-  } = useTabsRootContext(), id = useBaseUiId(), {
-    ref: listItemRef,
-    index: index2
-  } = useCompositeListItem(), open2 = value === selectedValue, {
-    mounted,
-    transitionStatus,
-    setMounted
-  } = useTransitionStatus(open2), hidden = !mounted, correspondingTabId = getTabIdByPanelValue(value), state = {
-    hidden,
-    orientation,
-    tabActivationDirection,
-    transitionStatus
-  }, panelRef = React28.useRef(null), element = useRenderElement("div", componentProps, {
-    state,
-    ref: [forwardedRef, listItemRef, panelRef],
-    props: [{
-      "aria-labelledby": correspondingTabId,
-      hidden,
-      id,
-      role: "tabpanel",
-      tabIndex: open2 ? 0 : -1,
-      inert: inertValue(!open2),
-      // Computed key: a plain literal key fails the DOM-props excess property check.
-      [index]: index2
-    }, elementProps],
-    stateAttributesMapping: stateAttributesMapping2
+function enableFocusInside(container) {
+  let elements = [];
+  appendMatchingElements(container, "[data-tabindex]", elements), elements.forEach((element) => {
+    let tabindex = element.dataset.tabindex;
+    delete element.dataset.tabindex, tabindex ? element.setAttribute("tabindex", tabindex) : element.removeAttribute("tabindex");
   });
-  return useOpenChangeComplete({
-    open: open2,
-    ref: panelRef,
-    onComplete() {
-      open2 || setMounted(!1);
-    }
-  }), useIsoLayoutEffect(() => {
-    if (!(id == null || hidden && !keepMounted))
-      return registerMountedTabPanel(value, id);
-  }, [hidden, keepMounted, value, id, registerMountedTabPanel]), keepMounted || mounted ? element : null;
-});
-process.env.NODE_ENV !== "production" && (TabsPanel.displayName = "TabsPanel");
-
-// ../../node_modules/@base-ui/react/tabs/list/TabsList.mjs
-import * as React32 from "react";
-
-// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRoot.mjs
-import * as React31 from "react";
-
-// ../../node_modules/@base-ui/react/internals/composite/root/useCompositeRoot.mjs
-import * as React29 from "react";
-
-// ../../node_modules/@base-ui/utils/isElementDisabled.mjs
-function isElementDisabled(element) {
-  return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
 }
 
 // ../../node_modules/@base-ui/react/internals/composite/composite.mjs
@@ -2431,275 +1548,70 @@ function getStyles(element) {
   };
 }
 
-// ../../node_modules/@base-ui/react/internals/composite/root/useCompositeRoot.mjs
-function useCompositeRoot(params) {
-  let {
-    loopFocus = !0,
-    orientation = "both",
-    grid,
-    onLoop,
-    direction,
-    highlightedIndex: externalHighlightedIndex,
-    onHighlightedIndexChange: externalSetHighlightedIndex,
-    rootRef: externalRef,
-    enableHomeAndEndKeys = !1,
-    stopEventPropagation,
-    disabledIndices,
-    modifierKeys = EMPTY_ARRAY
-  } = params, [internalHighlightedIndex, internalSetHighlightedIndex] = React29.useState(0), isGrid = grid != null, rootRef = React29.useRef(null), mergedRef = useMergedRefs(rootRef, externalRef), elementsRef = React29.useRef([]), hasSetDefaultIndexRef = React29.useRef(!1), highlightedElementRef = React29.useRef(null), highlightedIndex = externalHighlightedIndex ?? internalHighlightedIndex, onHighlightedIndexChange = useStableCallback((index2, shouldScrollIntoView = !1) => {
-    if (highlightedElementRef.current = elementsRef.current[index2] ?? null, (externalSetHighlightedIndex ?? internalSetHighlightedIndex)(index2), shouldScrollIntoView) {
-      let newActiveItem = elementsRef.current[index2];
-      scrollIntoViewIfNeeded(rootRef.current, newActiveItem, direction, orientation);
-    }
-  }), onMapChange = useStableCallback((map) => {
-    if (map.size === 0)
-      return;
-    if (hasSetDefaultIndexRef.current) {
-      let elements = elementsRef.current, nextIndex = elements.indexOf(highlightedElementRef.current);
-      if (nextIndex === -1) {
-        let replacement = elements[highlightedIndex];
-        !replacement || isListIndexDisabled(elements, highlightedIndex, disabledIndices) ? onHighlightedIndexChange(getFallbackIndex(elements, disabledIndices)) : highlightedElementRef.current = replacement;
-      } else nextIndex !== highlightedIndex && onHighlightedIndexChange(nextIndex);
-      return;
-    }
-    hasSetDefaultIndexRef.current = !0;
-    let sortedElements = Array.from(map.keys()), activeItem = sortedElements.find((compositeElement) => compositeElement?.hasAttribute(ACTIVE_COMPOSITE_ITEM)) ?? null, activeIndex = activeItem ? map.get(activeItem)?.index ?? -1 : -1;
-    if (activeIndex !== -1)
-      onHighlightedIndexChange(activeIndex);
-    else if (isListIndexDisabled(sortedElements, highlightedIndex, disabledIndices)) {
-      let firstEnabledIndex = findNonDisabledListIndex(sortedElements, {
-        disabledIndices
+// ../../node_modules/@base-ui/react/internals/direction-context/DirectionContext.mjs
+import * as React14 from "react";
+var DirectionContext = React14.createContext(void 0);
+process.env.NODE_ENV !== "production" && (DirectionContext.displayName = "DirectionContext");
+function useDirection() {
+  return React14.useContext(DirectionContext)?.direction ?? "ltr";
+}
+
+// ../../node_modules/@base-ui/react/internals/useTransitionStatus.mjs
+import * as React15 from "react";
+function useTransitionStatus(open2, enableIdleState = !1, deferEndingState = !1, animateInitialOpen = !1) {
+  let [transitionStatus, setTransitionStatus] = React15.useState(open2 && enableIdleState ? "idle" : void 0), [mounted, setMounted] = React15.useState(open2 && !animateInitialOpen);
+  return open2 && !mounted && (setMounted(!0), setTransitionStatus("starting")), !open2 && mounted && transitionStatus !== "ending" && !deferEndingState && setTransitionStatus("ending"), !open2 && !mounted && transitionStatus === "ending" && setTransitionStatus(void 0), useIsoLayoutEffect(() => {
+    if (!open2 && mounted && transitionStatus !== "ending" && deferEndingState) {
+      let frame = AnimationFrame.request(() => {
+        setTransitionStatus("ending");
       });
-      isIndexOutOfListBounds(sortedElements, firstEnabledIndex) || onHighlightedIndexChange(firstEnabledIndex);
+      return () => {
+        AnimationFrame.cancel(frame);
+      };
     }
-    scrollIntoViewIfNeeded(rootRef.current, activeItem, direction, orientation);
-  });
-  useIsoLayoutEffect(() => {
-    if (disabledIndices == null || externalHighlightedIndex != null || !hasSetDefaultIndexRef.current)
+  }, [open2, mounted, transitionStatus, deferEndingState]), useIsoLayoutEffect(() => {
+    if (!open2 || enableIdleState || transitionStatus === void 0)
       return;
-    let elements = elementsRef.current;
-    if (isListIndexDisabled(elements, highlightedIndex, disabledIndices)) {
-      let firstEnabledIndex = findNonDisabledListIndex(elements, {
-        disabledIndices
-      });
-      isIndexOutOfListBounds(elements, firstEnabledIndex) || onHighlightedIndexChange(firstEnabledIndex);
-    }
-  }, [disabledIndices, externalHighlightedIndex, highlightedIndex, elementsRef, onHighlightedIndexChange]);
-  let wrappedOnLoop = useStableCallback((event, prevIndex, nextIndex) => onLoop ? onLoop(event, prevIndex, nextIndex, elementsRef) : nextIndex), onKeyDown = useStableCallback((event) => {
-    let isHomeOrEnd = event.key === HOME || event.key === END;
-    if (!COMPOSITE_KEYS.has(event.key) || !enableHomeAndEndKeys && isHomeOrEnd || isModifierKeySet(event, modifierKeys) || !rootRef.current)
+    let frame = AnimationFrame.request(() => {
+      setTransitionStatus(void 0);
+    });
+    return () => {
+      AnimationFrame.cancel(frame);
+    };
+  }, [enableIdleState, open2, transitionStatus]), useIsoLayoutEffect(() => {
+    if (!open2 || !enableIdleState)
       return;
-    let isRtl = direction === "rtl", horizontalForwardKey = isRtl ? ARROW_LEFT2 : ARROW_RIGHT2, horizontalBackwardKey = isRtl ? ARROW_RIGHT2 : ARROW_LEFT2, forwardKey = orientation === "vertical" ? ARROW_DOWN2 : horizontalForwardKey, backwardKey = orientation === "vertical" ? ARROW_UP2 : horizontalBackwardKey, target = getTarget(event.nativeEvent);
-    if (target != null && isNativeInput(target) && !isElementDisabled(target)) {
-      let selectionStart = target.selectionStart, selectionEnd = target.selectionEnd, textContent = target.value;
-      if (selectionStart == null || event.shiftKey || selectionStart !== selectionEnd || event.key !== backwardKey && selectionStart < textContent.length || event.key !== forwardKey && selectionStart > 0)
-        return;
-    }
-    let nextIndex = highlightedIndex, minIndex = getMinListIndex(elementsRef, disabledIndices), maxIndex = getMaxListIndex(elementsRef, disabledIndices);
-    grid != null && (nextIndex = grid({
-      disabledIndices,
-      elementsRef,
-      event,
-      highlightedIndex,
-      loopFocus,
-      maxIndex,
-      minIndex,
-      onLoop: wrappedOnLoop,
-      orientation,
-      rtl: isRtl
-    }));
-    let isForwardKey = orientation !== "vertical" && event.key === horizontalForwardKey || orientation !== "horizontal" && event.key === ARROW_DOWN2, isBackwardKey = orientation !== "vertical" && event.key === horizontalBackwardKey || orientation !== "horizontal" && event.key === ARROW_UP2;
-    enableHomeAndEndKeys && (event.key === HOME ? nextIndex = minIndex : event.key === END && (nextIndex = maxIndex)), nextIndex === highlightedIndex && (isForwardKey || isBackwardKey) && (loopFocus && nextIndex === maxIndex && isForwardKey ? (nextIndex = minIndex, onLoop && (nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef))) : loopFocus && nextIndex === minIndex && isBackwardKey ? (nextIndex = maxIndex, onLoop && (nextIndex = onLoop(event, highlightedIndex, nextIndex, elementsRef))) : nextIndex = findNonDisabledListIndex(elementsRef.current, {
-      startingIndex: nextIndex,
-      decrement: isBackwardKey,
-      disabledIndices
-    })), nextIndex !== highlightedIndex && !isIndexOutOfListBounds(elementsRef.current, nextIndex) && (stopEventPropagation && event.stopPropagation(), (isGrid || isHomeOrEnd || isForwardKey || isBackwardKey) && event.preventDefault(), onHighlightedIndexChange(nextIndex, !0), queueMicrotask(() => {
-      elementsRef.current[nextIndex]?.focus();
-    }));
-  });
-  return {
-    props: {
-      ref: mergedRef,
-      onFocus(event) {
-        let element = rootRef.current, target = getTarget(event.nativeEvent);
-        !element || target == null || !isNativeInput(target) || target.setSelectionRange(0, target.value.length);
-      },
-      onKeyDown
-    },
-    highlightedIndex,
-    onHighlightedIndexChange,
-    elementsRef,
-    onMapChange,
-    relayKeyboardEvent: onKeyDown
+    open2 && mounted && transitionStatus !== "idle" && setTransitionStatus("starting");
+    let frame = AnimationFrame.request(() => {
+      setTransitionStatus("idle");
+    });
+    return () => {
+      AnimationFrame.cancel(frame);
+    };
+  }, [enableIdleState, open2, mounted, transitionStatus]), {
+    mounted,
+    setMounted,
+    transitionStatus
   };
 }
-function getFallbackIndex(elements, disabledIndices) {
-  let fallbackIndex = -1;
-  for (let index2 = 0; index2 < elements.length; index2 += 1) {
-    let element = elements[index2];
-    if (!(!element || isListIndexDisabled(elements, index2, disabledIndices))) {
-      if (element.hasAttribute(ACTIVE_COMPOSITE_ITEM))
-        return index2;
-      fallbackIndex === -1 && (fallbackIndex = index2);
-    }
-  }
-  return Math.max(fallbackIndex, 0);
-}
-function isModifierKeySet(event, ignoredModifierKeys) {
-  for (let key of MODIFIER_KEYS)
-    if (!ignoredModifierKeys.includes(key) && event.getModifierState(key))
-      return !0;
-  return !1;
-}
 
-// ../../node_modules/@base-ui/react/internals/direction-context/DirectionContext.mjs
-import * as React30 from "react";
-var DirectionContext = React30.createContext(void 0);
-process.env.NODE_ENV !== "production" && (DirectionContext.displayName = "DirectionContext");
-function useDirection() {
-  return React30.useContext(DirectionContext)?.direction ?? "ltr";
-}
+// src/shared/use-sync-external-store/shim.ts
+import { useSyncExternalStore } from "react";
 
-// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRoot.mjs
-import { jsx as _jsx5 } from "react/jsx-runtime";
-function CompositeRoot(componentProps) {
-  let {
-    render,
-    className,
-    style,
-    refs = EMPTY_ARRAY,
-    props = EMPTY_ARRAY,
-    state = EMPTY_OBJECT,
-    stateAttributesMapping: stateAttributesMapping3,
-    highlightedIndex: highlightedIndexProp,
-    onHighlightedIndexChange: onHighlightedIndexChangeProp,
-    orientation,
-    grid,
-    loopFocus,
-    onLoop,
-    enableHomeAndEndKeys,
-    onMapChange: onMapChangeProp,
-    stopEventPropagation = !0,
-    rootRef,
-    disabledIndices,
-    modifierKeys,
-    highlightItemOnHover = !1,
-    tag = "div",
-    ...elementProps
-  } = componentProps, direction = useDirection(), {
-    props: defaultProps,
-    highlightedIndex,
-    onHighlightedIndexChange,
-    elementsRef,
-    onMapChange: onMapChangeUnwrapped,
-    relayKeyboardEvent
-  } = useCompositeRoot({
-    grid,
-    loopFocus,
-    onLoop,
-    orientation,
-    highlightedIndex: highlightedIndexProp,
-    onHighlightedIndexChange: onHighlightedIndexChangeProp,
-    rootRef,
-    stopEventPropagation,
-    enableHomeAndEndKeys,
-    direction,
-    disabledIndices,
-    modifierKeys
-  }), element = useRenderElement(tag, componentProps, {
-    state,
-    ref: refs,
-    props: [defaultProps, ...props, elementProps],
-    stateAttributesMapping: stateAttributesMapping3
-  }), contextValue = React31.useMemo(() => ({
-    highlightedIndex,
-    onHighlightedIndexChange,
-    highlightItemOnHover,
-    relayKeyboardEvent
-  }), [highlightedIndex, onHighlightedIndexChange, highlightItemOnHover, relayKeyboardEvent]);
-  return _jsx5(CompositeRootContext.Provider, {
-    value: contextValue,
-    children: _jsx5(CompositeList, {
-      elementsRef,
-      onMapChange: (newMap) => {
-        onMapChangeProp?.(newMap), onMapChangeUnwrapped(newMap);
-      },
-      children: element
-    })
-  });
+// ../../node_modules/@base-ui/react/utils/getCssDimensions.mjs
+function getCssDimensions(element) {
+  let css = getComputedStyle2(element), width = parseFloat(css.width) || 0, height = parseFloat(css.height) || 0, hasOffset = isHTMLElement(element), offsetWidth = hasOffset ? element.offsetWidth : width, offsetHeight = hasOffset ? element.offsetHeight : height;
+  return (round(width) !== offsetWidth || round(height) !== offsetHeight) && (width = offsetWidth, height = offsetHeight), {
+    width,
+    height
+  };
 }
 
-// ../../node_modules/@base-ui/react/tabs/list/TabsList.mjs
-import { jsx as _jsx6 } from "react/jsx-runtime";
-var TabsList = React32.forwardRef(function(componentProps, forwardedRef) {
-  let {
-    activateOnFocus = !1,
-    className,
-    loopFocus = !0,
-    render,
-    style,
-    ...elementProps
-  } = componentProps, {
-    orientation,
-    setTabMap,
-    tabActivationDirection
-  } = useTabsRootContext(), [highlightedTabIndex, setHighlightedTabIndex] = React32.useState(0), [tabsListElement, setTabsListElement] = React32.useState(null), indicatorUpdateListenersRef = React32.useRef(/* @__PURE__ */ new Set()), tabResizeObserverElementsRef = React32.useRef(/* @__PURE__ */ new Set()), resizeObserverRef = React32.useRef(null);
-  useIsoLayoutEffect(() => {
-    if (typeof ResizeObserver > "u")
-      return;
-    let resizeObserver = new ResizeObserver(() => {
-      indicatorUpdateListenersRef.current.forEach((listener) => {
-        listener();
-      });
-    });
-    return resizeObserverRef.current = resizeObserver, tabsListElement && resizeObserver.observe(tabsListElement), tabResizeObserverElementsRef.current.forEach((element) => {
-      resizeObserver.observe(element);
-    }), () => {
-      resizeObserver.disconnect(), resizeObserverRef.current = null;
-    };
-  }, [tabsListElement]);
-  let registerIndicatorUpdateListener = useStableCallback((listener) => (indicatorUpdateListenersRef.current.add(listener), () => {
-    indicatorUpdateListenersRef.current.delete(listener);
-  })), registerTabResizeObserverElement = useStableCallback((element) => (tabResizeObserverElementsRef.current.add(element), resizeObserverRef.current?.observe(element), () => {
-    tabResizeObserverElementsRef.current.delete(element), resizeObserverRef.current?.unobserve(element);
-  })), state = {
-    orientation,
-    tabActivationDirection
-  }, defaultProps = {
-    "aria-orientation": orientation === "vertical" ? "vertical" : void 0,
-    role: "tablist"
-  }, tabsListContextValue = React32.useMemo(() => ({
-    activateOnFocus,
-    registerIndicatorUpdateListener,
-    registerTabResizeObserverElement,
-    tabsListElement
-  }), [activateOnFocus, registerIndicatorUpdateListener, registerTabResizeObserverElement, tabsListElement]);
-  return _jsx6(TabsListContext.Provider, {
-    value: tabsListContextValue,
-    children: _jsx6(CompositeRoot, {
-      render,
-      className,
-      style,
-      state,
-      refs: [forwardedRef, setTabsListElement],
-      props: [defaultProps, elementProps],
-      stateAttributesMapping: tabsStateAttributesMapping,
-      highlightedIndex: highlightedTabIndex,
-      enableHomeAndEndKeys: !0,
-      loopFocus,
-      orientation,
-      onHighlightedIndexChange: setHighlightedTabIndex,
-      onMapChange: setTabMap,
-      disabledIndices: EMPTY_ARRAY
-    })
-  });
-});
-process.env.NODE_ENV !== "production" && (TabsList.displayName = "TabsList");
-
 export {
   useRefWithInit,
   useStableCallback,
   NOOP,
+  EMPTY_ARRAY,
   EMPTY_OBJECT,
   useOnMount,
   formatErrorMessage_default,
@@ -2735,6 +1647,7 @@ export {
   closest,
   getTarget,
   FOCUSABLE_ATTRIBUTE,
+  TransitionStatusDataAttributes_exports,
   transitionStatusMapping,
   CommonPopupDataAttributes_exports,
   CommonTriggerDataAttributes_exports,
@@ -2778,6 +1691,11 @@ export {
   getOppositePlacement,
   getPaddingObject,
   rectToClientRect,
+  isIndexOutOfListBounds,
+  getMinListIndex,
+  getMaxListIndex,
+  findNonDisabledListIndex,
+  isListIndexDisabled,
   isElementVisible,
   ownerDocument,
   isTabbable,
@@ -2789,7 +1707,6 @@ export {
   isOutsideEvent,
   disableFocusInside,
   enableFocusInside,
-  useCSPContext,
   useIsoLayoutEffect,
   DirectionContext,
   useDirection,
@@ -2802,9 +1719,21 @@ export {
   useTransitionStatus,
   useAnimationsFinished,
   useOpenChangeComplete,
+  useSyncExternalStore,
   inertValue,
   getCssDimensions,
+  error,
+  CompositeRootContext,
+  useCompositeRootContext,
   useButton,
+  ARROW_UP2 as ARROW_UP,
+  ARROW_DOWN2 as ARROW_DOWN,
+  ARROW_LEFT2 as ARROW_LEFT,
+  ARROW_RIGHT2 as ARROW_RIGHT,
+  HOME,
+  END,
   COMPOSITE_KEYS,
-  index_parts_exports
+  MODIFIER_KEYS,
+  isNativeInput,
+  scrollIntoViewIfNeeded
 };