@aussieljk/forkbook 0.0.1-5 → 0.0.1-7

package/dist/_browser-chunks/chunk-E47B5255.js

@@ -0,0 +1,1149 @@
+import {
+  ARROW_DOWN,
+  ARROW_LEFT,
+  ARROW_RIGHT,
+  ARROW_UP,
+  COMPOSITE_KEYS,
+  CompositeRootContext,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  END,
+  HOME,
+  MODIFIER_KEYS,
+  TransitionStatusDataAttributes_exports,
+  activeElement,
+  contains,
+  createChangeEventDetails,
+  error,
+  findNonDisabledListIndex,
+  formatErrorMessage_default,
+  getCssDimensions,
+  getMaxListIndex,
+  getMinListIndex,
+  getParentNode,
+  getTarget,
+  getWindow,
+  inertValue,
+  isHTMLElement,
+  isIndexOutOfListBounds,
+  isLastTraversableNode,
+  isListIndexDisabled,
+  isNativeInput,
+  isReactVersionAtLeast,
+  ownerDocument,
+  reason_parts_exports,
+  scrollIntoViewIfNeeded,
+  transitionStatusMapping,
+  useBaseUiId,
+  useButton,
+  useCompositeRootContext,
+  useDirection,
+  useForcedRerendering,
+  useIsoLayoutEffect,
+  useMergedRefs,
+  useOpenChangeComplete,
+  useRefWithInit,
+  useRenderElement,
+  useStableCallback,
+  useSyncExternalStore,
+  useTransitionStatus
+} from "./chunk-DAUHYZUB.js";
+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 React5 from "react";
+
+// ../../node_modules/@base-ui/utils/useControlled.mjs
+import * as React from "react";
+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/react/internals/composite/list/CompositeList.mjs
+import * as React3 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/list/CompositeListContext.mjs
+import * as React2 from "react";
+var CompositeListContext = React2.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  subscribeMapChange: () => () => {
+  },
+  nextIndexRef: {
+    current: 0
+  }
+});
+process.env.NODE_ENV !== "production" && (CompositeListContext.displayName = "CompositeListContext");
+function useCompositeListContext() {
+  return React2.useContext(CompositeListContext);
+}
+
+// ../../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] = React3.useState(0), listeners = useRefWithInit(createListeners).current, map = useRefWithInit(createMap).current, nextIndexRef = React3.useRef(0), isDirtyRef = React3.useRef(!0), itemsRef = React3.useRef(null), mutationObserverRef = React3.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;
+  }, []);
+  let subscribeMapChange = useStableCallback((fn) => (listeners.add(fn), () => {
+    listeners.delete(fn);
+  })), contextValue = React3.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/react/tabs/root/TabsRootContext.mjs
+import * as React4 from "react";
+var TabsRootContext = React4.createContext(void 0);
+process.env.NODE_ENV !== "production" && (TabsRootContext.displayName = "TabsRootContext");
+function useTabsRootContext() {
+  let context = React4.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/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/tabs/root/TabsRoot.mjs
+import { jsx as _jsx2 } from "react/jsx-runtime";
+var TabsRoot = React5.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 = React5.useRef([]), [mountedTabPanels, setMountedTabPanels] = React5.useState(() => /* @__PURE__ */ new Map()), [value, setValue] = useControlled({
+    controlled: valueProp,
+    default: defaultValueProp,
+    name: "Tabs",
+    state: "value"
+  }), isControlled = valueProp !== void 0, [tabMap, setTabMap] = React5.useState(() => /* @__PURE__ */ new Map()), lastKnownTabElementRef = React5.useRef(void 0), getTabElementBySelectedValue = React5.useCallback((selectedValue) => findTabElement(tabMap, selectedValue), [tabMap]), [activationDirectionState, setActivationDirectionState] = React5.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 = React5.useCallback((tabValue) => mountedTabPanels.get(tabValue), [mountedTabPanels]), getTabIdByPanelValue = React5.useCallback((tabPanelValue) => {
+    for (let tabMetadata of tabMap.values())
+      if (tabPanelValue === tabMetadata.value)
+        return tabMetadata.id;
+  }, [tabMap]), tabsContextValue = React5.useMemo(() => ({
+    getTabElementBySelectedValue,
+    getTabIdByPanelValue,
+    getTabPanelIdByValue,
+    onValueChange,
+    orientation,
+    registerMountedTabPanel,
+    setTabMap,
+    tabActivationDirection,
+    value
+  }), [getTabElementBySelectedValue, getTabIdByPanelValue, getTabPanelIdByValue, onValueChange, orientation, registerMountedTabPanel, setTabMap, tabActivationDirection, value]), selectedTabMetadata = React5.useMemo(() => {
+    for (let tabMetadata of tabMap.values())
+      if (tabMetadata.value === value)
+        return tabMetadata;
+  }, [tabMap, value]), firstEnabledTabValue = React5.useMemo(() => {
+    for (let tabMetadata of tabMap.values())
+      if (!tabMetadata.disabled)
+        return tabMetadata.value;
+  }, [tabMap]), shouldNotifyInitialValueChangeRef = React5.useRef(!hasExplicitDefaultValueProp), initialDefaultValueRef = React5.useRef(defaultValueProp), shouldHonorDisabledDefaultValueRef = React5.useRef(hasExplicitDefaultValueProp), didRegisterTabsRef = React5.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/tabs/tab/TabsTab.mjs
+import * as React9 from "react";
+
+// ../../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 React7 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/list/useCompositeListItem.mjs
+import * as React6 from "react";
+function useCompositeListItem(params = {}) {
+  let {
+    guess,
+    label,
+    metadata,
+    textRef,
+    index: externalIndex
+  } = params, {
+    register,
+    unregister,
+    subscribeMapChange,
+    nextIndexRef
+  } = useCompositeListContext(), indexRef = React6.useRef(-1), [internalIndex, setInternalIndex] = React6.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 = React6.useRef(null), ref = React6.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 = React7.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 disabled = item.hasAttribute("disabled") || item.ariaDisabled === "true";
+        !isHighlighted && !disabled && item.focus();
+      }
+    },
+    compositeRef: mergedRef,
+    index: index2
+  };
+}
+
+// ../../node_modules/@base-ui/react/tabs/list/TabsListContext.mjs
+import * as React8 from "react";
+var TabsListContext = React8.createContext(void 0);
+process.env.NODE_ENV !== "production" && (TabsListContext.displayName = "TabsListContext");
+function useTabsListContext() {
+  let context = React8.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/react/tabs/tab/TabsTab.mjs
+var TabsTab = React9.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    className,
+    disabled = !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 = React9.useMemo(() => ({
+    disabled,
+    id,
+    value
+  }), [disabled, 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 = React9.useRef(!1), unobserveTabElementRef = React9.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;
+    }
+    disabled || onHighlightedIndexChange(index2);
+  }, [active, index2, highlightedIndex, onHighlightedIndexChange, disabled, tabsListElement]);
+  let {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton,
+    focusableWhenDisabled: !0
+  }), tabPanelId = getTabPanelIdByValue(value), isPressingRef = React9.useRef(!1), isMainButtonRef = React9.useRef(!1);
+  function activate(event) {
+    onValueChange(value, createChangeEventDetails(reason_parts_exports.none, event.nativeEvent, void 0, {
+      activationDirection: "none"
+    }));
+  }
+  function onClick(event) {
+    active || disabled || activate(event);
+  }
+  function onFocus(event) {
+    active || disabled || activateOnFocus && (!isPressingRef.current || // keyboard or touch focus
+    isMainButtonRef.current) && activate(event);
+  }
+  function onPointerDown(event) {
+    if (active || disabled)
+      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,
+      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 React13 from "react";
+
+// ../../node_modules/@base-ui/react/internals/PrehydrationScript.mjs
+import "react";
+
+// ../../node_modules/@base-ui/utils/hydration.mjs
+import * as React10 from "react";
+var emptySubscribe = () => () => {
+}, getTrue = () => !0, getFalse = () => !1;
+function useIsHydratedModern() {
+  return useSyncExternalStore(emptySubscribe, getTrue, getFalse);
+}
+function useIsHydratedLegacy() {
+  let [hydrated, setHydrated] = React10.useState(!1);
+  return React10.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 React11 from "react";
+var CSPContext = React11.createContext(void 0);
+process.env.NODE_ENV !== "production" && (CSPContext.displayName = "CSPContext");
+var DEFAULT_CSP_CONTEXT_VALUE = {
+  disableStyleElements: !1
+};
+function useCSPContext() {
+  return React11.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/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 = React13.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    className,
+    render,
+    renderBeforeHydration = !1,
+    style: styleProp,
+    ...elementProps
+  } = componentProps, {
+    getTabElementBySelectedValue,
+    orientation,
+    tabActivationDirection,
+    value
+  } = useTabsRootContext(), {
+    tabsListElement,
+    registerIndicatorUpdateListener
+  } = useTabsListContext(), rerender = useForcedRerendering();
+  React13.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(React13.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 React14 from "react";
+
+// ../../node_modules/@base-ui/react/tabs/panel/TabsPanelDataAttributes.mjs
+var index = "data-index";
+var startingStyle = TransitionStatusDataAttributes_exports.startingStyle, endingStyle = TransitionStatusDataAttributes_exports.endingStyle;
+
+// ../../node_modules/@base-ui/react/tabs/panel/TabsPanel.mjs
+var stateAttributesMapping2 = {
+  ...tabsStateAttributesMapping,
+  ...transitionStatusMapping
+}, TabsPanel = React14.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(), open = value === selectedValue, {
+    mounted,
+    transitionStatus,
+    setMounted
+  } = useTransitionStatus(open), hidden = !mounted, correspondingTabId = getTabIdByPanelValue(value), state = {
+    hidden,
+    orientation,
+    tabActivationDirection,
+    transitionStatus
+  }, panelRef = React14.useRef(null), element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, listItemRef, panelRef],
+    props: [{
+      "aria-labelledby": correspondingTabId,
+      hidden,
+      id,
+      role: "tabpanel",
+      tabIndex: open ? 0 : -1,
+      inert: inertValue(!open),
+      // Computed key: a plain literal key fails the DOM-props excess property check.
+      [index]: index2
+    }, elementProps],
+    stateAttributesMapping: stateAttributesMapping2
+  });
+  return useOpenChangeComplete({
+    open,
+    ref: panelRef,
+    onComplete() {
+      open || 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 React17 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRoot.mjs
+import * as React16 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/root/useCompositeRoot.mjs
+import * as React15 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/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] = React15.useState(0), isGrid = grid != null, rootRef = React15.useRef(null), mergedRef = useMergedRefs(rootRef, externalRef), elementsRef = React15.useRef([]), hasSetDefaultIndexRef = React15.useRef(!1), highlightedElementRef = React15.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
+      });
+      isIndexOutOfListBounds(sortedElements, firstEnabledIndex) || onHighlightedIndexChange(firstEnabledIndex);
+    }
+    scrollIntoViewIfNeeded(rootRef.current, activeItem, direction, orientation);
+  });
+  useIsoLayoutEffect(() => {
+    if (disabledIndices == null || externalHighlightedIndex != null || !hasSetDefaultIndexRef.current)
+      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)
+      return;
+    let isRtl = direction === "rtl", horizontalForwardKey = isRtl ? ARROW_LEFT : ARROW_RIGHT, horizontalBackwardKey = isRtl ? ARROW_RIGHT : ARROW_LEFT, forwardKey = orientation === "vertical" ? ARROW_DOWN : horizontalForwardKey, backwardKey = orientation === "vertical" ? ARROW_UP : 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_DOWN, isBackwardKey = orientation !== "vertical" && event.key === horizontalBackwardKey || orientation !== "horizontal" && event.key === ARROW_UP;
+    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
+  };
+}
+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/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 = React16.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/tabs/list/TabsList.mjs
+import { jsx as _jsx6 } from "react/jsx-runtime";
+var TabsList = React17.forwardRef(function(componentProps, forwardedRef) {
+  let {
+    activateOnFocus = !1,
+    className,
+    loopFocus = !0,
+    render,
+    style,
+    ...elementProps
+  } = componentProps, {
+    orientation,
+    setTabMap,
+    tabActivationDirection
+  } = useTabsRootContext(), [highlightedTabIndex, setHighlightedTabIndex] = React17.useState(0), [tabsListElement, setTabsListElement] = React17.useState(null), indicatorUpdateListenersRef = React17.useRef(/* @__PURE__ */ new Set()), tabResizeObserverElementsRef = React17.useRef(/* @__PURE__ */ new Set()), resizeObserverRef = React17.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 = React17.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 {
+  useCSPContext,
+  index_parts_exports
+};