@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

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

@@ -0,0 +1,2810 @@
+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";
+var SafeReact = {
+  ...React3
+};
+
+// ../../node_modules/@base-ui/utils/useRefWithInit.mjs
+import * as React4 from "react";
+var UNINITIALIZED = {};
+function useRefWithInit(init, initArg) {
+  let ref = React4.useRef(UNINITIALIZED);
+  return ref.current === UNINITIALIZED && (ref.current = init(initArg)), ref;
+}
+
+// ../../node_modules/@base-ui/utils/useStableCallback.mjs
+var useInsertionEffect = SafeReact.useInsertionEffect, useSafeInsertionEffect = (
+  // React 17 doesn't have useInsertionEffect.
+  useInsertionEffect && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  useInsertionEffect !== SafeReact.useLayoutEffect ? useInsertionEffect : (fn) => fn()
+);
+function useStableCallback(callback) {
+  let stable = useRefWithInit(createStableCallback).current;
+  return stable.next = callback, useSafeInsertionEffect(stable.effect), stable.trampoline;
+}
+function createStableCallback() {
+  let stable = {
+    next: void 0,
+    callback: assertNotCalled,
+    trampoline: (...args) => stable.callback?.(...args),
+    effect: () => {
+      stable.callback = stable.next;
+    }
+  };
+  return stable;
+}
+function assertNotCalled() {
+  if (process.env.NODE_ENV !== "production")
+    throw (
+      /* minify-error-disabled */
+      new Error("Base UI: Cannot call an event handler while rendering.")
+    );
+}
+
+// ../../node_modules/@base-ui/react/internals/useRenderElement.mjs
+import * as React7 from "react";
+
+// ../../node_modules/@base-ui/utils/useMergedRefs.mjs
+function useMergedRefs(a, b, c, d) {
+  let forkRef = useRefWithInit(createForkRef).current;
+  return didChange(forkRef, a, b, c, d) && update(forkRef, [a, b, c, d]), forkRef.callback;
+}
+function useMergedRefsN(refs) {
+  let forkRef = useRefWithInit(createForkRef).current;
+  return didChangeN(forkRef, refs) && update(forkRef, refs), forkRef.callback;
+}
+function createForkRef() {
+  return {
+    callback: null,
+    cleanup: null,
+    refs: []
+  };
+}
+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]);
+}
+function update(forkRef, refs) {
+  if (forkRef.refs = refs, refs.every((ref) => ref == null)) {
+    forkRef.callback = null;
+    return;
+  }
+  forkRef.callback = (instance) => {
+    if (forkRef.cleanup && (forkRef.cleanup(), forkRef.cleanup = null), instance != null) {
+      let cleanupCallbacks = Array(refs.length).fill(null);
+      for (let i = 0; i < refs.length; i += 1) {
+        let ref = refs[i];
+        if (ref != null)
+          switch (typeof ref) {
+            case "function": {
+              let refCleanup = ref(instance);
+              typeof refCleanup == "function" && (cleanupCallbacks[i] = refCleanup);
+              break;
+            }
+            case "object": {
+              ref.current = instance;
+              break;
+            }
+            default:
+          }
+      }
+      forkRef.cleanup = () => {
+        for (let i = 0; i < refs.length; i += 1) {
+          let ref = refs[i];
+          if (ref != null)
+            switch (typeof ref) {
+              case "function": {
+                let cleanupCallback = cleanupCallbacks[i];
+                typeof cleanupCallback == "function" ? cleanupCallback() : ref(null);
+                break;
+              }
+              case "object": {
+                ref.current = null;
+                break;
+              }
+              default:
+            }
+        }
+      };
+    }
+  };
+}
+
+// ../../node_modules/@base-ui/utils/getReactElementRef.mjs
+import * as React6 from "react";
+
+// ../../node_modules/@base-ui/utils/reactVersion.mjs
+import * as React5 from "react";
+var majorVersion = parseInt(React5.version, 10);
+function isReactVersionAtLeast(reactVersionToCheck) {
+  return majorVersion >= reactVersionToCheck;
+}
+
+// ../../node_modules/@base-ui/utils/getReactElementRef.mjs
+function getReactElementRef(element) {
+  if (!React6.isValidElement(element))
+    return null;
+  let reactElement = element, propsWithRef = reactElement.props;
+  return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
+}
+
+// ../../node_modules/@base-ui/utils/mergeObjects.mjs
+function mergeObjects(a, b) {
+  if (a && !b)
+    return a;
+  if (!a && b)
+    return b;
+  if (a || b)
+    return {
+      ...a,
+      ...b
+    };
+}
+
+// ../../node_modules/@base-ui/utils/warn.mjs
+var warn = createLogOnce("warn", "Base UI");
+
+// ../../node_modules/@base-ui/utils/empty.mjs
+function NOOP() {
+}
+var EMPTY_ARRAY = Object.freeze([]), EMPTY_OBJECT = Object.freeze({});
+
+// ../../node_modules/@base-ui/react/internals/getStateAttributesProps.mjs
+function getStateAttributesProps(state, customMapping) {
+  let props = {};
+  for (let key in state) {
+    let value = state[key];
+    if (customMapping?.hasOwnProperty(key)) {
+      let customProps = customMapping[key](value);
+      customProps != null && Object.assign(props, customProps);
+      continue;
+    }
+    value === !0 ? props[`data-${key.toLowerCase()}`] = "" : value && (props[`data-${key.toLowerCase()}`] = value.toString());
+  }
+  return props;
+}
+
+// ../../node_modules/@base-ui/react/utils/resolveClassName.mjs
+function resolveClassName(className, state) {
+  return typeof className == "function" ? className(state) : className;
+}
+
+// ../../node_modules/@base-ui/react/utils/resolveStyle.mjs
+function resolveStyle(style, state) {
+  return typeof style == "function" ? style(state) : style;
+}
+
+// ../../node_modules/@base-ui/react/merge-props/mergeProps.mjs
+var EMPTY_PROPS = {};
+function mergeProps(a, b, c, d, e) {
+  if (!c && !d && !e && !a)
+    return createInitialMergedProps(b);
+  let merged = createInitialMergedProps(a);
+  return b && (merged = mergeInto(merged, b)), c && (merged = mergeInto(merged, c)), d && (merged = mergeInto(merged, d)), e && (merged = mergeInto(merged, e)), merged;
+}
+function mergePropsN(props) {
+  if (props.length === 0)
+    return EMPTY_PROPS;
+  if (props.length === 1)
+    return createInitialMergedProps(props[0]);
+  let merged = createInitialMergedProps(props[0]);
+  for (let i = 1; i < props.length; i += 1)
+    merged = mergeInto(merged, props[i]);
+  return merged;
+}
+function createInitialMergedProps(inputProps) {
+  return isPropsGetter(inputProps) ? {
+    ...inputProps(EMPTY_PROPS)
+  } : copyInitialProps(inputProps);
+}
+function mergeInto(merged, inputProps) {
+  return isPropsGetter(inputProps) ? inputProps(merged) : mutablyMergeInto(merged, inputProps);
+}
+function copyInitialProps(inputProps) {
+  let copiedProps = {
+    ...inputProps
+  };
+  for (let propName in copiedProps) {
+    let propValue = copiedProps[propName];
+    isEventHandler(propName, propValue) && (copiedProps[propName] = wrapEventHandler(propValue));
+  }
+  return copiedProps;
+}
+function mutablyMergeInto(mergedProps, externalProps) {
+  if (!externalProps)
+    return mergedProps;
+  for (let propName in externalProps) {
+    let externalPropValue = externalProps[propName];
+    switch (propName) {
+      case "style": {
+        mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
+        break;
+      }
+      case "className": {
+        mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
+        break;
+      }
+      default:
+        isEventHandler(propName, externalPropValue) ? mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue) : mergedProps[propName] = externalPropValue;
+    }
+  }
+  return mergedProps;
+}
+function isEventHandler(key, value) {
+  let code0 = key.charCodeAt(0), code1 = key.charCodeAt(1), code2 = key.charCodeAt(2);
+  return code0 === 111 && code1 === 110 && code2 >= 65 && code2 <= 90 && (typeof value == "function" || typeof value > "u");
+}
+function isPropsGetter(inputProps) {
+  return typeof inputProps == "function";
+}
+function mergeEventHandlers(ourHandler, theirHandler) {
+  return theirHandler ? ourHandler ? (...args) => {
+    let event = args[0];
+    if (isSyntheticEvent(event)) {
+      let baseUIEvent = event;
+      makeEventPreventable(baseUIEvent);
+      let result2 = theirHandler(...args);
+      return baseUIEvent.baseUIHandlerPrevented || ourHandler?.(...args), result2;
+    }
+    let result = theirHandler(...args);
+    return ourHandler?.(...args), result;
+  } : wrapEventHandler(theirHandler) : ourHandler;
+}
+function wrapEventHandler(handler) {
+  return handler && ((...args) => {
+    let event = args[0];
+    return isSyntheticEvent(event) && makeEventPreventable(event), handler(...args);
+  });
+}
+function makeEventPreventable(event) {
+  return event.preventBaseUIHandler = () => {
+    event.baseUIHandlerPrevented = !0;
+  }, event;
+}
+function mergeClassNames(ourClassName, theirClassName) {
+  return theirClassName ? ourClassName ? theirClassName + " " + ourClassName : theirClassName : ourClassName;
+}
+function isSyntheticEvent(event) {
+  return event != null && typeof event == "object" && "nativeEvent" in event;
+}
+
+// ../../node_modules/@base-ui/react/internals/useRenderElement.mjs
+import { createElement as _createElement } from "react";
+function useRenderElement(element, componentProps, params = {}) {
+  let renderProp = componentProps.render;
+  params.enabled !== !1 && (renderProp = unwrapLazyRenderProp(renderProp));
+  let outProps = useRenderElementProps(componentProps, params, renderProp);
+  if (params.enabled === !1)
+    return null;
+  let state = params.state ?? EMPTY_OBJECT;
+  return evaluateRenderProp(element, renderProp, outProps, state);
+}
+function useRenderElementProps(componentProps, params, renderProp) {
+  let {
+    className: classNameProp,
+    style: styleProp
+  } = componentProps, {
+    state = EMPTY_OBJECT,
+    ref,
+    props,
+    stateAttributesMapping: stateAttributesMapping3,
+    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;
+  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) {
+  return Array.isArray(props) ? mergePropsN(props) : mergeProps(void 0, props);
+}
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), COMPONENT_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9$]*$/, LOWERCASE_CHARACTER_PATTERN = /[a-z]/;
+function unwrapLazyRenderProp(render) {
+  if (render?.$$typeof !== REACT_LAZY_TYPE)
+    return render;
+  let unwrapped = React7.Children.toArray(render)[0];
+  return React7.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))
+      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 renderTag(element, props);
+}
+function warnIfRenderPropLooksLikeComponent(renderFn) {
+  let functionName = renderFn.name;
+  functionName.length !== 0 && COMPONENT_IDENTIFIER_PATTERN.test(functionName) && LOWERCASE_CHARACTER_PATTERN.test(functionName) && warn(`The \`render\` prop received a function named \`${functionName}\` that starts with an uppercase letter.`, "This usually means a React component was passed directly as `render={Component}`.", "Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.", "If this is an intentional render callback, rename it to start with a lowercase letter.", "Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.", "https://base-ui.com/r/invalid-render-prop");
+}
+function renderTag(Tag, props) {
+  return Tag === "button" ? _createElement("button", {
+    type: "button",
+    ...props,
+    key: props.key
+  }) : Tag === "img" ? _createElement("img", {
+    alt: "",
+    ...props,
+    key: props.key
+  }) : React7.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/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;
+  }, []);
+  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/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
+  };
+}
+
+// ../../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/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";
+}
+function getNodeName(node) {
+  return isNode(node) ? (node.nodeName || "").toLowerCase() : "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  return hasWindow() ? value instanceof Node || value instanceof getWindow(value).Node : !1;
+}
+function isElement(value) {
+  return hasWindow() ? value instanceof Element || value instanceof getWindow(value).Element : !1;
+}
+function isHTMLElement(value) {
+  return hasWindow() ? value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement : !1;
+}
+function isShadowRoot(value) {
+  return !hasWindow() || typeof ShadowRoot > "u" ? !1 : value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  let {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle2(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
+}
+function isTableElement(element) {
+  return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+  try {
+    if (element.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return element.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+var willChangeRe = /transform|translate|scale|rotate|perspective|filter/, containRe = /paint|layout|strict|content/, isNotNone = (value) => !!value && value !== "none", isWebKitValue;
+function isContainingBlock(elementOrCss) {
+  let css = isElement(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
+  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  for (; isHTMLElement(currentNode) && !isLastTraversableNode(currentNode); ) {
+    if (isContainingBlock(currentNode))
+      return currentNode;
+    if (isTopLayer(currentNode))
+      return null;
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  return isWebKitValue == null && (isWebKitValue = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), isWebKitValue;
+}
+function isLastTraversableNode(node) {
+  return /^(html|body|#document)$/.test(getNodeName(node));
+}
+function getComputedStyle2(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  return isElement(element) ? {
+    scrollLeft: element.scrollLeft,
+    scrollTop: element.scrollTop
+  } : {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html")
+    return node;
+  let result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  let parentNode = getParentNode(node);
+  return isLastTraversableNode(parentNode) ? (node.ownerDocument || node).body : isHTMLElement(parentNode) && isOverflowElement(parentNode) ? parentNode : getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  list === void 0 && (list = []), traverseIframes === void 0 && (traverseIframes = !0);
+  let scrollableAncestor = getNearestOverflowAncestor(node), isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body), win = getWindow(scrollableAncestor);
+  if (isBody) {
+    let frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  } else
+    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+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/utils/useId.mjs
+import * as React13 from "react";
+
+// ../../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/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;
+}
+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/useBaseUiId.mjs
+function useBaseUiId(idOverride) {
+  return useId(idOverride, "base-ui");
+}
+
+// ../../node_modules/@base-ui/react/internals/use-button/useButton.mjs
+import * as React16 from "react";
+
+// ../../node_modules/@base-ui/react/internals/composite/root/CompositeRootContext.mjs
+import * as React14 from "react";
+var CompositeRootContext = React14.createContext(void 0);
+process.env.NODE_ENV !== "production" && (CompositeRootContext.displayName = "CompositeRootContext");
+function useCompositeRootContext(optional = !1) {
+  let context = React14.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";
+function useFocusableWhenDisabled(parameters) {
+  let {
+    focusableWhenDisabled,
+    disabled: disabled2,
+    composite = !1,
+    tabIndex: tabIndexProp = 0,
+    isNativeButton
+  } = parameters, isFocusableComposite = composite && focusableWhenDisabled !== !1, isNonFocusableComposite = composite && focusableWhenDisabled === !1;
+  return {
+    props: React15.useMemo(() => {
+      let additionalProps = {
+        // allow Tabbing away from focusableWhenDisabled elements
+        onKeyDown(event) {
+          disabled2 && focusableWhenDisabled && event.key !== "Tab" && event.preventDefault();
+        }
+      };
+      return composite || (additionalProps.tabIndex = tabIndexProp, !isNativeButton && disabled2 && (additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1)), (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled2) && (additionalProps["aria-disabled"] = disabled2), isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite) && (additionalProps.disabled = disabled2), additionalProps;
+    }, [composite, disabled2, focusableWhenDisabled, isFocusableComposite, isNonFocusableComposite, isNativeButton, tabIndexProp])
+  };
+}
+
+// ../../node_modules/@base-ui/react/utils/dispatchClickWithModifiers.mjs
+function dispatchClickWithModifiers(target, sourceEvent, {
+  detail = 0,
+  pointerType = ""
+} = {}) {
+  target.dispatchEvent(new (getWindow(target)).PointerEvent("click", {
+    bubbles: !0,
+    cancelable: !0,
+    composed: !0,
+    detail,
+    pointerType,
+    shiftKey: sourceEvent.shiftKey,
+    ctrlKey: sourceEvent.ctrlKey,
+    altKey: sourceEvent.altKey,
+    metaKey: sourceEvent.metaKey
+  }));
+}
+
+// ../../node_modules/@base-ui/react/internals/use-button/useButton.mjs
+function useButton(parameters = {}) {
+  let {
+    disabled: disabled2 = !1,
+    focusableWhenDisabled,
+    tabIndex = 0,
+    native: isNativeButton = !0,
+    composite: compositeProp
+  } = parameters, elementRef = React16.useRef(null), compositeRootContext = useCompositeRootContext(!0), isCompositeItem = compositeProp ?? compositeRootContext !== void 0, {
+    props: focusableWhenDisabledProps
+  } = useFocusableWhenDisabled({
+    focusableWhenDisabled,
+    disabled: disabled2,
+    composite: isCompositeItem,
+    tabIndex,
+    isNativeButton
+  });
+  process.env.NODE_ENV !== "production" && React16.useEffect(() => {
+    if (!elementRef.current)
+      return;
+    let isButtonTag = isButtonElement(elementRef.current);
+    if (isNativeButton) {
+      if (!isButtonTag) {
+        let ownerStackMessage = SafeReact.captureOwnerStack?.() || "";
+        error(`A component that acts as a button expected a native <button> because the \`nativeButton\` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the \`render\` prop, or set \`nativeButton\` to \`false\`.${ownerStackMessage}`);
+      }
+    } else if (isButtonTag) {
+      let ownerStackMessage = SafeReact.captureOwnerStack?.() || "";
+      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 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 {
+      onClick: externalOnClick,
+      onMouseDown: externalOnMouseDown,
+      onKeyUp: externalOnKeyUp,
+      onKeyDown: externalOnKeyDown,
+      onPointerDown: externalOnPointerDown,
+      ...otherExternalProps
+    } = externalProps;
+    return mergeProps({
+      onClick(event) {
+        if (disabled2) {
+          event.preventDefault();
+          return;
+        }
+        externalOnClick?.(event);
+      },
+      onMouseDown(event) {
+        disabled2 || externalOnMouseDown?.(event);
+      },
+      onKeyDown(event) {
+        if (disabled2 || (makeEventPreventable(event), externalOnKeyDown?.(event), event.baseUIHandlerPrevented))
+          return;
+        let isCurrentTarget = event.target === event.currentTarget, currentTarget = event.currentTarget, isButton = isButtonElement(currentTarget), isLink = !isNativeButton && isValidLinkElement(currentTarget), shouldClick = isCurrentTarget && (isNativeButton ? isButton : !isLink), isEnterKey = event.key === "Enter", isSpaceKey = event.key === " ", role = currentTarget.getAttribute("role"), isTextNavigationRole = role?.startsWith("menuitem") || role === "option" || role === "gridcell";
+        if (isCurrentTarget && isCompositeItem && isSpaceKey) {
+          if (event.defaultPrevented && isTextNavigationRole)
+            return;
+          event.preventDefault(), (!isNativeButton || isButton) && (event.preventBaseUIHandler(), dispatchClickWithModifiers(currentTarget, event));
+          return;
+        }
+        if (!shouldClick || isNativeButton || !isSpaceKey && !isEnterKey) {
+          isCurrentTarget && isLink && isSpaceKey && event.preventDefault();
+          return;
+        }
+        event.defaultPrevented || (event.preventDefault(), isEnterKey && (event.preventBaseUIHandler(), dispatchClickWithModifiers(currentTarget, event)));
+      },
+      onKeyUp(event) {
+        if (!disabled2) {
+          if (makeEventPreventable(event), externalOnKeyUp?.(event), event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && event.key === " ") {
+            event.preventDefault();
+            return;
+          }
+          event.baseUIHandlerPrevented || event.target === event.currentTarget && !isNativeButton && !isCompositeItem && !event.defaultPrevented && event.key === " " && (event.preventBaseUIHandler(), dispatchClickWithModifiers(event.currentTarget, event));
+        }
+      },
+      onPointerDown(event) {
+        if (disabled2) {
+          event.preventDefault();
+          return;
+        }
+        externalOnPointerDown?.(event);
+      }
+    }, isNativeButton ? {
+      type: "button"
+    } : {
+      role: "button"
+    }, focusableWhenDisabledProps, otherExternalProps);
+  }, [disabled2, focusableWhenDisabledProps, isCompositeItem, isNativeButton]), buttonRef = useStableCallback((element) => {
+    elementRef.current = element, updateDisabled();
+  });
+  return {
+    getButtonProps,
+    buttonRef
+  };
+}
+function isButtonElement(elem) {
+  return isHTMLElement(elem) && elem.tagName === "BUTTON";
+}
+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, {
+  engine: () => engine_exports,
+  env: () => env_exports,
+  mediaQuery: () => media_query_exports,
+  os: () => os_exports,
+  screenReader: () => screen_reader_exports
+});
+
+// ../../node_modules/@base-ui/utils/platform/os.mjs
+var os_exports = {};
+__export(os_exports, {
+  android: () => android,
+  apple: () => apple,
+  ios: () => ios,
+  linux: () => linux,
+  mac: () => mac,
+  windows: () => windows
+});
+
+// ../../node_modules/@base-ui/utils/platform/shared.mjs
+function readRawData() {
+  if (typeof navigator > "u")
+    return {
+      userAgent: "",
+      platform: "",
+      maxTouchPoints: 0
+    };
+  if (process.env.NODE_ENV !== "production") {
+    let uaData = navigator.userAgentData;
+    if (uaData && Array.isArray(uaData.brands))
+      return {
+        userAgent: uaData.brands.map(({
+          brand,
+          version: version2
+        }) => `${brand}/${version2}`).join(" "),
+        platform: uaData.platform ?? navigator.platform ?? "",
+        maxTouchPoints: navigator.maxTouchPoints ?? 0
+      };
+  }
+  return {
+    userAgent: navigator.userAgent,
+    platform: navigator.platform ?? "",
+    maxTouchPoints: navigator.maxTouchPoints ?? 0
+  };
+}
+var {
+  userAgent,
+  platform,
+  maxTouchPoints
+} = readRawData(), lowerUserAgent = userAgent.toLowerCase(), lowerPlatform = platform.toLowerCase();
+
+// ../../node_modules/@base-ui/utils/platform/os.mjs
+var ios = /^i(os$|p)/.test(lowerPlatform) || lowerPlatform === "macintel" && maxTouchPoints > 1, ANDROID_STRING = "android", android = lowerPlatform === ANDROID_STRING || lowerUserAgent.includes(ANDROID_STRING), mac = !ios && lowerPlatform.startsWith("mac"), windows = lowerPlatform.startsWith("win"), linux = !android && /^(linux|chrome os)/.test(lowerPlatform), apple = mac || ios;
+
+// ../../node_modules/@base-ui/utils/platform/engine.mjs
+var engine_exports = {};
+__export(engine_exports, {
+  blink: () => blink,
+  gecko: () => gecko,
+  webkit: () => webkit
+});
+var webkit = typeof CSS < "u" && !!CSS.supports?.("-webkit-backdrop-filter:none"), gecko = !webkit && lowerUserAgent.includes("firefox"), blink = !webkit && lowerUserAgent.includes("chrom");
+
+// ../../node_modules/@base-ui/utils/platform/screen-reader.mjs
+var screen_reader_exports = {};
+__export(screen_reader_exports, {
+  voiceOver: () => voiceOver
+});
+var voiceOver = apple;
+
+// ../../node_modules/@base-ui/utils/platform/env.mjs
+var env_exports = {};
+__export(env_exports, {
+  jsdom: () => jsdom
+});
+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
+});
+var popupOpen = "data-popup-open", pressed = "data-pressed";
+
+// ../../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/floating-ui-react/utils/element.mjs
+function isTargetInsideEnabledTrigger(target, triggerElements) {
+  if (!isElement(target))
+    return !1;
+  let targetElement = target;
+  if (triggerElements.hasElement(targetElement))
+    return !targetElement.hasAttribute(triggerDisabled);
+  for (let [, trigger] of triggerElements.entries())
+    if (contains(trigger, targetElement))
+      return !trigger.hasAttribute(triggerDisabled);
+  return !1;
+}
+function isEventTargetWithin(event, node) {
+  if (node == null)
+    return !1;
+  if ("composedPath" in event)
+    return event.composedPath().includes(node);
+  let eventAgain = event;
+  return eventAgain.target != null && node.contains(eventAgain.target);
+}
+function isRootElement(element) {
+  return element.matches("html,body");
+}
+function isTypeableElement(element) {
+  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+function isInteractiveElement(element) {
+  return closest(element, `button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),${TYPEABLE_SELECTOR}`) != null;
+}
+function isTypeableCombobox(element) {
+  return element ? element.getAttribute("role") === "combobox" && isTypeableElement(element) : !1;
+}
+function matchesFocusVisible(element) {
+  if (!element || parts_exports.env.jsdom)
+    return !0;
+  try {
+    return element.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+function getFloatingFocusElement(floatingElement) {
+  return floatingElement ? floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector(`[${FOCUSABLE_ATTRIBUTE}]`) || floatingElement : null;
+}
+
+// ../../node_modules/@base-ui/react/floating-ui-react/utils/nodes.mjs
+function getNodeChildren(nodes, id, onlyOpenChildren = !0) {
+  return nodes.filter((node) => node.parentId === id).flatMap((child) => [...!onlyOpenChildren || child.context?.open ? [child] : [], ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
+}
+function getNodeAncestors(nodes, id) {
+  let allAncestors = [], currentParentId = nodes.find((node) => node.id === id)?.parentId;
+  for (; currentParentId; ) {
+    let currentNode = nodes.find((node) => node.id === currentParentId);
+    currentParentId = currentNode?.parentId, currentNode && (allAncestors = allAncestors.concat(currentNode));
+  }
+  return allAncestors;
+}
+
+// ../../node_modules/@base-ui/react/floating-ui-react/utils/event.mjs
+function stopEvent(event) {
+  event.preventDefault(), event.stopPropagation();
+}
+function isReactEvent(event) {
+  return "nativeEvent" in event;
+}
+function isVirtualClick(event) {
+  return event.pointerType === "" && event.isTrusted ? !0 : parts_exports.os.android && event.pointerType ? event.type === "click" && event.buttons === 1 : event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+  return parts_exports.env.jsdom ? !1 : !parts_exports.os.android && event.width === 0 && event.height === 0 || // Chrome synthesizes a screen reader press (TalkBack, VoiceOver, NVDA) as a 1x1 mouse
+  // `pointerdown` with no pressure. TalkBack can report a pressed button, while desktop
+  // mouse presses can report no pressure, so only require no pressed button off Android.
+  event.type === "pointerdown" && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" && (parts_exports.os.android || event.buttons === 0) || // iOS VoiceOver returns 0.333• for width/height.
+  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
+}
+function isMouseLikePointerType(pointerType, strict) {
+  let values = ["mouse", "pen"];
+  return strict || values.push("", void 0), values.includes(pointerType);
+}
+function isClickLikeEvent(event) {
+  let type = event.type;
+  return type === "click" || type === "mousedown" || type === "keydown" || type === "keyup";
+}
+
+// ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+var sides = ["top", "right", "bottom", "left"], alignments = ["start", "end"], placements = sides.reduce((acc, side2) => acc.concat(side2, side2 + "-" + alignments[0], side2 + "-" + alignments[1]), []), min = Math.min, max = Math.max, round = Math.round, floor = Math.floor, createCoords = (v) => ({
+  x: v,
+  y: v
+}), oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value == "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+  let firstChar = placement[0];
+  return firstChar === "t" || firstChar === "b" ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  rtl === void 0 && (rtl = !1);
+  let alignment = getAlignment(placement), alignmentAxis = getAlignmentAxis(placement), length = getAxisLength(alignmentAxis), mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  return rects.reference[length] > rects.floating[length] && (mainAlignmentSide = getOppositePlacement(mainAlignmentSide)), [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  let oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
+}
+var lrPlacement = ["left", "right"], rlPlacement = ["right", "left"], tbPlacement = ["top", "bottom"], btPlacement = ["bottom", "top"];
+function getSideList(side2, isStart, rtl) {
+  switch (side2) {
+    case "top":
+    case "bottom":
+      return rtl ? isStart ? rlPlacement : lrPlacement : isStart ? lrPlacement : rlPlacement;
+    case "left":
+    case "right":
+      return isStart ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  let alignment = getAlignment(placement), list = getSideList(getSide(placement), direction === "start", rtl);
+  return alignment && (list = list.map((side2) => side2 + "-" + alignment), flipAlignment && (list = list.concat(list.map(getOppositeAlignmentPlacement)))), list;
+}
+function getOppositePlacement(placement) {
+  let side2 = getSide(placement);
+  return oppositeSideMap[side2] + placement.slice(side2.length);
+}
+function expandPaddingObject(padding) {
+  var _padding$top, _padding$right, _padding$bottom, _padding$left;
+  return {
+    top: (_padding$top = padding.top) != null ? _padding$top : 0,
+    right: (_padding$right = padding.right) != null ? _padding$right : 0,
+    bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
+    left: (_padding$left = padding.left) != null ? _padding$left : 0
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding != "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  let {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+
+// ../../node_modules/@base-ui/react/floating-ui-react/utils/composite.mjs
+function isIndexOutOfListBounds(list, index2) {
+  return index2 < 0 || index2 >= list.length;
+}
+function getMinListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef.current, {
+    disabledIndices
+  });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+  return findNonDisabledListIndex(listRef.current, {
+    decrement: !0,
+    startingIndex: listRef.current.length,
+    disabledIndices
+  });
+}
+function findNonDisabledListIndex(list, {
+  startingIndex = -1,
+  decrement = !1,
+  disabledIndices,
+  amount = 1
+} = {}) {
+  let index2 = startingIndex;
+  do
+    index2 += decrement ? -amount : amount;
+  while (index2 >= 0 && index2 <= list.length - 1 && isListIndexDisabled(list, index2, disabledIndices));
+  return index2;
+}
+function isListIndexDisabled(list, index2, disabledIndices) {
+  if (typeof disabledIndices == "function" ? disabledIndices(index2) : disabledIndices?.includes(index2) ?? !1)
+    return !0;
+  let element = list[index2];
+  return element ? !isElementVisible(element) || element.matches(":disabled") ? !0 : !disabledIndices && (element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") : !1;
+}
+function isHiddenByStyles(styles) {
+  return styles.visibility === "hidden" || styles.visibility === "collapse";
+}
+function isElementVisible(element, styles = element ? getComputedStyle2(element) : null) {
+  return !element || !element.isConnected || !styles || isHiddenByStyles(styles) ? !1 : typeof element.checkVisibility == "function" ? element.checkVisibility() : styles.display !== "none" && styles.display !== "contents";
+}
+
+// ../../node_modules/@base-ui/react/floating-ui-react/utils/tabbable.mjs
+var CANDIDATE_SELECTOR = 'a[href],button,input,select,textarea,summary,details,iframe,object,embed,[tabindex],[contenteditable]:not([contenteditable="false"]),audio[controls],video[controls]';
+function getParentElement(element) {
+  let assignedSlot = element.assignedSlot;
+  if (assignedSlot)
+    return assignedSlot;
+  if (element.parentElement)
+    return element.parentElement;
+  let rootNode = element.getRootNode();
+  return isShadowRoot(rootNode) ? rootNode.host : null;
+}
+function getDetailsSummary(details) {
+  for (let child of Array.from(details.children))
+    if (getNodeName(child) === "summary")
+      return child;
+  return null;
+}
+function isWithinOpenDetailsSummary(element, details) {
+  let summary = getDetailsSummary(details);
+  return !!summary && (element === summary || contains(summary, element));
+}
+function isFocusableCandidate(element) {
+  let nodeName = element ? getNodeName(element) : "";
+  return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== "summary" || element.parentElement != null && getNodeName(element.parentElement) === "details" && getDetailsSummary(element.parentElement) === element) && (nodeName !== "details" || getDetailsSummary(element) == null) && (nodeName !== "input" || element.type !== "hidden");
+}
+function isFocusableElement(element) {
+  if (!isFocusableCandidate(element) || !element.isConnected || element.matches(":disabled"))
+    return !1;
+  for (let current = element; current; current = getParentElement(current)) {
+    let isAncestor = current !== element, isSlot = getNodeName(current) === "slot";
+    if (current.hasAttribute("inert") || isAncestor && getNodeName(current) === "details" && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute("hidden") || !isSlot && !isVisibleInTabbableTree(current, isAncestor))
+      return !1;
+  }
+  return !0;
+}
+function isVisibleInTabbableTree(element, isAncestor) {
+  let styles = getComputedStyle2(element);
+  return isAncestor ? styles.display !== "none" : isElementVisible(element, styles);
+}
+function getTabIndex(element) {
+  let tabIndex = element.tabIndex;
+  if (tabIndex < 0) {
+    let nodeName = getNodeName(element);
+    if (nodeName === "details" || nodeName === "audio" || nodeName === "video" || isHTMLElement(element) && element.isContentEditable)
+      return 0;
+  }
+  return tabIndex;
+}
+function getNamedRadioInput(element) {
+  if (getNodeName(element) !== "input")
+    return null;
+  let input = element;
+  return input.type === "radio" && input.name !== "" ? input : null;
+}
+function isTabbableRadio(element, candidates) {
+  let input = getNamedRadioInput(element);
+  if (!input)
+    return !0;
+  let checkedRadio = candidates.find((candidate) => {
+    let radio = getNamedRadioInput(candidate);
+    return radio?.name === input.name && radio.form === input.form && radio.checked;
+  });
+  return checkedRadio ? checkedRadio === input : candidates.find((candidate) => {
+    let radio = getNamedRadioInput(candidate);
+    return radio?.name === input.name && radio.form === input.form;
+  }) === input;
+}
+function getComposedChildren(container) {
+  if (isHTMLElement(container) && getNodeName(container) === "slot") {
+    let assignedElements = container.assignedElements({
+      flatten: !0
+    });
+    if (assignedElements.length > 0)
+      return assignedElements;
+  }
+  return isHTMLElement(container) && container.shadowRoot ? Array.from(container.shadowRoot.children) : Array.from(container.children);
+}
+function appendCandidates(container, list) {
+  getComposedChildren(container).forEach((child) => {
+    isFocusableCandidate(child) && list.push(child), appendCandidates(child, list);
+  });
+}
+function appendMatchingElements(container, selector, list) {
+  getComposedChildren(container).forEach((child) => {
+    isHTMLElement(child) && child.matches(selector) && list.push(child), appendMatchingElements(child, selector, list);
+  });
+}
+function isTabbable(element) {
+  return isFocusableElement(element) && getTabIndex(element) >= 0;
+}
+function focusable(container) {
+  let candidates = [];
+  return appendCandidates(container, candidates), candidates.filter(isFocusableElement);
+}
+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;
+}
+
+// ../../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);
+  React26.useEffect(() => {
+    if (!enabled)
+      return;
+    let abortController = new AbortController();
+    return runOnceAnimationsFinish(onComplete, abortController.signal), () => {
+      abortController.abort();
+    };
+  }, [enabled, open2, onComplete, runOnceAnimationsFinish]);
+}
+
+// ../../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
+  };
+}
+
+// ../../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
+  });
+  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
+var ARROW_UP2 = "ArrowUp", ARROW_DOWN2 = "ArrowDown", ARROW_LEFT2 = "ArrowLeft", ARROW_RIGHT2 = "ArrowRight", HOME = "Home", END = "End";
+var COMPOSITE_KEYS = /* @__PURE__ */ new Set([ARROW_UP2, ARROW_DOWN2, ARROW_LEFT2, ARROW_RIGHT2, HOME, END]), SHIFT = "Shift", MODIFIER_KEYS = [SHIFT, "Control", "Alt", "Meta"];
+function isInputElement(element) {
+  return isHTMLElement(element) && element.tagName === "INPUT";
+}
+function isNativeInput(element) {
+  return !!(isInputElement(element) && element.selectionStart != null || isHTMLElement(element) && element.tagName === "TEXTAREA");
+}
+function scrollIntoViewIfNeeded(scrollContainer, element, direction, orientation) {
+  if (!scrollContainer || !element || !element.scrollTo)
+    return;
+  let targetX = scrollContainer.scrollLeft, targetY = scrollContainer.scrollTop, isOverflowingX = scrollContainer.clientWidth < scrollContainer.scrollWidth, isOverflowingY = scrollContainer.clientHeight < scrollContainer.scrollHeight;
+  if (isOverflowingX && orientation !== "vertical") {
+    let elementOffsetLeft = getOffset(scrollContainer, element, "left"), containerStyles = getStyles(scrollContainer), elementStyles = getStyles(element);
+    direction === "ltr" && (elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight > scrollContainer.scrollLeft + scrollContainer.clientWidth - containerStyles.scrollPaddingRight ? targetX = elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight - scrollContainer.clientWidth + containerStyles.scrollPaddingRight : elementOffsetLeft - elementStyles.scrollMarginLeft < scrollContainer.scrollLeft + containerStyles.scrollPaddingLeft && (targetX = elementOffsetLeft - elementStyles.scrollMarginLeft - containerStyles.scrollPaddingLeft)), direction === "rtl" && (elementOffsetLeft - elementStyles.scrollMarginLeft < scrollContainer.scrollLeft + containerStyles.scrollPaddingLeft ? targetX = elementOffsetLeft - elementStyles.scrollMarginLeft - containerStyles.scrollPaddingLeft : elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight > scrollContainer.scrollLeft + scrollContainer.clientWidth - containerStyles.scrollPaddingRight && (targetX = elementOffsetLeft + element.offsetWidth + elementStyles.scrollMarginRight - scrollContainer.clientWidth + containerStyles.scrollPaddingRight));
+  }
+  if (isOverflowingY && orientation !== "horizontal") {
+    let elementOffsetTop = getOffset(scrollContainer, element, "top"), containerStyles = getStyles(scrollContainer), elementStyles = getStyles(element);
+    elementOffsetTop - elementStyles.scrollMarginTop < scrollContainer.scrollTop + containerStyles.scrollPaddingTop ? targetY = elementOffsetTop - elementStyles.scrollMarginTop - containerStyles.scrollPaddingTop : elementOffsetTop + element.offsetHeight + elementStyles.scrollMarginBottom > scrollContainer.scrollTop + scrollContainer.clientHeight - containerStyles.scrollPaddingBottom && (targetY = elementOffsetTop + element.offsetHeight + elementStyles.scrollMarginBottom - scrollContainer.clientHeight + containerStyles.scrollPaddingBottom);
+  }
+  scrollContainer.scrollTo({
+    left: targetX,
+    top: targetY,
+    behavior: "auto"
+  });
+}
+function getOffset(ancestor, element, side2) {
+  let propName = side2 === "left" ? "offsetLeft" : "offsetTop", result = 0;
+  for (; element.offsetParent && (result += element[propName], element.offsetParent !== ancestor); )
+    element = element.offsetParent;
+  return result;
+}
+function getStyles(element) {
+  let styles = getComputedStyle(element);
+  return {
+    scrollMarginTop: parseFloat(styles.scrollMarginTop) || 0,
+    scrollMarginRight: parseFloat(styles.scrollMarginRight) || 0,
+    scrollMarginBottom: parseFloat(styles.scrollMarginBottom) || 0,
+    scrollMarginLeft: parseFloat(styles.scrollMarginLeft) || 0,
+    scrollPaddingTop: parseFloat(styles.scrollPaddingTop) || 0,
+    scrollPaddingRight: parseFloat(styles.scrollPaddingRight) || 0,
+    scrollPaddingBottom: parseFloat(styles.scrollPaddingBottom) || 0,
+    scrollPaddingLeft: parseFloat(styles.scrollPaddingLeft) || 0
+  };
+}
+
+// ../../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
+      });
+      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_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
+  };
+}
+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";
+}
+
+// ../../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/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_OBJECT,
+  useOnMount,
+  formatErrorMessage_default,
+  useMergedRefs,
+  isReactVersionAtLeast,
+  mergeProps,
+  useRenderElement,
+  useForcedRerendering,
+  useId,
+  useBaseUiId,
+  getNodeName,
+  getWindow,
+  getDocumentElement,
+  isNode,
+  isElement,
+  isHTMLElement,
+  isShadowRoot,
+  isOverflowElement,
+  isTableElement,
+  isTopLayer,
+  isContainingBlock,
+  getContainingBlock,
+  isWebKit,
+  isLastTraversableNode,
+  getComputedStyle2 as getComputedStyle,
+  getNodeScroll,
+  getParentNode,
+  getOverflowAncestors,
+  getFrameElement,
+  parts_exports,
+  activeElement,
+  contains,
+  closest,
+  getTarget,
+  FOCUSABLE_ATTRIBUTE,
+  transitionStatusMapping,
+  CommonPopupDataAttributes_exports,
+  CommonTriggerDataAttributes_exports,
+  triggerOpenStateMapping,
+  pressableTriggerOpenStateMapping,
+  popupStateMapping,
+  popupTransitionStateMapping,
+  triggerDisabled,
+  isTargetInsideEnabledTrigger,
+  isEventTargetWithin,
+  isRootElement,
+  isTypeableElement,
+  isInteractiveElement,
+  isTypeableCombobox,
+  matchesFocusVisible,
+  getFloatingFocusElement,
+  getNodeChildren,
+  getNodeAncestors,
+  stopEvent,
+  isReactEvent,
+  isVirtualClick,
+  isVirtualPointerEvent,
+  isMouseLikePointerType,
+  isClickLikeEvent,
+  min,
+  max,
+  round,
+  floor,
+  createCoords,
+  clamp,
+  evaluate,
+  getSide,
+  getAlignment,
+  getOppositeAxis,
+  getAxisLength,
+  getSideAxis,
+  getAlignmentAxis,
+  getAlignmentSides,
+  getExpandedPlacements,
+  getOppositeAxisPlacements,
+  getOppositePlacement,
+  getPaddingObject,
+  rectToClientRect,
+  isElementVisible,
+  ownerDocument,
+  isTabbable,
+  focusable,
+  tabbable,
+  getNextTabbable,
+  getPreviousTabbable,
+  getTabbableNearElement,
+  isOutsideEvent,
+  disableFocusInside,
+  enableFocusInside,
+  useCSPContext,
+  useIsoLayoutEffect,
+  DirectionContext,
+  useDirection,
+  getFiniteAnimations,
+  createChangeEventDetails,
+  reason_parts_exports,
+  AnimationFrame,
+  useAnimationFrame,
+  resolveRef,
+  useTransitionStatus,
+  useAnimationsFinished,
+  useOpenChangeComplete,
+  inertValue,
+  getCssDimensions,
+  useButton,
+  COMPOSITE_KEYS,
+  index_parts_exports
+};