@tscircuit/3d-viewer 0.0.577 → 0.0.578

package/dist/index.js

@@ -13721,23 +13721,23 @@ var require_src = __commonJS({
 var require_dist = __commonJS({
   "node_modules/jscad-planner/dist/index.cjs"(exports, module) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
+    var __defProp25 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames2 = Object.getOwnPropertyNames;
     var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp25(target, name, { get: all[name], enumerable: true });
     };
     var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
         for (let key of __getOwnPropNames2(from))
           if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+            __defProp25(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS = (mod) => __copyProps2(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS = (mod) => __copyProps2(__defProp25({}, "__esModule", { value: true }), mod);
     var lib_exports = {};
     __export2(lib_exports, {
       executeJscadOperations: () => executeJscadOperations3,
@@ -14432,7 +14432,7 @@ var require_browser = __commonJS({
 });
 
 // src/CadViewer.tsx
-import { useState as useState39, useCallback as useCallback25, useRef as useRef28, useEffect as useEffect48 } from "react";
+import { useState as useState39, useCallback as useCallback25, useRef as useRef29, useEffect as useEffect48 } from "react";
 import * as THREE46 from "three";
 
 // src/CadViewerJscad.tsx
@@ -32710,7 +32710,7 @@ import * as THREE21 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.576",
+  version: "0.0.577",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -33692,16 +33692,11 @@ function computePointInFront(rotationVector, distance5) {
 var OrientationCubeCanvas = () => {
   const { mainCameraRef } = useCameraController();
   const containerRef = useRef7(null);
-  const canvasRef = useRef7(null);
-  const rendererRef = useRef7(null);
-  const sceneRef = useRef7(null);
-  const cameraRef = useRef7(null);
-  const animationFrameRef = useRef7(null);
   useEffect18(() => {
     if (!containerRef.current) return;
+    const container = containerRef.current;
     const canvas = document.createElement("canvas");
-    canvasRef.current = canvas;
-    containerRef.current.appendChild(canvas);
+    container.appendChild(canvas);
     const renderer = new THREE20.WebGLRenderer({
       canvas,
       antialias: true,
@@ -33709,12 +33704,9 @@ var OrientationCubeCanvas = () => {
     });
     renderer.setSize(120, 120);
     renderer.setPixelRatio(window.devicePixelRatio);
-    rendererRef.current = renderer;
     const scene = new THREE20.Scene();
-    sceneRef.current = scene;
     const camera = new THREE20.PerspectiveCamera(75, 1, 0.1, 1e3);
     camera.up.set(0, 0, 1);
-    cameraRef.current = camera;
     const ambientLight = new THREE20.AmbientLight(16777215, Math.PI / 2);
     scene.add(ambientLight);
     const group = new THREE20.Group();
@@ -33780,6 +33772,7 @@ var OrientationCubeCanvas = () => {
     group.add(leftText);
     group.add(topText);
     group.add(bottomText);
+    let animationFrameId = null;
     const animate = () => {
       if (mainCameraRef.current) {
         const cameraPosition = computePointInFront(
@@ -33792,12 +33785,13 @@ var OrientationCubeCanvas = () => {
         }
       }
       renderer.render(scene, camera);
-      animationFrameRef.current = requestAnimationFrame(animate);
+      animationFrameId = requestAnimationFrame(animate);
     };
     animate();
     return () => {
-      if (animationFrameRef.current) {
-        cancelAnimationFrame(animationFrameRef.current);
+      canvas.remove();
+      if (animationFrameId !== null) {
+        cancelAnimationFrame(animationFrameId);
       }
       frontText.dispose();
       backText.dispose();
@@ -33812,9 +33806,6 @@ var OrientationCubeCanvas = () => {
       scene.clear();
       renderer.dispose();
       renderer.forceContextLoss();
-      if (canvasRef.current && containerRef.current) {
-        containerRef.current.removeChild(canvasRef.current);
-      }
     };
   }, [mainCameraRef]);
   return /* @__PURE__ */ jsx14(
@@ -40022,18 +40013,61 @@ import { useState as useState37 } from "react";
 import * as React44 from "react";
 
 // node_modules/@radix-ui/primitive/dist/index.mjs
+var __defProp3 = Object.defineProperty;
+var __name = (target, value) => __defProp3(target, "name", { value, configurable: true });
 var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
 function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
-  return function handleEvent(event) {
+  return /* @__PURE__ */ __name(function handleEvent(event) {
     originalEventHandler?.(event);
     if (checkForDefaultPrevented === false || !event || !event.defaultPrevented) {
       return ourEventHandler?.(event);
     }
-  };
+  }, "handleEvent");
+}
+__name(composeEventHandlers, "composeEventHandlers");
+function getOwnerWindow(element) {
+  if (!canUseDOM) {
+    throw new Error("Cannot access window outside of the DOM");
+  }
+  return element?.ownerDocument?.defaultView ?? window;
 }
+__name(getOwnerWindow, "getOwnerWindow");
+function getOwnerDocument(element) {
+  if (!canUseDOM) {
+    throw new Error("Cannot access document outside of the DOM");
+  }
+  return element?.ownerDocument ?? document;
+}
+__name(getOwnerDocument, "getOwnerDocument");
+function getActiveElement(node, activeDescendant = false) {
+  const { activeElement } = getOwnerDocument(node);
+  if (!activeElement?.nodeName) {
+    return null;
+  }
+  if (isFrame(activeElement) && activeElement.contentDocument) {
+    return getActiveElement(activeElement.contentDocument.body, activeDescendant);
+  }
+  if (activeDescendant) {
+    const id = activeElement.getAttribute("aria-activedescendant");
+    if (id) {
+      const element = getOwnerDocument(activeElement).getElementById(id);
+      if (element) {
+        return element;
+      }
+    }
+  }
+  return activeElement;
+}
+__name(getActiveElement, "getActiveElement");
+function isFrame(element) {
+  return element.tagName === "IFRAME";
+}
+__name(isFrame, "isFrame");
 
 // node_modules/@radix-ui/react-compose-refs/dist/index.mjs
 import * as React13 from "react";
+var __defProp4 = Object.defineProperty;
+var __name2 = (target, value) => __defProp4(target, "name", { value, configurable: true });
 function setRef(ref, value) {
   if (typeof ref === "function") {
     return ref(value);
@@ -40041,6 +40075,7 @@ function setRef(ref, value) {
     ref.current = value;
   }
 }
+__name2(setRef, "setRef");
 function composeRefs(...refs) {
   return (node) => {
     let hasCleanup = false;
@@ -40065,13 +40100,40 @@ function composeRefs(...refs) {
     }
   };
 }
+__name2(composeRefs, "composeRefs");
 function useComposedRefs(...refs) {
   return React13.useCallback(composeRefs(...refs), refs);
 }
+__name2(useComposedRefs, "useComposedRefs");
 
 // node_modules/@radix-ui/react-context/dist/index.mjs
 import * as React14 from "react";
 import { jsx as jsx21 } from "react/jsx-runtime";
+var __defProp5 = Object.defineProperty;
+var __name3 = (target, value) => __defProp5(target, "name", { value, configurable: true });
+// @__NO_SIDE_EFFECTS__
+function createContext22(rootComponentName, defaultContext) {
+  const Context = React14.createContext(defaultContext);
+  Context.displayName = rootComponentName + "Context";
+  const Provider = /* @__PURE__ */ __name3((props) => {
+    const { children, ...context } = props;
+    const value = React14.useMemo(() => context, Object.values(context));
+    return /* @__PURE__ */ jsx21(Context.Provider, { value, children });
+  }, "Provider");
+  Provider.displayName = rootComponentName + "Provider";
+  function useContext22(consumerName, options = {}) {
+    const { optional = false } = options;
+    const context = React14.useContext(Context);
+    if (context) return context;
+    if (defaultContext !== void 0) return defaultContext;
+    if (optional) return void 0;
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+  }
+  __name3(useContext22, "useContext");
+  return [Provider, useContext22];
+}
+__name3(createContext22, "createContext");
+// @__NO_SIDE_EFFECTS__
 function createContextScope(scopeName, createContextScopeDeps = []) {
   let defaultContexts = [];
   function createContext32(rootComponentName, defaultContext) {
@@ -40079,12 +40141,12 @@ function createContextScope(scopeName, createContextScopeDeps = []) {
     BaseContext.displayName = rootComponentName + "Context";
     const index2 = defaultContexts.length;
     defaultContexts = [...defaultContexts, defaultContext];
-    const Provider = (props) => {
+    const Provider = /* @__PURE__ */ __name3((props) => {
       const { scope, children, ...context } = props;
       const Context = scope?.[scopeName]?.[index2] || BaseContext;
       const value = React14.useMemo(() => context, Object.values(context));
       return /* @__PURE__ */ jsx21(Context.Provider, { value, children });
-    };
+    }, "Provider");
     Provider.displayName = rootComponentName + "Provider";
     function useContext22(consumerName, scope, options = {}) {
       const { optional = false } = options;
@@ -40095,46 +40157,53 @@ function createContextScope(scopeName, createContextScopeDeps = []) {
       if (optional) return void 0;
       throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
     }
+    __name3(useContext22, "useContext");
     return [Provider, useContext22];
   }
-  const createScope = () => {
+  __name3(createContext32, "createContext");
+  const createScope = /* @__PURE__ */ __name3(() => {
     const scopeContexts = defaultContexts.map((defaultContext) => {
       return React14.createContext(defaultContext);
     });
-    return function useScope(scope) {
+    return /* @__PURE__ */ __name3(function useScope(scope) {
       const contexts = scope?.[scopeName] || scopeContexts;
       return React14.useMemo(
         () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
         [scope, contexts]
       );
-    };
-  };
+    }, "useScope");
+  }, "createScope");
   createScope.scopeName = scopeName;
   return [createContext32, composeContextScopes(createScope, ...createContextScopeDeps)];
 }
+__name3(createContextScope, "createContextScope");
 function composeContextScopes(...scopes) {
   const baseScope = scopes[0];
   if (scopes.length === 1) return baseScope;
-  const createScope = () => {
+  const createScope = /* @__PURE__ */ __name3(() => {
     const scopeHooks = scopes.map((createScope2) => ({
       useScope: createScope2(),
       scopeName: createScope2.scopeName
     }));
-    return function useComposedScopes(overrideScopes) {
+    return /* @__PURE__ */ __name3(function useComposedScopes(overrideScopes) {
       const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
         const scopeProps = useScope(overrideScopes);
         const currentScope = scopeProps[`__scope${scopeName}`];
         return { ...nextScopes2, ...currentScope };
       }, {});
       return React14.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
-    };
-  };
+    }, "useComposedScopes");
+  }, "createScope");
   createScope.scopeName = baseScope.scopeName;
   return createScope;
 }
+__name3(composeContextScopes, "composeContextScopes");
 
 // node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
-import * as React16 from "react";
+import * as React17 from "react";
+
+// node_modules/@radix-ui/primitive/dist/internal/is-development.false.mjs
+var IS_DEVELOPMENT = false;
 
 // node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
 import * as React15 from "react";
@@ -40143,12 +40212,42 @@ var useLayoutEffect2 = globalThis?.document ? React15.useLayoutEffect : () => {
 
 // node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
 import * as React22 from "react";
-var useInsertionEffect = React16[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
+
+// node_modules/@radix-ui/react-use-effect-event/dist/index.mjs
+import * as React16 from "react";
+var __defProp6 = Object.defineProperty;
+var __name4 = (target, value) => __defProp6(target, "name", { value, configurable: true });
+var useReactEffectEvent = React16[" useEffectEvent ".trim().toString()];
+var useReactInsertionEffect = React16[" useInsertionEffect ".trim().toString()];
+function useEffectEvent(callback) {
+  if (typeof useReactEffectEvent === "function") {
+    return useReactEffectEvent(callback);
+  }
+  const ref = React16.useRef(() => {
+    throw new Error("Cannot call an event handler while rendering.");
+  });
+  if (typeof useReactInsertionEffect === "function") {
+    useReactInsertionEffect(() => {
+      ref.current = callback;
+    });
+  } else {
+    useLayoutEffect2(() => {
+      ref.current = callback;
+    });
+  }
+  return React16.useMemo(() => ((...args) => ref.current?.(...args)), []);
+}
+__name4(useEffectEvent, "useEffectEvent");
+
+// node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
+var __defProp7 = Object.defineProperty;
+var __name5 = (target, value) => __defProp7(target, "name", { value, configurable: true });
+var useInsertionEffect = React17[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
 function useControllableState({
   prop,
   defaultProp,
-  onChange = () => {
-  },
+  onChange = /* @__PURE__ */ __name5(() => {
+  }, "onChange"),
   caller
 }) {
   const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
@@ -40157,9 +40256,9 @@ function useControllableState({
   });
   const isControlled = prop !== void 0;
   const value = isControlled ? prop : uncontrolledProp;
-  if (true) {
-    const isControlledRef = React16.useRef(prop !== void 0);
-    React16.useEffect(() => {
+  if (IS_DEVELOPMENT) {
+    const isControlledRef = React17.useRef(prop !== void 0);
+    React17.useEffect(() => {
       const wasControlled = isControlledRef.current;
       if (wasControlled !== isControlled) {
         const from = wasControlled ? "controlled" : "uncontrolled";
@@ -40171,7 +40270,7 @@ function useControllableState({
       isControlledRef.current = isControlled;
     }, [isControlled, caller]);
   }
-  const setValue = React16.useCallback(
+  const setValue = React17.useCallback(
     (nextValue) => {
       if (isControlled) {
         const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
@@ -40186,17 +40285,18 @@ function useControllableState({
   );
   return [value, setValue];
 }
+__name5(useControllableState, "useControllableState");
 function useUncontrolledState({
   defaultProp,
   onChange
 }) {
-  const [value, setValue] = React16.useState(defaultProp);
-  const prevValueRef = React16.useRef(value);
-  const onChangeRef = React16.useRef(onChange);
+  const [value, setValue] = React17.useState(defaultProp);
+  const prevValueRef = React17.useRef(value);
+  const onChangeRef = React17.useRef(onChange);
   useInsertionEffect(() => {
     onChangeRef.current = onChange;
   }, [onChange]);
-  React16.useEffect(() => {
+  React17.useEffect(() => {
     if (prevValueRef.current !== value) {
       onChangeRef.current?.(value);
       prevValueRef.current = value;
@@ -40204,27 +40304,147 @@ function useUncontrolledState({
   }, [value, prevValueRef]);
   return [value, setValue, onChangeRef];
 }
+__name5(useUncontrolledState, "useUncontrolledState");
 function isFunction(value) {
   return typeof value === "function";
 }
+__name5(isFunction, "isFunction");
+var SYNC_STATE = /* @__PURE__ */ Symbol("RADIX:SYNC_STATE");
+function useControllableStateReducer(reducer, userArgs, initialArg, init) {
+  const { prop: controlledState, defaultProp, onChange: onChangeProp, caller } = userArgs;
+  const isControlled = controlledState !== void 0;
+  const onChange = useEffectEvent(onChangeProp);
+  if (IS_DEVELOPMENT) {
+    const isControlledRef = React22.useRef(controlledState !== void 0);
+    React22.useEffect(() => {
+      const wasControlled = isControlledRef.current;
+      if (wasControlled !== isControlled) {
+        const from = wasControlled ? "controlled" : "uncontrolled";
+        const to = isControlled ? "controlled" : "uncontrolled";
+        console.warn(
+          `${caller} is changing from ${from} to ${to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+        );
+      }
+      isControlledRef.current = isControlled;
+    }, [isControlled, caller]);
+  }
+  const args = [{ ...initialArg, state: defaultProp }];
+  if (init) {
+    args.push(init);
+  }
+  const [internalState, dispatch] = React22.useReducer(
+    (state2, action) => {
+      if (action.type === SYNC_STATE) {
+        return { ...state2, state: action.state };
+      }
+      const next = reducer(state2, action);
+      if (isControlled && !Object.is(next.state, state2.state)) {
+        onChange(next.state);
+      }
+      return next;
+    },
+    ...args
+  );
+  const uncontrolledState = internalState.state;
+  const prevValueRef = React22.useRef(uncontrolledState);
+  React22.useEffect(() => {
+    if (prevValueRef.current !== uncontrolledState) {
+      prevValueRef.current = uncontrolledState;
+      if (!isControlled) {
+        onChange(uncontrolledState);
+      }
+    }
+  }, [uncontrolledState, prevValueRef, isControlled]);
+  const state = React22.useMemo(() => {
+    const isControlled2 = controlledState !== void 0;
+    if (isControlled2) {
+      return { ...internalState, state: controlledState };
+    }
+    return internalState;
+  }, [internalState, controlledState]);
+  React22.useEffect(() => {
+    if (isControlled && !Object.is(controlledState, internalState.state)) {
+      dispatch({ type: SYNC_STATE, state: controlledState });
+    }
+  }, [controlledState, internalState.state, isControlled]);
+  return [state, dispatch];
+}
+__name5(useControllableStateReducer, "useControllableStateReducer");
 
 // node_modules/@radix-ui/react-primitive/dist/index.mjs
-import * as React18 from "react";
+import * as React19 from "react";
 import * as ReactDOM2 from "react-dom";
 
 // node_modules/@radix-ui/react-slot/dist/index.mjs
-import * as React17 from "react";
+import * as React18 from "react";
+import { jsx as jsx22 } from "react/jsx-runtime";
+var __defProp8 = Object.defineProperty;
+var __name6 = (target, value) => __defProp8(target, "name", { value, configurable: true });
+var mergeProps = /* @__PURE__ */ __name6(((slotProps, childProps) => {
+  const overrideProps = { ...childProps };
+  for (const propName in childProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        const slotIsFunction = typeof slotPropValue === "function";
+        const childIsFunction = typeof childPropValue === "function";
+        if (IS_DEVELOPMENT) {
+          if (!slotIsFunction || !childIsFunction) {
+            console.warn(
+              `Slot: Expected a function for ${propName}, but received ${[typeof slotPropValue, typeof childPropValue].filter((v) => v !== "function").join(" and ")}.`
+            );
+          }
+        }
+        overrideProps[propName] = (...args) => {
+          const result = childIsFunction ? childPropValue(...args) : void 0;
+          if (slotIsFunction) {
+            slotPropValue(...args);
+          }
+          return result;
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = {
+        ...typeof slotPropValue === "object" ? slotPropValue : null,
+        ...typeof childPropValue === "object" ? childPropValue : null
+      };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    } else if (propName === "aria-describedby") {
+      overrideProps[propName] = concatAriaDescribedby(childPropValue, slotPropValue);
+    }
+  }
+  return { ...slotProps, ...overrideProps };
+}), "mergeProps");
+function concatAriaDescribedby(...values) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    for (const id of String(value).trim().split(/\s+/)) {
+      if (id) ids.add(id);
+    }
+  }
+  return ids.size > 0 ? Array.from(ids).join(" ") : void 0;
+}
+__name6(concatAriaDescribedby, "concatAriaDescribedby");
+var SlotContext = React18.createContext(mergeProps);
+SlotContext.displayName = "SlotContext";
 // @__NO_SIDE_EFFECTS__
 function createSlot(ownerName) {
-  const Slot2 = React17.forwardRef((props, forwardedRef) => {
-    let { children, ...slotProps } = props;
+  const Slot2 = React18.forwardRef((props, forwardedRef) => {
+    const context = React18.useContext(SlotContext);
+    let { children, mergeProps: mergePropsProp = context, ...slotProps } = props;
     let slottableElement = null;
     let hasSlottable = false;
     const newChildren = [];
     if (isLazyComponent(children) && typeof use === "function") {
       children = use(children._payload);
     }
-    React17.Children.forEach(children, (maybeSlottable) => {
+    React18.Children.forEach(children, (maybeSlottable) => {
       if (isSlottable(maybeSlottable)) {
         hasSlottable = true;
         const slottable = maybeSlottable;
@@ -40239,13 +40459,13 @@ function createSlot(ownerName) {
       }
     });
     if (slottableElement) {
-      slottableElement = React17.cloneElement(slottableElement, void 0, newChildren);
+      slottableElement = React18.cloneElement(slottableElement, void 0, newChildren);
     } else if (
       // A `Slottable` was found but it didn't resolve to a single element (e.g.
       // it wrapped multiple elements, text, or a render-prop `child` that
       // wasn't an element). Don't fall back to treating the `Slottable` wrapper
       // itself as the slot target — throw a descriptive error below instead.
-      !hasSlottable && React17.Children.count(children) === 1 && React17.isValidElement(children)
+      !hasSlottable && React18.Children.count(children) === 1 && React18.isValidElement(children)
     ) {
       slottableElement = children;
     }
@@ -40259,48 +40479,36 @@ function createSlot(ownerName) {
       }
       return children;
     }
-    const mergedProps = mergeProps(slotProps, slottableElement.props ?? {});
-    if (slottableElement.type !== React17.Fragment) {
+    const mergedProps = mergePropsProp(
+      slotProps,
+      slottableElement.props ?? {}
+    );
+    if (slottableElement.type !== React18.Fragment) {
       mergedProps.ref = forwardedRef ? composedRef : slottableElementRef;
     }
-    return React17.cloneElement(slottableElement, mergedProps);
+    return React18.cloneElement(slottableElement, mergedProps);
   });
   Slot2.displayName = `${ownerName}.Slot`;
   return Slot2;
 }
+__name6(createSlot, "createSlot");
 var SLOTTABLE_IDENTIFIER = /* @__PURE__ */ Symbol.for("radix.slottable");
-var getSlottableElementFromSlottable = (slottable, child) => {
+// @__NO_SIDE_EFFECTS__
+function createSlottable(ownerName) {
+  const Slottable2 = /* @__PURE__ */ __name6((props) => "child" in props ? props.children(props.child) : props.children, "Slottable");
+  Slottable2.displayName = `${ownerName}.Slottable`;
+  Slottable2.__radixId = SLOTTABLE_IDENTIFIER;
+  return Slottable2;
+}
+__name6(createSlottable, "createSlottable");
+var getSlottableElementFromSlottable = /* @__PURE__ */ __name6((slottable, child) => {
   if ("child" in slottable.props) {
     const child2 = slottable.props.child;
-    if (!React17.isValidElement(child2)) return null;
-    return React17.cloneElement(child2, void 0, slottable.props.children(child2.props.children));
-  }
-  return React17.isValidElement(child) ? child : null;
-};
-function mergeProps(slotProps, childProps) {
-  const overrideProps = { ...childProps };
-  for (const propName in childProps) {
-    const slotPropValue = slotProps[propName];
-    const childPropValue = childProps[propName];
-    const isHandler = /^on[A-Z]/.test(propName);
-    if (isHandler) {
-      if (slotPropValue && childPropValue) {
-        overrideProps[propName] = (...args) => {
-          const result = childPropValue(...args);
-          slotPropValue(...args);
-          return result;
-        };
-      } else if (slotPropValue) {
-        overrideProps[propName] = slotPropValue;
-      }
-    } else if (propName === "style") {
-      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
-    } else if (propName === "className") {
-      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
-    }
+    if (!React18.isValidElement(child2)) return null;
+    return React18.cloneElement(child2, void 0, slottable.props.children(child2.props.children));
   }
-  return { ...slotProps, ...overrideProps };
-}
+  return React18.isValidElement(child) ? child : null;
+}, "getSlottableElementFromSlottable");
 function getElementRef(element) {
   let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
   let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
@@ -40314,26 +40522,32 @@ function getElementRef(element) {
   }
   return element.props.ref || element.ref;
 }
+__name6(getElementRef, "getElementRef");
 function isSlottable(child) {
-  return React17.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
+  return React18.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
 }
+__name6(isSlottable, "isSlottable");
 var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
 function isLazyComponent(element) {
   return element != null && typeof element === "object" && "$$typeof" in element && element.$$typeof === REACT_LAZY_TYPE && "_payload" in element && isPromiseLike(element._payload);
 }
+__name6(isLazyComponent, "isLazyComponent");
 function isPromiseLike(value) {
   return typeof value === "object" && value !== null && "then" in value;
 }
-var createSlotError = (ownerName) => {
+__name6(isPromiseLike, "isPromiseLike");
+var createSlotError = /* @__PURE__ */ __name6((ownerName) => {
   return `${ownerName} failed to slot onto its children. Expected a single React element child or \`Slottable\`.`;
-};
-var createSlottableError = (ownerName) => {
+}, "createSlotError");
+var createSlottableError = /* @__PURE__ */ __name6((ownerName) => {
   return `${ownerName} failed to slot onto its \`Slottable\`. Expected \`Slottable\` to receive a single React element child.`;
-};
-var use = React17[" use ".trim().toString()];
+}, "createSlottableError");
+var use = React18[" use ".trim().toString()];
 
 // node_modules/@radix-ui/react-primitive/dist/index.mjs
-import { jsx as jsx22 } from "react/jsx-runtime";
+import { jsx as jsx23 } from "react/jsx-runtime";
+var __defProp9 = Object.defineProperty;
+var __name7 = (target, value) => __defProp9(target, "name", { value, configurable: true });
 var NODES = [
   "a",
   "button",
@@ -40355,13 +40569,13 @@ var NODES = [
 ];
 var Primitive = NODES.reduce((primitive, node) => {
   const Slot2 = createSlot(`Primitive.${node}`);
-  const Node2 = React18.forwardRef((props, forwardedRef) => {
+  const Node2 = React19.forwardRef((props, forwardedRef) => {
     const { asChild, ...primitiveProps } = props;
     const Comp = asChild ? Slot2 : node;
     if (typeof window !== "undefined") {
       window[/* @__PURE__ */ Symbol.for("radix-ui")] = true;
     }
-    return /* @__PURE__ */ jsx22(Comp, { ...primitiveProps, ref: forwardedRef });
+    return /* @__PURE__ */ jsx23(Comp, { ...primitiveProps, ref: forwardedRef });
   });
   Node2.displayName = `Primitive.${node}`;
   return { ...primitive, [node]: Node2 };
@@ -40369,15 +40583,19 @@ var Primitive = NODES.reduce((primitive, node) => {
 function dispatchDiscreteCustomEvent(target, event) {
   if (target) ReactDOM2.flushSync(() => target.dispatchEvent(event));
 }
+__name7(dispatchDiscreteCustomEvent, "dispatchDiscreteCustomEvent");
 
 // node_modules/@radix-ui/react-menu/dist/index.mjs
 import * as React43 from "react";
 
 // node_modules/@radix-ui/react-collection/dist/index.mjs
-import * as React19 from "react";
-import { jsx as jsx23 } from "react/jsx-runtime";
-import * as React23 from "react";
+import * as React20 from "react";
 import { jsx as jsx24 } from "react/jsx-runtime";
+import * as React23 from "react";
+import { jsx as jsx25 } from "react/jsx-runtime";
+var __defProp10 = Object.defineProperty;
+var __name8 = (target, value) => __defProp10(target, "name", { value, configurable: true });
+// @__NO_SIDE_EFFECTS__
 function createCollection(name) {
   const PROVIDER_NAME = name + "CollectionProvider";
   const [createCollectionContext, createCollectionScope3] = createContextScope(PROVIDER_NAME);
@@ -40385,44 +40603,44 @@ function createCollection(name) {
     PROVIDER_NAME,
     { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
   );
-  const CollectionProvider = (props) => {
+  const CollectionProvider = /* @__PURE__ */ __name8((props) => {
     const { scope, children } = props;
-    const ref = React19.useRef(null);
-    const itemMap = React19.useRef(/* @__PURE__ */ new Map()).current;
-    return /* @__PURE__ */ jsx23(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
-  };
+    const ref = React20.useRef(null);
+    const itemMap = React20.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ jsx24(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
+  }, "CollectionProvider");
   CollectionProvider.displayName = PROVIDER_NAME;
   const COLLECTION_SLOT_NAME = name + "CollectionSlot";
   const CollectionSlotImpl = createSlot(COLLECTION_SLOT_NAME);
-  const CollectionSlot = React19.forwardRef(
+  const CollectionSlot = React20.forwardRef(
     (props, forwardedRef) => {
       const { scope, children } = props;
       const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
       const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
-      return /* @__PURE__ */ jsx23(CollectionSlotImpl, { ref: composedRefs, children });
+      return /* @__PURE__ */ jsx24(CollectionSlotImpl, { ref: composedRefs, children });
     }
   );
   CollectionSlot.displayName = COLLECTION_SLOT_NAME;
   const ITEM_SLOT_NAME = name + "CollectionItemSlot";
   const ITEM_DATA_ATTR = "data-radix-collection-item";
   const CollectionItemSlotImpl = createSlot(ITEM_SLOT_NAME);
-  const CollectionItemSlot = React19.forwardRef(
+  const CollectionItemSlot = React20.forwardRef(
     (props, forwardedRef) => {
       const { scope, children, ...itemData } = props;
-      const ref = React19.useRef(null);
+      const ref = React20.useRef(null);
       const composedRefs = useComposedRefs(forwardedRef, ref);
       const context = useCollectionContext(ITEM_SLOT_NAME, scope);
-      React19.useEffect(() => {
+      React20.useEffect(() => {
         context.itemMap.set(ref, { ref, ...itemData });
         return () => void context.itemMap.delete(ref);
       });
-      return /* @__PURE__ */ jsx23(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children });
+      return /* @__PURE__ */ jsx24(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children });
     }
   );
   CollectionItemSlot.displayName = ITEM_SLOT_NAME;
   function useCollection3(scope) {
     const context = useCollectionContext(name + "CollectionConsumer", scope);
-    const getItems = React19.useCallback(() => {
+    const getItems = React20.useCallback(() => {
       const collectionNode = context.collectionRef.current;
       if (!collectionNode) return [];
       const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
@@ -40434,43 +40652,525 @@ function createCollection(name) {
     }, [context.collectionRef, context.itemMap]);
     return getItems;
   }
+  __name8(useCollection3, "useCollection");
   return [
     { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },
     useCollection3,
     createCollectionScope3
   ];
 }
+__name8(createCollection, "createCollection");
+var __instanciated = /* @__PURE__ */ new WeakMap();
+var OrderedDict = class _OrderedDict extends Map {
+  static {
+    __name8(this, "OrderedDict");
+  }
+  #keys;
+  constructor(entries) {
+    super(entries);
+    this.#keys = [...super.keys()];
+    __instanciated.set(this, true);
+  }
+  set(key, value) {
+    if (__instanciated.get(this)) {
+      if (this.has(key)) {
+        this.#keys[this.#keys.indexOf(key)] = key;
+      } else {
+        this.#keys.push(key);
+      }
+    }
+    super.set(key, value);
+    return this;
+  }
+  insert(index2, key, value) {
+    const has = this.has(key);
+    const length64 = this.#keys.length;
+    const relativeIndex = toSafeInteger(index2);
+    let actualIndex = relativeIndex >= 0 ? relativeIndex : length64 + relativeIndex;
+    const safeIndex = actualIndex < 0 || actualIndex >= length64 ? -1 : actualIndex;
+    if (safeIndex === this.size || has && safeIndex === this.size - 1 || safeIndex === -1) {
+      this.set(key, value);
+      return this;
+    }
+    const size4 = this.size + (has ? 0 : 1);
+    if (relativeIndex < 0) {
+      actualIndex++;
+    }
+    const keys = [...this.#keys];
+    let nextValue;
+    let shouldSkip = false;
+    for (let i = actualIndex; i < size4; i++) {
+      if (actualIndex === i) {
+        let nextKey = keys[i];
+        if (keys[i] === key) {
+          nextKey = keys[i + 1];
+        }
+        if (has) {
+          this.delete(key);
+        }
+        nextValue = this.get(nextKey);
+        this.set(key, value);
+      } else {
+        if (!shouldSkip && keys[i - 1] === key) {
+          shouldSkip = true;
+        }
+        const currentKey = keys[shouldSkip ? i : i - 1];
+        const currentValue = nextValue;
+        nextValue = this.get(currentKey);
+        this.delete(currentKey);
+        this.set(currentKey, currentValue);
+      }
+    }
+    return this;
+  }
+  with(index2, key, value) {
+    const copy = new _OrderedDict(this);
+    copy.insert(index2, key, value);
+    return copy;
+  }
+  before(key) {
+    const index2 = this.#keys.indexOf(key) - 1;
+    if (index2 < 0) {
+      return void 0;
+    }
+    return this.entryAt(index2);
+  }
+  /**
+   * Sets a new key-value pair at the position before the given key.
+   */
+  setBefore(key, newKey, value) {
+    const index2 = this.#keys.indexOf(key);
+    if (index2 === -1) {
+      return this;
+    }
+    return this.insert(index2, newKey, value);
+  }
+  after(key) {
+    let index2 = this.#keys.indexOf(key);
+    index2 = index2 === -1 || index2 === this.size - 1 ? -1 : index2 + 1;
+    if (index2 === -1) {
+      return void 0;
+    }
+    return this.entryAt(index2);
+  }
+  /**
+   * Sets a new key-value pair at the position after the given key.
+   */
+  setAfter(key, newKey, value) {
+    const index2 = this.#keys.indexOf(key);
+    if (index2 === -1) {
+      return this;
+    }
+    return this.insert(index2 + 1, newKey, value);
+  }
+  first() {
+    return this.entryAt(0);
+  }
+  last() {
+    return this.entryAt(-1);
+  }
+  clear() {
+    this.#keys = [];
+    return super.clear();
+  }
+  delete(key) {
+    const deleted = super.delete(key);
+    if (deleted) {
+      this.#keys.splice(this.#keys.indexOf(key), 1);
+    }
+    return deleted;
+  }
+  deleteAt(index2) {
+    const key = this.keyAt(index2);
+    if (key !== void 0) {
+      return this.delete(key);
+    }
+    return false;
+  }
+  at(index2) {
+    const key = at(this.#keys, index2);
+    if (key !== void 0) {
+      return this.get(key);
+    }
+  }
+  entryAt(index2) {
+    const key = at(this.#keys, index2);
+    if (key !== void 0) {
+      return [key, this.get(key)];
+    }
+  }
+  indexOf(key) {
+    return this.#keys.indexOf(key);
+  }
+  keyAt(index2) {
+    return at(this.#keys, index2);
+  }
+  from(key, offset4) {
+    const index2 = this.indexOf(key);
+    if (index2 === -1) {
+      return void 0;
+    }
+    let dest = index2 + offset4;
+    if (dest < 0) dest = 0;
+    if (dest >= this.size) dest = this.size - 1;
+    return this.at(dest);
+  }
+  keyFrom(key, offset4) {
+    const index2 = this.indexOf(key);
+    if (index2 === -1) {
+      return void 0;
+    }
+    let dest = index2 + offset4;
+    if (dest < 0) dest = 0;
+    if (dest >= this.size) dest = this.size - 1;
+    return this.keyAt(dest);
+  }
+  find(predicate, thisArg) {
+    let index2 = 0;
+    for (const entry of this) {
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+        return entry;
+      }
+      index2++;
+    }
+    return void 0;
+  }
+  findIndex(predicate, thisArg) {
+    let index2 = 0;
+    for (const entry of this) {
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+        return index2;
+      }
+      index2++;
+    }
+    return -1;
+  }
+  filter(predicate, thisArg) {
+    const entries = [];
+    let index2 = 0;
+    for (const entry of this) {
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+        entries.push(entry);
+      }
+      index2++;
+    }
+    return new _OrderedDict(entries);
+  }
+  map(callbackfn, thisArg) {
+    const entries = [];
+    let index2 = 0;
+    for (const entry of this) {
+      entries.push([entry[0], Reflect.apply(callbackfn, thisArg, [entry, index2, this])]);
+      index2++;
+    }
+    return new _OrderedDict(entries);
+  }
+  reduce(...args) {
+    const [callbackfn, initialValue] = args;
+    let index2 = 0;
+    let accumulator = initialValue ?? this.at(0);
+    for (const entry of this) {
+      if (index2 === 0 && args.length === 1) {
+        accumulator = entry;
+      } else {
+        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]);
+      }
+      index2++;
+    }
+    return accumulator;
+  }
+  reduceRight(...args) {
+    const [callbackfn, initialValue] = args;
+    let accumulator = initialValue ?? this.at(-1);
+    for (let index2 = this.size - 1; index2 >= 0; index2--) {
+      const entry = this.at(index2);
+      if (index2 === this.size - 1 && args.length === 1) {
+        accumulator = entry;
+      } else {
+        accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]);
+      }
+    }
+    return accumulator;
+  }
+  toSorted(compareFn) {
+    const entries = [...this.entries()].sort(compareFn);
+    return new _OrderedDict(entries);
+  }
+  toReversed() {
+    const reversed = new _OrderedDict();
+    for (let index2 = this.size - 1; index2 >= 0; index2--) {
+      const key = this.keyAt(index2);
+      const element = this.get(key);
+      reversed.set(key, element);
+    }
+    return reversed;
+  }
+  toSpliced(...args) {
+    const entries = [...this.entries()];
+    entries.splice(...args);
+    return new _OrderedDict(entries);
+  }
+  slice(start, end) {
+    const result = new _OrderedDict();
+    let stop = this.size - 1;
+    if (start === void 0) {
+      return result;
+    }
+    if (start < 0) {
+      start = start + this.size;
+    }
+    if (end !== void 0 && end > 0) {
+      stop = end - 1;
+    }
+    for (let index2 = start; index2 <= stop; index2++) {
+      const key = this.keyAt(index2);
+      const element = this.get(key);
+      result.set(key, element);
+    }
+    return result;
+  }
+  every(predicate, thisArg) {
+    let index2 = 0;
+    for (const entry of this) {
+      if (!Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+        return false;
+      }
+      index2++;
+    }
+    return true;
+  }
+  some(predicate, thisArg) {
+    let index2 = 0;
+    for (const entry of this) {
+      if (Reflect.apply(predicate, thisArg, [entry, index2, this])) {
+        return true;
+      }
+      index2++;
+    }
+    return false;
+  }
+};
+function at(array, index2) {
+  if ("at" in Array.prototype) {
+    return Array.prototype.at.call(array, index2);
+  }
+  const actualIndex = toSafeIndex(array, index2);
+  return actualIndex === -1 ? void 0 : array[actualIndex];
+}
+__name8(at, "at");
+function toSafeIndex(array, index2) {
+  const length64 = array.length;
+  const relativeIndex = toSafeInteger(index2);
+  const actualIndex = relativeIndex >= 0 ? relativeIndex : length64 + relativeIndex;
+  return actualIndex < 0 || actualIndex >= length64 ? -1 : actualIndex;
+}
+__name8(toSafeIndex, "toSafeIndex");
+function toSafeInteger(number) {
+  return number !== number || number === 0 ? 0 : Math.trunc(number);
+}
+__name8(toSafeInteger, "toSafeInteger");
+// @__NO_SIDE_EFFECTS__
+function createCollection2(name) {
+  const PROVIDER_NAME = name + "CollectionProvider";
+  const [createCollectionContext, createCollectionScope3] = createContextScope(PROVIDER_NAME);
+  const [CollectionContextProvider, useCollectionContext] = createCollectionContext(
+    PROVIDER_NAME,
+    {
+      collectionElement: null,
+      collectionRef: { current: null },
+      collectionRefObject: { current: null },
+      itemMap: new OrderedDict(),
+      setItemMap: /* @__PURE__ */ __name8(() => void 0, "setItemMap")
+    }
+  );
+  const CollectionProvider = /* @__PURE__ */ __name8(({ state, ...props }) => {
+    return state ? /* @__PURE__ */ jsx25(CollectionProviderImpl, { ...props, state }) : /* @__PURE__ */ jsx25(CollectionInit, { ...props });
+  }, "CollectionProvider");
+  CollectionProvider.displayName = PROVIDER_NAME;
+  const CollectionInit = /* @__PURE__ */ __name8((props) => {
+    const state = useInitCollection();
+    return /* @__PURE__ */ jsx25(CollectionProviderImpl, { ...props, state });
+  }, "CollectionInit");
+  CollectionInit.displayName = PROVIDER_NAME + "Init";
+  const CollectionProviderImpl = /* @__PURE__ */ __name8((props) => {
+    const { scope, children, state } = props;
+    const ref = React23.useRef(null);
+    const [collectionElement, setCollectionElement] = React23.useState(
+      null
+    );
+    const composeRefs2 = useComposedRefs(ref, setCollectionElement);
+    const [itemMap, setItemMap] = state;
+    React23.useEffect(() => {
+      if (!collectionElement) return;
+      const observer = getChildListObserver(() => {
+      });
+      observer.observe(collectionElement, {
+        childList: true,
+        subtree: true
+      });
+      return () => {
+        observer.disconnect();
+      };
+    }, [collectionElement]);
+    return /* @__PURE__ */ jsx25(
+      CollectionContextProvider,
+      {
+        scope,
+        itemMap,
+        setItemMap,
+        collectionRef: composeRefs2,
+        collectionRefObject: ref,
+        collectionElement,
+        children
+      }
+    );
+  }, "CollectionProviderImpl");
+  CollectionProviderImpl.displayName = PROVIDER_NAME + "Impl";
+  const COLLECTION_SLOT_NAME = name + "CollectionSlot";
+  const CollectionSlotImpl = createSlot(COLLECTION_SLOT_NAME);
+  const CollectionSlot = React23.forwardRef(
+    (props, forwardedRef) => {
+      const { scope, children } = props;
+      const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
+      const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
+      return /* @__PURE__ */ jsx25(CollectionSlotImpl, { ref: composedRefs, children });
+    }
+  );
+  CollectionSlot.displayName = COLLECTION_SLOT_NAME;
+  const ITEM_SLOT_NAME = name + "CollectionItemSlot";
+  const ITEM_DATA_ATTR = "data-radix-collection-item";
+  const CollectionItemSlotImpl = createSlot(ITEM_SLOT_NAME);
+  const CollectionItemSlot = React23.forwardRef(
+    (props, forwardedRef) => {
+      const { scope, children, ...itemData } = props;
+      const ref = React23.useRef(null);
+      const [element, setElement] = React23.useState(null);
+      const composedRefs = useComposedRefs(forwardedRef, ref, setElement);
+      const context = useCollectionContext(ITEM_SLOT_NAME, scope);
+      const { setItemMap } = context;
+      const itemDataRef = React23.useRef(itemData);
+      if (!shallowEqual(itemDataRef.current, itemData)) {
+        itemDataRef.current = itemData;
+      }
+      const memoizedItemData = itemDataRef.current;
+      React23.useEffect(() => {
+        const itemData2 = memoizedItemData;
+        setItemMap((map) => {
+          if (!element) {
+            return map;
+          }
+          if (!map.has(element)) {
+            map.set(element, { ...itemData2, element });
+            return map.toSorted(sortByDocumentPosition);
+          }
+          return map.set(element, { ...itemData2, element }).toSorted(sortByDocumentPosition);
+        });
+        return () => {
+          setItemMap((map) => {
+            if (!element || !map.has(element)) {
+              return map;
+            }
+            map.delete(element);
+            return new OrderedDict(map);
+          });
+        };
+      }, [element, memoizedItemData, setItemMap]);
+      return /* @__PURE__ */ jsx25(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children });
+    }
+  );
+  CollectionItemSlot.displayName = ITEM_SLOT_NAME;
+  function useInitCollection() {
+    return React23.useState(new OrderedDict());
+  }
+  __name8(useInitCollection, "useInitCollection");
+  function useCollection3(scope) {
+    const { itemMap } = useCollectionContext(name + "CollectionConsumer", scope);
+    return itemMap;
+  }
+  __name8(useCollection3, "useCollection");
+  const functions = {
+    createCollectionScope: createCollectionScope3,
+    useCollection: useCollection3,
+    useInitCollection
+  };
+  return [
+    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },
+    functions
+  ];
+}
+__name8(createCollection2, "createCollection");
+function shallowEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (a == null || b == null) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (a[key] !== b[key]) return false;
+  }
+  return true;
+}
+__name8(shallowEqual, "shallowEqual");
+function isElementPreceding(a, b) {
+  return !!(b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_PRECEDING);
+}
+__name8(isElementPreceding, "isElementPreceding");
+function sortByDocumentPosition(a, b) {
+  return !a[1].element || !b[1].element ? 0 : isElementPreceding(a[1].element, b[1].element) ? -1 : 1;
+}
+__name8(sortByDocumentPosition, "sortByDocumentPosition");
+function getChildListObserver(callback) {
+  const observer = new MutationObserver((mutationsList) => {
+    for (const mutation of mutationsList) {
+      if (mutation.type === "childList") {
+        callback();
+        return;
+      }
+    }
+  });
+  return observer;
+}
+__name8(getChildListObserver, "getChildListObserver");
 
 // node_modules/@radix-ui/react-direction/dist/index.mjs
-import * as React20 from "react";
-import { jsx as jsx25 } from "react/jsx-runtime";
-var DirectionContext = React20.createContext(void 0);
+import * as React21 from "react";
+import { jsx as jsx26 } from "react/jsx-runtime";
+var __defProp11 = Object.defineProperty;
+var __name9 = (target, value) => __defProp11(target, "name", { value, configurable: true });
+var DirectionContext = React21.createContext(void 0);
 function useDirection(localDir) {
-  const globalDir = React20.useContext(DirectionContext);
+  const globalDir = React21.useContext(DirectionContext);
   return localDir || globalDir || "ltr";
 }
+__name9(useDirection, "useDirection");
 
 // node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs
-import * as React24 from "react";
+import * as React25 from "react";
 
 // node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs
-import * as React21 from "react";
+import * as React24 from "react";
+var __defProp12 = Object.defineProperty;
+var __name10 = (target, value) => __defProp12(target, "name", { value, configurable: true });
 function useCallbackRef(callback) {
-  const callbackRef = React21.useRef(callback);
-  React21.useEffect(() => {
+  const callbackRef = React24.useRef(callback);
+  React24.useEffect(() => {
     callbackRef.current = callback;
   });
-  return React21.useMemo(() => ((...args) => callbackRef.current?.(...args)), []);
+  return React24.useMemo(() => ((...args) => callbackRef.current?.(...args)), []);
 }
+__name10(useCallbackRef, "useCallbackRef");
 
 // node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs
-import { jsx as jsx26 } from "react/jsx-runtime";
-var DISMISSABLE_LAYER_NAME = "DismissableLayer";
+import { jsx as jsx27 } from "react/jsx-runtime";
+var __defProp13 = Object.defineProperty;
+var __name11 = (target, value) => __defProp13(target, "name", { value, configurable: true });
 var CONTEXT_UPDATE = "dismissableLayer.update";
 var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
 var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
 var originalBodyPointerEvents;
-var DismissableLayerContext = React24.createContext({
+var DismissableLayerContext = React25.createContext({
   layers: /* @__PURE__ */ new Set(),
   layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
   branches: /* @__PURE__ */ new Set(),
@@ -40481,8 +41181,9 @@ var DismissableLayerContext = React24.createContext({
   // See https://github.com/radix-ui/primitives/issues/3346
   dismissableSurfaces: /* @__PURE__ */ new Set()
 });
-var DismissableLayer = React24.forwardRef(
-  (props, forwardedRef) => {
+var DismissableLayer = /* @__PURE__ */ React25.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name11(function DismissableLayer2(props, forwardedRef) {
     const {
       disableOutsidePointerEvents = false,
       deferPointerDownOutside = false,
@@ -40493,10 +41194,10 @@ var DismissableLayer = React24.forwardRef(
       onDismiss,
       ...layerProps
     } = props;
-    const context = React24.useContext(DismissableLayerContext);
-    const [node, setNode] = React24.useState(null);
+    const context = React25.useContext(DismissableLayerContext);
+    const [node, setNode] = React25.useState(null);
     const ownerDocument = node?.ownerDocument ?? globalThis?.document;
-    const [, force] = React24.useState({});
+    const [, force] = React25.useState({});
     const composedRefs = useComposedRefs(forwardedRef, setNode);
     const layers = Array.from(context.layers);
     const [highestLayerWithOutsidePointerEventsDisabled] = [
@@ -40506,7 +41207,7 @@ var DismissableLayer = React24.forwardRef(
     const index2 = node ? layers.indexOf(node) : -1;
     const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
     const isPointerEventsEnabled = index2 >= highestLayerWithOutsidePointerEventsDisabledIndex;
-    const isDeferredPointerDownOutsideRef = React24.useRef(false);
+    const isDeferredPointerDownOutsideRef = React25.useRef(false);
     const pointerDownOutside = usePointerDownOutside(
       (event) => {
         onPointerDownOutside?.(event);
@@ -40518,7 +41219,7 @@ var DismissableLayer = React24.forwardRef(
         deferPointerDownOutside,
         isDeferredPointerDownOutsideRef,
         dismissableSurfaces: context.dismissableSurfaces,
-        shouldHandlePointerDownOutside: React24.useCallback(
+        shouldHandlePointerDownOutside: React25.useCallback(
           (target) => {
             if (!(target instanceof Node)) {
               return false;
@@ -40554,14 +41255,14 @@ var DismissableLayer = React24.forwardRef(
         onDismiss();
       }
     });
-    React24.useEffect(() => {
+    React25.useEffect(() => {
       if (!isHighestLayer) {
         return;
       }
       ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
       return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
     }, [ownerDocument, isHighestLayer, handleKeyDown]);
-    React24.useEffect(() => {
+    React25.useEffect(() => {
       if (!node) return;
       if (disableOutsidePointerEvents) {
         if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
@@ -40581,7 +41282,7 @@ var DismissableLayer = React24.forwardRef(
         }
       };
     }, [node, ownerDocument, disableOutsidePointerEvents, context]);
-    React24.useEffect(() => {
+    React25.useEffect(() => {
       return () => {
         if (!node) return;
         context.layers.delete(node);
@@ -40589,12 +41290,12 @@ var DismissableLayer = React24.forwardRef(
         dispatchUpdate();
       };
     }, [node, context]);
-    React24.useEffect(() => {
-      const handleUpdate = () => force({});
+    React25.useEffect(() => {
+      const handleUpdate = /* @__PURE__ */ __name11(() => force({}), "handleUpdate");
       document.addEventListener(CONTEXT_UPDATE, handleUpdate);
       return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
     }, []);
-    return /* @__PURE__ */ jsx26(
+    return /* @__PURE__ */ jsx27(
       Primitive.div,
       {
         ...layerProps,
@@ -40611,27 +41312,24 @@ var DismissableLayer = React24.forwardRef(
         )
       }
     );
-  }
+  }, "DismissableLayer")
 );
-DismissableLayer.displayName = DISMISSABLE_LAYER_NAME;
-var BRANCH_NAME = "DismissableLayerBranch";
-var DismissableLayerBranch = React24.forwardRef((props, forwardedRef) => {
-  const context = React24.useContext(DismissableLayerContext);
-  const ref = React24.useRef(null);
-  const composedRefs = useComposedRefs(forwardedRef, ref);
-  React24.useEffect(() => {
-    const node = ref.current;
-    if (node) {
-      context.branches.add(node);
-      return () => {
-        context.branches.delete(node);
-      };
+function useDismissableLayerSurface() {
+  const context = React25.useContext(DismissableLayerContext);
+  const [node, setNode] = React25.useState(null);
+  React25.useEffect(() => {
+    if (!node) {
+      return;
     }
-  }, [context.branches]);
-  return /* @__PURE__ */ jsx26(Primitive.div, { ...props, ref: composedRefs });
-});
-DismissableLayerBranch.displayName = BRANCH_NAME;
-var IS_TRUE = () => true;
+    context.dismissableSurfaces.add(node);
+    return () => {
+      context.dismissableSurfaces.delete(node);
+    };
+  }, [node, context.dismissableSurfaces]);
+  return setNode;
+}
+__name11(useDismissableLayerSurface, "useDismissableLayerSurface");
+var IS_TRUE = /* @__PURE__ */ __name11(() => true, "IS_TRUE");
 function usePointerDownOutside(onPointerDownOutside, args) {
   const {
     ownerDocument = globalThis?.document,
@@ -40641,20 +41339,22 @@ function usePointerDownOutside(onPointerDownOutside, args) {
     shouldHandlePointerDownOutside = IS_TRUE
   } = args;
   const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);
-  const isPointerInsideReactTreeRef = React24.useRef(false);
-  const isPointerDownOutsideRef = React24.useRef(false);
-  const interceptedOutsideInteractionEventsRef = React24.useRef(/* @__PURE__ */ new Map());
-  const handleClickRef = React24.useRef(() => {
+  const isPointerInsideReactTreeRef = React25.useRef(false);
+  const isPointerDownOutsideRef = React25.useRef(false);
+  const interceptedOutsideInteractionEventsRef = React25.useRef(/* @__PURE__ */ new Map());
+  const handleClickRef = React25.useRef(() => {
   });
-  React24.useEffect(() => {
+  React25.useEffect(() => {
     function resetOutsideInteraction() {
       isPointerDownOutsideRef.current = false;
       isDeferredPointerDownOutsideRef.current = false;
       interceptedOutsideInteractionEventsRef.current.clear();
     }
+    __name11(resetOutsideInteraction, "resetOutsideInteraction");
     function isOutsideInteractionIntercepted() {
       return Array.from(interceptedOutsideInteractionEventsRef.current.values()).some(Boolean);
     }
+    __name11(isOutsideInteractionIntercepted, "isOutsideInteractionIntercepted");
     function handleInteractionCapture(event) {
       if (!isPointerDownOutsideRef.current) {
         return;
@@ -40672,12 +41372,14 @@ function usePointerDownOutside(onPointerDownOutside, args) {
         }, 0);
       }
     }
+    __name11(handleInteractionCapture, "handleInteractionCapture");
     function handleInteractionBubble(event) {
       if (isPointerDownOutsideRef.current) {
         interceptedOutsideInteractionEventsRef.current.set(event.type, false);
       }
     }
-    const handlePointerDown = (event) => {
+    __name11(handleInteractionBubble, "handleInteractionBubble");
+    const handlePointerDown = /* @__PURE__ */ __name11((event) => {
       if (event.target && !isPointerInsideReactTreeRef.current) {
         let handleAndDispatchPointerDownOutsideEvent2 = function() {
           ownerDocument.removeEventListener("click", handleClickRef.current);
@@ -40693,6 +41395,7 @@ function usePointerDownOutside(onPointerDownOutside, args) {
           }
         };
         var handleAndDispatchPointerDownOutsideEvent = handleAndDispatchPointerDownOutsideEvent2;
+        __name11(handleAndDispatchPointerDownOutsideEvent2, "handleAndDispatchPointerDownOutsideEvent");
         if (!shouldHandlePointerDownOutside(event.target)) {
           ownerDocument.removeEventListener("click", handleClickRef.current);
           resetOutsideInteraction();
@@ -40715,7 +41418,7 @@ function usePointerDownOutside(onPointerDownOutside, args) {
         resetOutsideInteraction();
       }
       isPointerInsideReactTreeRef.current = false;
-    };
+    }, "handlePointerDown");
     const outsideInteractionEvents = [
       "pointerup",
       "mousedown",
@@ -40750,33 +41453,36 @@ function usePointerDownOutside(onPointerDownOutside, args) {
   ]);
   return {
     // ensures we check React component tree (not just DOM tree)
-    onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true
+    onPointerDownCapture: /* @__PURE__ */ __name11(() => isPointerInsideReactTreeRef.current = true, "onPointerDownCapture")
   };
 }
+__name11(usePointerDownOutside, "usePointerDownOutside");
 function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
   const handleFocusOutside = useCallbackRef(onFocusOutside);
-  const isFocusInsideReactTreeRef = React24.useRef(false);
-  React24.useEffect(() => {
-    const handleFocus = (event) => {
+  const isFocusInsideReactTreeRef = React25.useRef(false);
+  React25.useEffect(() => {
+    const handleFocus = /* @__PURE__ */ __name11((event) => {
       if (event.target && !isFocusInsideReactTreeRef.current) {
         const eventDetail = { originalEvent: event };
         handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {
           discrete: false
         });
       }
-    };
+    }, "handleFocus");
     ownerDocument.addEventListener("focusin", handleFocus);
     return () => ownerDocument.removeEventListener("focusin", handleFocus);
   }, [ownerDocument, handleFocusOutside]);
   return {
-    onFocusCapture: () => isFocusInsideReactTreeRef.current = true,
-    onBlurCapture: () => isFocusInsideReactTreeRef.current = false
+    onFocusCapture: /* @__PURE__ */ __name11(() => isFocusInsideReactTreeRef.current = true, "onFocusCapture"),
+    onBlurCapture: /* @__PURE__ */ __name11(() => isFocusInsideReactTreeRef.current = false, "onBlurCapture")
   };
 }
+__name11(useFocusOutside, "useFocusOutside");
 function dispatchUpdate() {
   const event = new CustomEvent(CONTEXT_UPDATE);
   document.dispatchEvent(event);
 }
+__name11(dispatchUpdate, "dispatchUpdate");
 function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
   const target = detail.originalEvent.target;
   const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });
@@ -40787,13 +41493,21 @@ function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
     target.dispatchEvent(event);
   }
 }
+__name11(handleAndDispatchCustomEvent, "handleAndDispatchCustomEvent");
 
 // node_modules/@radix-ui/react-focus-guards/dist/index.mjs
-import * as React25 from "react";
+import * as React26 from "react";
+var __defProp14 = Object.defineProperty;
+var __name12 = (target, value) => __defProp14(target, "name", { value, configurable: true });
 var count = 0;
 var guards = null;
+function FocusGuards(props) {
+  useFocusGuards();
+  return props.children;
+}
+__name12(FocusGuards, "FocusGuards");
 function useFocusGuards() {
-  React25.useEffect(() => {
+  React26.useEffect(() => {
     if (!guards) {
       guards = { start: createFocusGuard(), end: createFocusGuard() };
     }
@@ -40815,6 +41529,7 @@ function useFocusGuards() {
     };
   }, []);
 }
+__name12(useFocusGuards, "useFocusGuards");
 function createFocusGuard() {
   const element = document.createElement("span");
   element.setAttribute("data-radix-focus-guard", "");
@@ -40825,131 +41540,173 @@ function createFocusGuard() {
   element.style.pointerEvents = "none";
   return element;
 }
+__name12(createFocusGuard, "createFocusGuard");
 
 // node_modules/@radix-ui/react-focus-scope/dist/index.mjs
-import * as React26 from "react";
-import { jsx as jsx27 } from "react/jsx-runtime";
+import * as React27 from "react";
+import { jsx as jsx28 } from "react/jsx-runtime";
+var __defProp15 = Object.defineProperty;
+var __name13 = (target, value) => __defProp15(target, "name", { value, configurable: true });
 var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
 var AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
 var EVENT_OPTIONS = { bubbles: false, cancelable: true };
-var FOCUS_SCOPE_NAME = "FocusScope";
-var FocusScope = React26.forwardRef((props, forwardedRef) => {
-  const {
-    loop = false,
-    trapped = false,
-    onMountAutoFocus: onMountAutoFocusProp,
-    onUnmountAutoFocus: onUnmountAutoFocusProp,
-    ...scopeProps
-  } = props;
-  const [container, setContainer] = React26.useState(null);
-  const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);
-  const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);
-  const lastFocusedElementRef = React26.useRef(null);
-  const composedRefs = useComposedRefs(forwardedRef, setContainer);
-  const focusScope = React26.useRef({
-    paused: false,
-    pause() {
-      this.paused = true;
-    },
-    resume() {
-      this.paused = false;
-    }
-  }).current;
-  React26.useEffect(() => {
-    if (trapped) {
-      let handleFocusIn2 = function(event) {
-        if (focusScope.paused || !container) return;
-        const target = event.target;
-        if (container.contains(target)) {
-          lastFocusedElementRef.current = target;
-        } else {
-          focus(lastFocusedElementRef.current, { select: true });
-        }
-      }, handleFocusOut2 = function(event) {
-        if (focusScope.paused || !container) return;
-        const relatedTarget = event.relatedTarget;
-        if (relatedTarget === null) return;
-        if (!container.contains(relatedTarget)) {
-          focus(lastFocusedElementRef.current, { select: true });
-        }
-      }, handleMutations2 = function(mutations) {
-        const focusedElement = document.activeElement;
-        if (focusedElement !== document.body) return;
-        for (const mutation of mutations) {
-          if (mutation.removedNodes.length > 0) focus(container);
-        }
-      };
-      var handleFocusIn = handleFocusIn2, handleFocusOut = handleFocusOut2, handleMutations = handleMutations2;
-      document.addEventListener("focusin", handleFocusIn2);
-      document.addEventListener("focusout", handleFocusOut2);
-      const mutationObserver = new MutationObserver(handleMutations2);
-      if (container) mutationObserver.observe(container, { childList: true, subtree: true });
-      return () => {
-        document.removeEventListener("focusin", handleFocusIn2);
-        document.removeEventListener("focusout", handleFocusOut2);
-        mutationObserver.disconnect();
-      };
-    }
-  }, [trapped, container, focusScope.paused]);
-  React26.useEffect(() => {
-    if (container) {
-      focusScopesStack.add(focusScope);
-      const previouslyFocusedElement = document.activeElement;
-      const hasFocusedCandidate = container.contains(previouslyFocusedElement);
-      if (!hasFocusedCandidate) {
-        const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
-        container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
-        container.dispatchEvent(mountEvent);
-        if (!mountEvent.defaultPrevented) {
-          focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
-          if (document.activeElement === previouslyFocusedElement) {
-            focus(container);
+var FocusScope = /* @__PURE__ */ React27.forwardRef(
+  /* @__PURE__ */ __name13(function FocusScope2(props, forwardedRef) {
+    const {
+      loop = false,
+      trapped = false,
+      branches,
+      onMountAutoFocus: onMountAutoFocusProp,
+      onUnmountAutoFocus: onUnmountAutoFocusProp,
+      ...scopeProps
+    } = props;
+    const [container, setContainer] = React27.useState(null);
+    const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);
+    const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);
+    const lastFocusedElementRef = React27.useRef(null);
+    const composedRefs = useComposedRefs(forwardedRef, setContainer);
+    const branchesRef = React27.useRef(branches);
+    React27.useEffect(() => {
+      branchesRef.current = branches;
+    });
+    const isTargetInScope = React27.useCallback(
+      (target) => {
+        if (!target) return false;
+        if (container?.contains(target)) return true;
+        return Boolean(branchesRef.current?.some((branch) => branch.contains(target)));
+      },
+      [container]
+    );
+    const focusScope = React27.useRef({
+      paused: false,
+      pause() {
+        this.paused = true;
+      },
+      resume() {
+        this.paused = false;
+      }
+    }).current;
+    React27.useEffect(() => {
+      if (trapped) {
+        let handleFocusIn2 = function(event) {
+          if (focusScope.paused || !container) return;
+          const target = event.target;
+          if (isTargetInScope(target)) {
+            lastFocusedElementRef.current = target;
+          } else {
+            focus(lastFocusedElementRef.current, { select: true });
           }
-        }
-      }
-      return () => {
-        container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
-        setTimeout(() => {
-          const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
-          container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-          container.dispatchEvent(unmountEvent);
-          if (!unmountEvent.defaultPrevented) {
-            focus(previouslyFocusedElement ?? document.body, { select: true });
+        }, handleFocusOut2 = function(event) {
+          if (focusScope.paused || !container) return;
+          const relatedTarget = event.relatedTarget;
+          if (relatedTarget === null) return;
+          if (!isTargetInScope(relatedTarget)) {
+            focus(lastFocusedElementRef.current, { select: true });
           }
-          container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-          focusScopesStack.remove(focusScope);
-        }, 0);
-      };
-    }
-  }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);
-  const handleKeyDown = React26.useCallback(
-    (event) => {
-      if (!loop && !trapped) return;
-      if (focusScope.paused) return;
-      const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
-      const focusedElement = document.activeElement;
-      if (isTabKey && focusedElement) {
-        const container2 = event.currentTarget;
-        const [first, last] = getTabbableEdges(container2);
-        const hasTabbableElementsInside = first && last;
-        if (!hasTabbableElementsInside) {
-          if (focusedElement === container2) event.preventDefault();
-        } else {
-          if (!event.shiftKey && focusedElement === last) {
-            event.preventDefault();
-            if (loop) focus(first, { select: true });
-          } else if (event.shiftKey && focusedElement === first) {
-            event.preventDefault();
-            if (loop) focus(last, { select: true });
+        }, handleMutations2 = function(mutations) {
+          const focusedElement = document.activeElement;
+          if (focusedElement !== document.body) return;
+          for (const mutation of mutations) {
+            if (mutation.removedNodes.length > 0) focus(container);
+          }
+        };
+        var handleFocusIn = handleFocusIn2, handleFocusOut = handleFocusOut2, handleMutations = handleMutations2;
+        __name13(handleFocusIn2, "handleFocusIn");
+        __name13(handleFocusOut2, "handleFocusOut");
+        __name13(handleMutations2, "handleMutations");
+        document.addEventListener("focusin", handleFocusIn2);
+        document.addEventListener("focusout", handleFocusOut2);
+        const mutationObserver = new MutationObserver(handleMutations2);
+        if (container) mutationObserver.observe(container, { childList: true, subtree: true });
+        return () => {
+          document.removeEventListener("focusin", handleFocusIn2);
+          document.removeEventListener("focusout", handleFocusOut2);
+          mutationObserver.disconnect();
+        };
+      }
+    }, [trapped, container, focusScope.paused, isTargetInScope]);
+    React27.useEffect(() => {
+      if (container) {
+        focusScopesStack.add(focusScope);
+        const previouslyFocusedElement = document.activeElement;
+        const hasFocusedCandidate = container.contains(previouslyFocusedElement);
+        if (!hasFocusedCandidate) {
+          const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
+          container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+          container.dispatchEvent(mountEvent);
+          if (!mountEvent.defaultPrevented) {
+            focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
+            if (document.activeElement === previouslyFocusedElement) {
+              focus(container);
+            }
           }
         }
+        return () => {
+          container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+          setTimeout(() => {
+            const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
+            container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+            container.dispatchEvent(unmountEvent);
+            if (!unmountEvent.defaultPrevented) {
+              focus(previouslyFocusedElement ?? document.body, { select: true });
+            }
+            container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+            focusScopesStack.remove(focusScope);
+          }, 0);
+        };
       }
-    },
-    [loop, trapped, focusScope.paused]
+    }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);
+    const handleKeyDown = React27.useCallback(
+      (event) => {
+        if (!loop && !trapped) return;
+        if (focusScope.paused) return;
+        const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+        const focusedElement = document.activeElement;
+        if (isTabKey && focusedElement) {
+          const container2 = event.currentTarget;
+          const [first, last] = getTabbableEdges(container2);
+          const hasTabbableElementsInside = first && last;
+          if (!hasTabbableElementsInside) {
+            if (focusedElement === container2) event.preventDefault();
+          } else {
+            if (!event.shiftKey && focusedElement === last) {
+              event.preventDefault();
+              if (loop) focus(first, { select: true });
+            } else if (event.shiftKey && focusedElement === first) {
+              event.preventDefault();
+              if (loop) focus(last, { select: true });
+            }
+          }
+        }
+      },
+      [loop, trapped, focusScope.paused]
+    );
+    return /* @__PURE__ */ jsx28(Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown });
+  }, "FocusScope")
+);
+var FocusScopeBranchContext = React27.createContext(null);
+var FocusScopeBranchProvider = FocusScopeBranchContext.Provider;
+function useFocusScopeBranchRegistry() {
+  const [nodes, setNodes] = React27.useState([]);
+  const registry = React27.useMemo(
+    () => ({
+      add: /* @__PURE__ */ __name13((node) => setNodes((prev) => prev.includes(node) ? prev : [...prev, node]), "add"),
+      remove: /* @__PURE__ */ __name13((node) => setNodes((prev) => prev.filter((current) => current !== node)), "remove")
+    }),
+    []
   );
-  return /* @__PURE__ */ jsx27(Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown });
-});
-FocusScope.displayName = FOCUS_SCOPE_NAME;
+  return { nodes, registry };
+}
+__name13(useFocusScopeBranchRegistry, "useFocusScopeBranchRegistry");
+function useFocusScopeBranch(node) {
+  const registry = React27.useContext(FocusScopeBranchContext);
+  React27.useEffect(() => {
+    if (!node || !registry) return;
+    registry.add(node);
+    return () => registry.remove(node);
+  }, [node, registry]);
+}
+__name13(useFocusScopeBranch, "useFocusScopeBranch");
 function focusFirst(candidates, { select = false } = {}) {
   const previouslyFocusedElement = document.activeElement;
   for (const candidate of candidates) {
@@ -40957,24 +41714,27 @@ function focusFirst(candidates, { select = false } = {}) {
     if (document.activeElement !== previouslyFocusedElement) return;
   }
 }
+__name13(focusFirst, "focusFirst");
 function getTabbableEdges(container) {
   const candidates = getTabbableCandidates(container);
   const first = findVisible(candidates, container);
   const last = findVisible(candidates.reverse(), container);
   return [first, last];
 }
+__name13(getTabbableEdges, "getTabbableEdges");
 function getTabbableCandidates(container) {
   const nodes = [];
   const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
-    acceptNode: (node) => {
+    acceptNode: /* @__PURE__ */ __name13((node) => {
       const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
       if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
       return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-    }
+    }, "acceptNode")
   });
   while (walker.nextNode()) nodes.push(walker.currentNode);
   return nodes;
 }
+__name13(getTabbableCandidates, "getTabbableCandidates");
 function findVisible(elements, container) {
   const canUseCheckVisibility = typeof container.checkVisibility === "function" && container.checkVisibility({ checkVisibilityCSS: true });
   for (const element of elements) {
@@ -40984,6 +41744,7 @@ function findVisible(elements, container) {
     }
   }
 }
+__name13(findVisible, "findVisible");
 function isHidden(node, { upTo }) {
   if (getComputedStyle(node).visibility === "hidden") return true;
   while (node) {
@@ -40993,9 +41754,11 @@ function isHidden(node, { upTo }) {
   }
   return false;
 }
+__name13(isHidden, "isHidden");
 function isSelectableInput(element) {
   return element instanceof HTMLInputElement && "select" in element;
 }
+__name13(isSelectableInput, "isSelectableInput");
 function focus(element, { select = false } = {}) {
   if (element && element.focus) {
     const previouslyFocusedElement = document.activeElement;
@@ -41004,6 +41767,7 @@ function focus(element, { select = false } = {}) {
       element.select();
   }
 }
+__name13(focus, "focus");
 var focusScopesStack = createFocusScopesStack();
 function createFocusScopesStack() {
   let stack = [];
@@ -41022,6 +41786,7 @@ function createFocusScopesStack() {
     }
   };
 }
+__name13(createFocusScopesStack, "createFocusScopesStack");
 function arrayRemove(array, item) {
   const updatedArray = [...array];
   const index2 = updatedArray.indexOf(item);
@@ -41030,21 +41795,26 @@ function arrayRemove(array, item) {
   }
   return updatedArray;
 }
+__name13(arrayRemove, "arrayRemove");
 function removeLinks(items) {
   return items.filter((item) => item.tagName !== "A");
 }
+__name13(removeLinks, "removeLinks");
 
 // node_modules/@radix-ui/react-id/dist/index.mjs
-import * as React27 from "react";
-var useReactId = React27[" useId ".trim().toString()] || (() => void 0);
+import * as React28 from "react";
+var __defProp16 = Object.defineProperty;
+var __name14 = (target, value) => __defProp16(target, "name", { value, configurable: true });
+var useReactId = React28[" useId ".trim().toString()] || (() => void 0);
 var count2 = 0;
 function useId(deterministicId) {
-  const [id, setId] = React27.useState(useReactId());
+  const [id, setId] = React28.useState(useReactId());
   useLayoutEffect2(() => {
     if (!deterministicId) setId((reactId) => reactId ?? String(count2++));
   }, [deterministicId]);
   return deterministicId || (id ? `radix-${id}` : "");
 }
+__name14(useId, "useId");
 
 // node_modules/@radix-ui/react-popper/dist/index.mjs
 import * as React31 from "react";
@@ -41143,12 +41913,12 @@ function getOppositePlacement(placement) {
   return oppositeSideMap[side] + placement.slice(side.length);
 }
 function expandPaddingObject(padding) {
+  var _padding$top, _padding$right, _padding$bottom, _padding$left;
   return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...padding
+    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) {
@@ -41224,13 +41994,9 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
         y: reference.y
       };
   }
-  switch (getAlignment(placement)) {
-    case "start":
-      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
-    case "end":
-      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
+  const alignment = getAlignment(placement);
+  if (alignment) {
+    coords[alignmentAxis] += commonAlign * (alignment === "end" ? 1 : -1) * (rtl && isVertical ? -1 : 1);
   }
   return coords;
 }
@@ -41270,10 +42036,7 @@ async function detectOverflow(state, options) {
     height: rects.floating.height
   } : rects.reference;
   const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
-  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
-    x: 1,
-    y: 1
-  } : {
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) && await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
     x: 1,
     y: 1
   };
@@ -41421,12 +42184,11 @@ var arrow = (options) => ({
     const largestPossiblePadding = clientSize / 2 - arrowDimensions[length64] / 2 - 1;
     const minPadding = min(paddingObject[minProp], largestPossiblePadding);
     const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
-    const min$1 = minPadding;
     const max2 = clientSize - arrowDimensions[length64] - maxPadding;
     const center = clientSize / 2 - arrowDimensions[length64] / 2 + centerToReference;
-    const offset4 = clamp2(min$1, center, max2);
-    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length64] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length64] / 2 < 0;
-    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
+    const offset4 = clamp2(minPadding, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length64] / 2 - (center < minPadding ? minPadding : maxPadding) - arrowDimensions[length64] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < minPadding ? center - minPadding : center - max2 : 0;
     return {
       [axis]: coords[axis] + alignmentOffset,
       data: {
@@ -41714,23 +42476,16 @@ var shift = function(options) {
         y
       };
       const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
-      const crossAxis = getSideAxis(getSide(placement));
+      const crossAxis = getSideAxis(placement);
       const mainAxis = getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
+      const clampCoord = (axis, coord) => clamp2(coord + overflow[axis === "y" ? "top" : "left"], coord, coord - overflow[axis === "y" ? "bottom" : "right"]);
       if (checkMainAxis) {
-        const minSide = mainAxis === "y" ? "top" : "left";
-        const maxSide = mainAxis === "y" ? "bottom" : "right";
-        const min2 = mainAxisCoord + overflow[minSide];
-        const max2 = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = clamp2(min2, mainAxisCoord, max2);
+        mainAxisCoord = clampCoord(mainAxis, mainAxisCoord);
       }
       if (checkCrossAxis) {
-        const minSide = crossAxis === "y" ? "top" : "left";
-        const maxSide = crossAxis === "y" ? "bottom" : "right";
-        const min2 = crossAxisCoord + overflow[minSide];
-        const max2 = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = clamp2(min2, crossAxisCoord, max2);
+        crossAxisCoord = clampCoord(crossAxis, crossAxisCoord);
       }
       const limitedCoords = limiter.fn({
         ...state,
@@ -41758,6 +42513,7 @@ var limitShift = function(options) {
   return {
     options,
     fn(state) {
+      var _rawOffset$mainAxis, _rawOffset$crossAxis;
       const {
         x,
         y,
@@ -41783,9 +42539,8 @@ var limitShift = function(options) {
         mainAxis: rawOffset,
         crossAxis: 0
       } : {
-        mainAxis: 0,
-        crossAxis: 0,
-        ...rawOffset
+        mainAxis: (_rawOffset$mainAxis = rawOffset.mainAxis) != null ? _rawOffset$mainAxis : 0,
+        crossAxis: (_rawOffset$crossAxis = rawOffset.crossAxis) != null ? _rawOffset$crossAxis : 0
       };
       if (checkMainAxis) {
         const len = mainAxis === "y" ? "height" : "width";
@@ -41824,7 +42579,6 @@ var size = function(options) {
     name: "size",
     options,
     async fn(state) {
-      var _state$middlewareData, _state$middlewareData2;
       const {
         placement,
         rects,
@@ -41857,24 +42611,21 @@ var size = function(options) {
       const maximumClippingWidth = width10 - overflow.left - overflow.right;
       const overflowAvailableHeight = min(height10 - overflow[heightSide], maximumClippingHeight);
       const overflowAvailableWidth = min(width10 - overflow[widthSide], maximumClippingWidth);
-      const noShift = !state.middlewareData.shift;
+      const shiftData = state.middlewareData.shift;
+      const noShift = !shiftData;
       let availableHeight = overflowAvailableHeight;
       let availableWidth = overflowAvailableWidth;
-      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
+      if (shiftData != null && shiftData.enabled.x) {
         availableWidth = maximumClippingWidth;
       }
-      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
+      if (shiftData != null && shiftData.enabled.y) {
         availableHeight = maximumClippingHeight;
       }
       if (noShift && !alignment) {
-        const xMin = max(overflow.left, 0);
-        const xMax = max(overflow.right, 0);
-        const yMin = max(overflow.top, 0);
-        const yMax = max(overflow.bottom, 0);
         if (isYAxis) {
-          availableWidth = width10 - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+          availableWidth = width10 - 2 * max(overflow.left, overflow.right);
         } else {
-          availableHeight = height10 - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+          availableHeight = height10 - 2 * max(overflow.top, overflow.bottom);
         }
       }
       await apply({
@@ -42022,7 +42773,7 @@ function getParentNode(node) {
 function getNearestOverflowAncestor(node) {
   const parentNode = getParentNode(node);
   if (isLastTraversableNode(parentNode)) {
-    return node.ownerDocument ? node.ownerDocument.body : node.body;
+    return (node.ownerDocument || node).body;
   }
   if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
     return parentNode;
@@ -42112,10 +42863,7 @@ function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
   if (isFixed === void 0) {
     isFixed = false;
   }
-  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
-    return false;
-  }
-  return isFixed;
+  return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow(element);
 }
 function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
   if (includeScale === void 0) {
@@ -42141,12 +42889,12 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   let y = (clientRect.top + visualOffsets.y) / scale2.y;
   let width10 = clientRect.width / scale2.x;
   let height10 = clientRect.height / scale2.y;
-  if (domElement) {
+  if (domElement && offsetParent) {
     const win = getWindow(domElement);
-    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    const offsetWin = isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
     let currentWin = win;
     let currentIFrame = getFrameElement(currentWin);
-    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+    while (currentIFrame && offsetWin !== currentWin) {
       const iframeScale = getScale(currentIFrame);
       const iframeRect = currentIFrame.getBoundingClientRect();
       const css = getComputedStyle2(currentIFrame);
@@ -42205,7 +42953,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   let scale2 = createCoords(1);
   const offsets = createCoords(0);
   const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+  if (isOffsetParentAnElement || !isFixed) {
     if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
       scroll = getNodeScroll(offsetParent);
     }
@@ -42225,15 +42973,14 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   };
 }
 function getClientRects(element) {
-  return Array.from(element.getClientRects());
+  return element.getClientRects ? Array.from(element.getClientRects()) : [];
 }
-function getDocumentRect(element) {
-  const html = getDocumentElement(element);
-  const scroll = getNodeScroll(element);
-  const body = element.ownerDocument.body;
+function getDocumentRect(html) {
+  const scroll = getNodeScroll(html);
+  const body = html.ownerDocument.body;
   const width10 = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
   const height10 = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
-  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(html);
   const y = -scroll.scrollTop;
   if (getComputedStyle2(body).direction === "rtl") {
     x += max(html.clientWidth, body.clientWidth) - width10;
@@ -42246,7 +42993,11 @@ function getDocumentRect(element) {
   };
 }
 var SCROLLBAR_MAX = 25;
-function getViewportRect(element, strategy) {
+function getViewportRect(element, strategy, rootBoundary) {
+  if (rootBoundary === void 0) {
+    rootBoundary = "viewport";
+  }
+  const isLayoutViewport = rootBoundary === "layoutViewport";
   const win = getWindow(element);
   const html = getDocumentElement(element);
   const visualViewport = win.visualViewport;
@@ -42255,12 +43006,19 @@ function getViewportRect(element, strategy) {
   let x = 0;
   let y = 0;
   if (visualViewport) {
-    width10 = visualViewport.width;
-    height10 = visualViewport.height;
-    const visualViewportBased = isWebKit();
-    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
-      x = visualViewport.offsetLeft;
-      y = visualViewport.offsetTop;
+    const layoutRelativeClientCoords = !isWebKit() || strategy === "fixed";
+    if (isLayoutViewport) {
+      if (!layoutRelativeClientCoords) {
+        x = -visualViewport.offsetLeft;
+        y = -visualViewport.offsetTop;
+      }
+    } else {
+      width10 = visualViewport.width;
+      height10 = visualViewport.height;
+      if (layoutRelativeClientCoords) {
+        x = visualViewport.offsetLeft;
+        y = visualViewport.offsetTop;
+      }
     }
   }
   const windowScrollbarX = getWindowScrollBarX(html);
@@ -42269,12 +43027,11 @@ function getViewportRect(element, strategy) {
     const body = doc.body;
     const bodyStyles = getComputedStyle(body);
     const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
-    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
-    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
-      width10 -= clippingStableScrollbarWidth;
+    const reservedWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+    const gutter = getComputedStyle(html).scrollbarGutter === "stable both-edges" ? reservedWidth / 2 : reservedWidth;
+    if (gutter <= SCROLLBAR_MAX) {
+      width10 -= gutter;
     }
-  } else if (windowScrollbarX <= SCROLLBAR_MAX) {
-    width10 += windowScrollbarX;
   }
   return {
     width: width10,
@@ -42287,7 +43044,7 @@ function getInnerBoundingClientRect(element, strategy) {
   const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
   const top = clientRect.top + element.clientTop;
   const left = clientRect.left + element.clientLeft;
-  const scale2 = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const scale2 = getScale(element);
   const width10 = element.clientWidth * scale2.x;
   const height10 = element.clientHeight * scale2.y;
   const x = left * scale2.x;
@@ -42301,8 +43058,8 @@ function getInnerBoundingClientRect(element, strategy) {
 }
 function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
   let rect;
-  if (clippingAncestor === "viewport") {
-    rect = getViewportRect(element, strategy);
+  if (clippingAncestor === "viewport" || clippingAncestor === "layoutViewport") {
+    rect = getViewportRect(element, strategy, clippingAncestor);
   } else if (clippingAncestor === "document") {
     rect = getDocumentRect(getDocumentElement(element));
   } else if (isElement(clippingAncestor)) {
@@ -42318,33 +43075,24 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
   }
   return rectToClientRect(rect);
 }
-function hasFixedPositionAncestor(element, stopNode) {
-  const parentNode = getParentNode(element);
-  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
-    return false;
-  }
-  return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
-}
 function getClippingElementAncestors(element, cache) {
   const cachedResult = cache.get(element);
   if (cachedResult) {
     return cachedResult;
   }
   let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
-  let currentContainingBlockComputedStyle = null;
+  let lastKeptComputedStyle = null;
   const elementIsFixed = getComputedStyle2(element).position === "fixed";
   let currentNode = elementIsFixed ? getParentNode(element) : element;
   while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
     const computedStyle = getComputedStyle2(currentNode);
     const currentNodeIsContaining = isContainingBlock(currentNode);
-    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
-      currentContainingBlockComputedStyle = null;
-    }
-    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    const lastPosition = lastKeptComputedStyle ? lastKeptComputedStyle.position : elementIsFixed ? "fixed" : "";
+    const shouldDropCurrentNode = !currentNodeIsContaining && (lastPosition === "fixed" || lastPosition === "absolute" && computedStyle.position === "static");
     if (shouldDropCurrentNode) {
       result = result.filter((ancestor) => ancestor !== currentNode);
     } else {
-      currentContainingBlockComputedStyle = computedStyle;
+      lastKeptComputedStyle = computedStyle;
     }
     currentNode = getParentNode(currentNode);
   }
@@ -42399,10 +43147,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     scrollTop: 0
   };
   const offsets = createCoords(0);
-  function setLeftRTLScrollbarOffset() {
-    offsets.x = getWindowScrollBarX(documentElement);
-  }
-  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+  if (isOffsetParentAnElement || !isFixed) {
     if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
       scroll = getNodeScroll(offsetParent);
     }
@@ -42410,12 +43155,10 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
       const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
       offsets.x = offsetRect.x + offsetParent.clientLeft;
       offsets.y = offsetRect.y + offsetParent.clientTop;
-    } else if (documentElement) {
-      setLeftRTLScrollbarOffset();
     }
   }
-  if (isFixed && !isOffsetParentAnElement && documentElement) {
-    setLeftRTLScrollbarOffset();
+  if (!isOffsetParentAnElement && documentElement) {
+    offsets.x = getWindowScrollBarX(documentElement);
   }
   const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
   const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
@@ -42499,7 +43242,7 @@ var platform = {
 function rectsAreEqual(a, b) {
   return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 }
-function observeMove(element, onMove) {
+function observeMove(element, onMove, ancestorResize) {
   let io = null;
   let timeoutId;
   const root = getDocumentElement(element);
@@ -42542,6 +43285,9 @@ function observeMove(element, onMove) {
     let isFirstUpdate = true;
     function handleObserve(entries) {
       const ratio = entries[0].intersectionRatio;
+      if (!rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+        return refresh();
+      }
       if (ratio !== threshold) {
         if (!isFirstUpdate) {
           return refresh();
@@ -42554,9 +43300,6 @@ function observeMove(element, onMove) {
           refresh(false, ratio);
         }
       }
-      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
-        refresh();
-      }
       isFirstUpdate = false;
     }
     try {
@@ -42570,8 +43313,14 @@ function observeMove(element, onMove) {
     }
     io.observe(element);
   }
+  const win = getWindow(element);
+  const handleResize = () => refresh(ancestorResize);
+  win.addEventListener("resize", handleResize);
   refresh(true);
-  return cleanup;
+  return () => {
+    win.removeEventListener("resize", handleResize);
+    cleanup();
+  };
 }
 function autoUpdate(reference, floating, update, options) {
   if (options === void 0) {
@@ -42587,12 +43336,10 @@ function autoUpdate(reference, floating, update, options) {
   const referenceEl = unwrapElement(reference);
   const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
   ancestors.forEach((ancestor) => {
-    ancestorScroll && ancestor.addEventListener("scroll", update, {
-      passive: true
-    });
+    ancestorScroll && ancestor.addEventListener("scroll", update);
     ancestorResize && ancestor.addEventListener("resize", update);
   });
-  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update, ancestorResize) : null;
   let reobserveFrame = -1;
   let resizeObserver = null;
   if (elementResize) {
@@ -42652,11 +43399,9 @@ var arrow2 = arrow;
 var limitShift2 = limitShift;
 var computePosition2 = (reference, floating, options) => {
   const cache = /* @__PURE__ */ new Map();
-  const mergedOptions = {
-    platform,
-    ...options
-  };
+  const mergedOptions = options != null ? options : {};
   const platformWithCache = {
+    ...platform,
     ...mergedOptions.platform,
     _c: cache
   };
@@ -42667,7 +43412,7 @@ var computePosition2 = (reference, floating, options) => {
 };
 
 // node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
-import * as React28 from "react";
+import * as React29 from "react";
 import { useLayoutEffect as useLayoutEffect3 } from "react";
 import * as ReactDOM3 from "react-dom";
 var isClient = typeof document !== "undefined";
@@ -42733,7 +43478,7 @@ function roundByDPR(element, value) {
   return Math.round(value * dpr) / dpr;
 }
 function useLatestRef(value) {
-  const ref = React28.useRef(value);
+  const ref = React29.useRef(value);
   index(() => {
     ref.current = value;
   });
@@ -42756,7 +43501,7 @@ function useFloating(options) {
     whileElementsMounted,
     open
   } = options;
-  const [data, setData] = React28.useState({
+  const [data, setData] = React29.useState({
     x: 0,
     y: 0,
     strategy,
@@ -42764,19 +43509,19 @@ function useFloating(options) {
     middlewareData: {},
     isPositioned: false
   });
-  const [latestMiddleware, setLatestMiddleware] = React28.useState(middleware);
+  const [latestMiddleware, setLatestMiddleware] = React29.useState(middleware);
   if (!deepEqual(latestMiddleware, middleware)) {
     setLatestMiddleware(middleware);
   }
-  const [_reference, _setReference] = React28.useState(null);
-  const [_floating, _setFloating] = React28.useState(null);
-  const setReference = React28.useCallback((node) => {
+  const [_reference, _setReference] = React29.useState(null);
+  const [_floating, _setFloating] = React29.useState(null);
+  const setReference = React29.useCallback((node) => {
     if (node !== referenceRef.current) {
       referenceRef.current = node;
       _setReference(node);
     }
   }, []);
-  const setFloating = React28.useCallback((node) => {
+  const setFloating = React29.useCallback((node) => {
     if (node !== floatingRef.current) {
       floatingRef.current = node;
       _setFloating(node);
@@ -42784,14 +43529,14 @@ function useFloating(options) {
   }, []);
   const referenceEl = externalReference || _reference;
   const floatingEl = externalFloating || _floating;
-  const referenceRef = React28.useRef(null);
-  const floatingRef = React28.useRef(null);
-  const dataRef = React28.useRef(data);
+  const referenceRef = React29.useRef(null);
+  const floatingRef = React29.useRef(null);
+  const dataRef = React29.useRef(data);
   const hasWhileElementsMounted = whileElementsMounted != null;
   const whileElementsMountedRef = useLatestRef(whileElementsMounted);
   const platformRef = useLatestRef(platform2);
   const openRef = useLatestRef(open);
-  const update = React28.useCallback(() => {
+  const update = React29.useCallback(() => {
     if (!referenceRef.current || !floatingRef.current) {
       return;
     }
@@ -42829,7 +43574,7 @@ function useFloating(options) {
       }));
     }
   }, [open]);
-  const isMountedRef = React28.useRef(false);
+  const isMountedRef = React29.useRef(false);
   index(() => {
     isMountedRef.current = true;
     return () => {
@@ -42846,17 +43591,17 @@ function useFloating(options) {
       update();
     }
   }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
-  const refs = React28.useMemo(() => ({
+  const refs = React29.useMemo(() => ({
     reference: referenceRef,
     floating: floatingRef,
     setReference,
     setFloating
   }), [setReference, setFloating]);
-  const elements = React28.useMemo(() => ({
+  const elements = React29.useMemo(() => ({
     reference: referenceEl,
     floating: floatingEl
   }), [referenceEl, floatingEl]);
-  const floatingStyles = React28.useMemo(() => {
+  const floatingStyles = React29.useMemo(() => {
     const initialStyles = {
       position: strategy,
       left: 0,
@@ -42882,7 +43627,7 @@ function useFloating(options) {
       top: y
     };
   }, [strategy, transform, elements.floating, data.x, data.y]);
-  return React28.useMemo(() => ({
+  return React29.useMemo(() => ({
     ...data,
     update,
     refs,
@@ -42977,30 +43722,10 @@ var arrow3 = (options, deps) => {
   };
 };
 
-// node_modules/@radix-ui/react-arrow/dist/index.mjs
-import * as React29 from "react";
-import { jsx as jsx28 } from "react/jsx-runtime";
-var NAME = "Arrow";
-var Arrow = React29.forwardRef((props, forwardedRef) => {
-  const { children, width: width10 = 10, height: height10 = 5, ...arrowProps } = props;
-  return /* @__PURE__ */ jsx28(
-    Primitive.svg,
-    {
-      ...arrowProps,
-      ref: forwardedRef,
-      width: width10,
-      height: height10,
-      viewBox: "0 0 30 10",
-      preserveAspectRatio: "none",
-      children: props.asChild ? children : /* @__PURE__ */ jsx28("polygon", { points: "0,0 30,0 15,10" })
-    }
-  );
-});
-Arrow.displayName = NAME;
-var Root = Arrow;
-
 // node_modules/@radix-ui/react-use-size/dist/index.mjs
 import * as React30 from "react";
+var __defProp17 = Object.defineProperty;
+var __name15 = (target, value) => __defProp17(target, "name", { value, configurable: true });
 function useSize(element) {
   const [size4, setSize] = React30.useState(void 0);
   useLayoutEffect2(() => {
@@ -43035,13 +43760,24 @@ function useSize(element) {
   }, [element]);
   return size4;
 }
+__name15(useSize, "useSize");
 
 // node_modules/@radix-ui/react-popper/dist/index.mjs
 import { jsx as jsx29 } from "react/jsx-runtime";
+var __defProp18 = Object.defineProperty;
+var __name16 = (target, value) => __defProp18(target, "name", { value, configurable: true });
+var Sticky = {
+  Partial: "partial",
+  Always: "always"
+};
+var UpdatePositionStrategy = {
+  Optimized: "optimized",
+  Always: "always"
+};
 var POPPER_NAME = "Popper";
 var [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME);
 var [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME);
-var Popper = (props) => {
+var Popper = /* @__PURE__ */ __name16((props) => {
   const { __scopePopper, children } = props;
   const [anchor, setAnchor] = React31.useState(null);
   const [placementState, setPlacementState] = React31.useState(void 0);
@@ -43056,11 +43792,10 @@ var Popper = (props) => {
       children
     }
   );
-};
-Popper.displayName = POPPER_NAME;
+}, "Popper");
 var ANCHOR_NAME = "PopperAnchor";
-var PopperAnchor = React31.forwardRef(
-  (props, forwardedRef) => {
+var PopperAnchor = /* @__PURE__ */ React31.forwardRef(
+  /* @__PURE__ */ __name16(function PopperAnchor2(props, forwardedRef) {
     const { __scopePopper, virtualRef, ...anchorProps } = props;
     const context = usePopperContext(ANCHOR_NAME, __scopePopper);
     const ref = React31.useRef(null);
@@ -43098,13 +43833,12 @@ var PopperAnchor = React31.forwardRef(
         ref: composedRefs
       }
     );
-  }
+  }, "PopperAnchor")
 );
-PopperAnchor.displayName = ANCHOR_NAME;
 var CONTENT_NAME = "PopperContent";
 var [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME);
-var PopperContent = React31.forwardRef(
-  (props, forwardedRef) => {
+var PopperContent = /* @__PURE__ */ React31.forwardRef(
+  /* @__PURE__ */ __name16(function PopperContent2(props, forwardedRef) {
     const {
       __scopePopper,
       side = "bottom",
@@ -43115,9 +43849,9 @@ var PopperContent = React31.forwardRef(
       avoidCollisions = true,
       collisionBoundary = [],
       collisionPadding: collisionPaddingProp = 0,
-      sticky = "partial",
+      sticky = Sticky.Partial,
       hideWhenDetached = false,
-      updatePositionStrategy = "optimized",
+      updatePositionStrategy = UpdatePositionStrategy.Optimized,
       onPlaced,
       ...contentProps
     } = props;
@@ -43142,12 +43876,12 @@ var PopperContent = React31.forwardRef(
       // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
       strategy: "fixed",
       placement: desiredPlacement,
-      whileElementsMounted: (...args) => {
+      whileElementsMounted: /* @__PURE__ */ __name16((...args) => {
         const cleanup = autoUpdate(...args, {
-          animationFrame: updatePositionStrategy === "always"
+          animationFrame: updatePositionStrategy === UpdatePositionStrategy.Always
         });
         return cleanup;
-      },
+      }, "whileElementsMounted"),
       elements: {
         reference: context.anchor
       },
@@ -43156,20 +43890,20 @@ var PopperContent = React31.forwardRef(
         avoidCollisions && shift3({
           mainAxis: true,
           crossAxis: false,
-          limiter: sticky === "partial" ? limitShift3() : void 0,
+          limiter: sticky === Sticky.Partial ? limitShift3() : void 0,
           ...detectOverflowOptions
         }),
         avoidCollisions && flip3({ ...detectOverflowOptions }),
         size3({
           ...detectOverflowOptions,
-          apply: ({ elements, rects, availableWidth, availableHeight }) => {
+          apply: /* @__PURE__ */ __name16(({ elements, rects, availableWidth, availableHeight }) => {
             const { width: anchorWidth, height: anchorHeight } = rects.reference;
             const contentStyle = elements.floating.style;
             contentStyle.setProperty("--radix-popper-available-width", `${availableWidth}px`);
             contentStyle.setProperty("--radix-popper-available-height", `${availableHeight}px`);
             contentStyle.setProperty("--radix-popper-anchor-width", `${anchorWidth}px`);
             contentStyle.setProperty("--radix-popper-anchor-height", `${anchorHeight}px`);
-          }
+          }, "apply")
         }),
         arrow4 && arrow3({ element: arrow4, padding: arrowPadding }),
         transformOrigin({ arrowWidth, arrowHeight }),
@@ -43251,9 +43985,10 @@ var PopperContent = React31.forwardRef(
                 ref: composedRefs,
                 style: {
                   ...contentProps.style,
-                  // if the PopperContent hasn't been placed yet (not all measurements done)
-                  // we prevent animations so that users's animation don't kick in too early referring wrong sides
-                  animation: !isPositioned ? "none" : void 0
+                  // if the PopperContent hasn't been placed yet (not all
+                  // measurements done) we prevent animations so that users'
+                  // animations don't kick in too early from the wrong sides.
+                  animation: !isPositioned ? "none" : contentProps.style?.animation
                 }
               }
             )
@@ -43261,68 +43996,13 @@ var PopperContent = React31.forwardRef(
         )
       }
     );
-  }
+  }, "PopperContent")
 );
-PopperContent.displayName = CONTENT_NAME;
-var ARROW_NAME = "PopperArrow";
-var OPPOSITE_SIDE = {
-  top: "bottom",
-  right: "left",
-  bottom: "top",
-  left: "right"
-};
-var PopperArrow = React31.forwardRef(function PopperArrow2(props, forwardedRef) {
-  const { __scopePopper, ...arrowProps } = props;
-  const contentContext = useContentContext(ARROW_NAME, __scopePopper);
-  const baseSide = OPPOSITE_SIDE[contentContext.placedSide];
-  return (
-    // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)
-    // doesn't report size as we'd expect on SVG elements.
-    // it reports their bounding box which is effectively the largest path inside the SVG.
-    /* @__PURE__ */ jsx29(
-      "span",
-      {
-        ref: contentContext.onArrowChange,
-        style: {
-          position: "absolute",
-          left: contentContext.arrowX,
-          top: contentContext.arrowY,
-          [baseSide]: 0,
-          transformOrigin: {
-            top: "",
-            right: "0 0",
-            bottom: "center 0",
-            left: "100% 0"
-          }[contentContext.placedSide],
-          transform: {
-            top: "translateY(100%)",
-            right: "translateY(50%) rotate(90deg) translateX(-50%)",
-            bottom: `rotate(180deg)`,
-            left: "translateY(50%) rotate(-90deg) translateX(50%)"
-          }[contentContext.placedSide],
-          visibility: contentContext.shouldHideArrow ? "hidden" : void 0
-        },
-        children: /* @__PURE__ */ jsx29(
-          Root,
-          {
-            ...arrowProps,
-            ref: forwardedRef,
-            style: {
-              ...arrowProps.style,
-              // ensures the element can be measured correctly (mostly for if SVG)
-              display: "block"
-            }
-          }
-        )
-      }
-    )
-  );
-});
-PopperArrow.displayName = ARROW_NAME;
 function isNotNull2(value) {
   return value !== null;
 }
-var transformOrigin = (options) => ({
+__name16(isNotNull2, "isNotNull");
+var transformOrigin = /* @__PURE__ */ __name16((options) => ({
   name: "transformOrigin",
   options,
   fn(data) {
@@ -43352,48 +44032,49 @@ var transformOrigin = (options) => ({
     }
     return { data: { x, y } };
   }
-});
+}), "transformOrigin");
 function getSideAndAlignFromPlacement(placement) {
   const [side, align = "center"] = placement.split("-");
   return [side, align];
 }
-var Root2 = Popper;
-var Anchor = PopperAnchor;
-var Content = PopperContent;
-var Arrow2 = PopperArrow;
+__name16(getSideAndAlignFromPlacement, "getSideAndAlignFromPlacement");
 
 // node_modules/@radix-ui/react-portal/dist/index.mjs
 import * as React32 from "react";
 import * as ReactDOM4 from "react-dom";
 import { jsx as jsx30 } from "react/jsx-runtime";
-var PORTAL_NAME = "Portal";
-var Portal = React32.forwardRef((props, forwardedRef) => {
-  const { container: containerProp, ...portalProps } = props;
-  const [mounted, setMounted] = React32.useState(false);
-  useLayoutEffect2(() => setMounted(true), []);
-  const container = containerProp || mounted && globalThis?.document?.body;
-  return container ? ReactDOM4.createPortal(/* @__PURE__ */ jsx30(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;
-});
-Portal.displayName = PORTAL_NAME;
+var __defProp19 = Object.defineProperty;
+var __name17 = (target, value) => __defProp19(target, "name", { value, configurable: true });
+var Portal = /* @__PURE__ */ React32.forwardRef(
+  /* @__PURE__ */ __name17(function Portal2(props, forwardedRef) {
+    const { container: containerProp, ...portalProps } = props;
+    const [mounted, setMounted] = React32.useState(false);
+    useLayoutEffect2(() => setMounted(true), []);
+    const container = containerProp || mounted && globalThis?.document?.body;
+    return container ? ReactDOM4.createPortal(/* @__PURE__ */ jsx30(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;
+  }, "Portal")
+);
 
 // node_modules/@radix-ui/react-presence/dist/index.mjs
 import * as React210 from "react";
 import * as React33 from "react";
+var __defProp20 = Object.defineProperty;
+var __name18 = (target, value) => __defProp20(target, "name", { value, configurable: true });
 function useStateMachine(initialState, machine) {
   return React33.useReducer((state, event) => {
     const nextState = machine[state][event];
     return nextState ?? state;
   }, initialState);
 }
-var Presence = (props) => {
+__name18(useStateMachine, "useStateMachine");
+var Presence = /* @__PURE__ */ __name18((props) => {
   const { present, children } = props;
   const presence = usePresence(present);
   const child = typeof children === "function" ? children({ present: presence.isPresent }) : React210.Children.only(children);
   const ref = useStableComposedRefs(presence.ref, getElementRef2(child));
   const forceMount = typeof children === "function";
   return forceMount || presence.isPresent ? React210.cloneElement(child, { ref }) : null;
-};
-Presence.displayName = "Presence";
+}, "Presence");
 function usePresence(present) {
   const [node, setNode] = React210.useState();
   const stylesRef = React210.useRef(null);
@@ -43449,7 +44130,7 @@ function usePresence(present) {
     if (node) {
       let timeoutId;
       const ownerWindow = node.ownerDocument.defaultView ?? window;
-      const handleAnimationEnd = (event) => {
+      const handleAnimationEnd = /* @__PURE__ */ __name18((event) => {
         const currentAnimationName = getAnimationName(stylesRef.current);
         const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
         if (event.target === node && isCurrentAnimation) {
@@ -43464,12 +44145,12 @@ function usePresence(present) {
             });
           }
         }
-      };
-      const handleAnimationStart = (event) => {
+      }, "handleAnimationEnd");
+      const handleAnimationStart = /* @__PURE__ */ __name18((event) => {
         if (event.target === node) {
           prevAnimationNameRef.current = getAnimationName(stylesRef.current);
         }
-      };
+      }, "handleAnimationStart");
       node.addEventListener("animationstart", handleAnimationStart);
       node.addEventListener("animationcancel", handleAnimationEnd);
       node.addEventListener("animationend", handleAnimationEnd);
@@ -43497,6 +44178,7 @@ function usePresence(present) {
     }, [])
   };
 }
+__name18(usePresence, "usePresence");
 function setRef2(ref, value) {
   if (typeof ref === "function") {
     return ref(value);
@@ -43504,6 +44186,7 @@ function setRef2(ref, value) {
     ref.current = value;
   }
 }
+__name18(setRef2, "setRef");
 function useStableComposedRefs(...refs) {
   const refsRef = React210.useRef(refs);
   refsRef.current = refs;
@@ -43531,9 +44214,11 @@ function useStableComposedRefs(...refs) {
     }
   }, []);
 }
+__name18(useStableComposedRefs, "useStableComposedRefs");
 function getAnimationName(styles) {
   return styles?.animationName || "none";
 }
+__name18(getAnimationName, "getAnimationName");
 function getElementRef2(element) {
   let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
   let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
@@ -43547,6 +44232,7 @@ function getElementRef2(element) {
   }
   return element.props.ref || element.ref;
 }
+__name18(getElementRef2, "getElementRef");
 
 // node_modules/@radix-ui/react-roving-focus/dist/index.mjs
 import * as React35 from "react";
@@ -43554,6 +44240,8 @@ import * as React35 from "react";
 // node_modules/@radix-ui/react-use-is-hydrated/dist/index.mjs
 import * as React211 from "react";
 import * as React34 from "react";
+var __defProp21 = Object.defineProperty;
+var __name19 = (target, value) => __defProp21(target, "name", { value, configurable: true });
 var _isHydrated = false;
 function useIsHydrated() {
   const [isHydrated, setIsHydrated] = React34.useState(_isHydrated);
@@ -43565,11 +44253,13 @@ function useIsHydrated() {
   }, []);
   return isHydrated;
 }
+__name19(useIsHydrated, "useIsHydrated");
 var useReactSyncExternalStore = React211[" useSyncExternalStore ".trim().toString()];
 function subscribe() {
   return () => {
   };
 }
+__name19(subscribe, "subscribe");
 function useIsHydratedModern() {
   return useReactSyncExternalStore(
     subscribe,
@@ -43577,10 +44267,13 @@ function useIsHydratedModern() {
     () => false
   );
 }
+__name19(useIsHydratedModern, "useIsHydratedModern");
 var useIsHydrated2 = typeof useReactSyncExternalStore === "function" ? useIsHydratedModern : useIsHydrated;
 
 // node_modules/@radix-ui/react-roving-focus/dist/index.mjs
 import { jsx as jsx31 } from "react/jsx-runtime";
+var __defProp22 = Object.defineProperty;
+var __name20 = (target, value) => __defProp22(target, "name", { value, configurable: true });
 var ENTRY_FOCUS = "rovingFocusGroup.onEntryFocus";
 var EVENT_OPTIONS2 = { bubbles: false, cancelable: true };
 var GROUP_NAME = "RovingFocusGroup";
@@ -43589,14 +44282,22 @@ var [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContext
   GROUP_NAME,
   [createCollectionScope]
 );
+var Orientation = {
+  Vertical: "vertical",
+  Horizontal: "horizontal"
+};
+var Direction = {
+  LTR: "ltr",
+  RTL: "rtl"
+};
 var [RovingFocusProvider, useRovingFocusContext] = createRovingFocusGroupContext(GROUP_NAME);
-var RovingFocusGroup = React35.forwardRef(
-  (props, forwardedRef) => {
+var RovingFocusGroup = /* @__PURE__ */ React35.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name20(function RovingFocusGroup2(props, forwardedRef) {
     return /* @__PURE__ */ jsx31(Collection.Provider, { scope: props.__scopeRovingFocusGroup, children: /* @__PURE__ */ jsx31(Collection.Slot, { scope: props.__scopeRovingFocusGroup, children: /* @__PURE__ */ jsx31(RovingFocusGroupImpl, { ...props, ref: forwardedRef }) }) });
-  }
+  }, "RovingFocusGroup")
 );
-RovingFocusGroup.displayName = GROUP_NAME;
-var RovingFocusGroupImpl = React35.forwardRef((props, forwardedRef) => {
+var RovingFocusGroupImpl = /* @__PURE__ */ React35.forwardRef(/* @__PURE__ */ __name20(function RovingFocusGroupImpl2(props, forwardedRef) {
   const {
     __scopeRovingFocusGroup,
     orientation: orientation2,
@@ -43685,10 +44386,11 @@ var RovingFocusGroupImpl = React35.forwardRef((props, forwardedRef) => {
       )
     }
   );
-});
+}, "RovingFocusGroupImpl"));
 var ITEM_NAME = "RovingFocusGroupItem";
-var RovingFocusGroupItem = React35.forwardRef(
-  (props, forwardedRef) => {
+var RovingFocusGroupItem = /* @__PURE__ */ React35.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name20(function RovingFocusGroupItem2(props, forwardedRef) {
     const {
       __scopeRovingFocusGroup,
       focusable = true,
@@ -43763,9 +44465,8 @@ var RovingFocusGroupItem = React35.forwardRef(
         )
       }
     );
-  }
+  }, "RovingFocusGroupItem")
 );
-RovingFocusGroupItem.displayName = ITEM_NAME;
 var MAP_KEY_TO_FOCUS_INTENT = {
   ArrowLeft: "prev",
   ArrowUp: "prev",
@@ -43777,15 +44478,21 @@ var MAP_KEY_TO_FOCUS_INTENT = {
   End: "last"
 };
 function getDirectionAwareKey(key, dir) {
-  if (dir !== "rtl") return key;
+  if (dir !== Direction.RTL) return key;
   return key === "ArrowLeft" ? "ArrowRight" : key === "ArrowRight" ? "ArrowLeft" : key;
 }
+__name20(getDirectionAwareKey, "getDirectionAwareKey");
 function getFocusIntent(event, orientation2, dir) {
   const key = getDirectionAwareKey(event.key, dir);
-  if (orientation2 === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key)) return void 0;
-  if (orientation2 === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key)) return void 0;
+  if (orientation2 === Orientation.Vertical && ["ArrowLeft", "ArrowRight"].includes(key)) {
+    return void 0;
+  }
+  if (orientation2 === Orientation.Horizontal && ["ArrowUp", "ArrowDown"].includes(key)) {
+    return void 0;
+  }
   return MAP_KEY_TO_FOCUS_INTENT[key];
 }
+__name20(getFocusIntent, "getFocusIntent");
 function focusFirst2(candidates, preventScroll = false) {
   const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
   for (const candidate of candidates) {
@@ -43794,11 +44501,11 @@ function focusFirst2(candidates, preventScroll = false) {
     if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
   }
 }
+__name20(focusFirst2, "focusFirst");
 function wrapArray(array, startIndex) {
   return array.map((_, index2) => array[(startIndex + index2) % array.length]);
 }
-var Root3 = RovingFocusGroup;
-var Item = RovingFocusGroupItem;
+__name20(wrapArray, "wrapArray");
 
 // node_modules/aria-hidden/dist/es2015/index.js
 var getDefaultParent = function(originalTarget) {
@@ -44643,6 +45350,12 @@ var Combination_default = ReactRemoveScroll;
 
 // node_modules/@radix-ui/react-menu/dist/index.mjs
 import { jsx as jsx32 } from "react/jsx-runtime";
+var __defProp23 = Object.defineProperty;
+var __name21 = (target, value) => __defProp23(target, "name", { value, configurable: true });
+var Direction2 = {
+  LTR: "ltr",
+  RTL: "rtl"
+};
 var SELECTION_KEYS = ["Enter", " "];
 var FIRST_KEYS = ["ArrowDown", "PageUp", "Home"];
 var LAST_KEYS = ["ArrowUp", "PageDown", "End"];
@@ -44666,7 +45379,7 @@ var usePopperScope = createPopperScope();
 var useRovingFocusGroupScope = createRovingFocusGroupScope();
 var [MenuProvider, useMenuContext] = createMenuContext(MENU_NAME);
 var [MenuRootProvider, useMenuRootContext] = createMenuContext(MENU_NAME);
-var Menu = (props) => {
+var Menu = /* @__PURE__ */ __name21((props) => {
   const { __scopeMenu, open = false, children, dir, onOpenChange, modal = true } = props;
   const popperScope = usePopperScope(__scopeMenu);
   const [content, setContent] = React43.useState(null);
@@ -44674,12 +45387,12 @@ var Menu = (props) => {
   const handleOpenChange = useCallbackRef(onOpenChange);
   const direction = useDirection(dir);
   React43.useEffect(() => {
-    const handleKeyDown = () => {
+    const handleKeyDown = /* @__PURE__ */ __name21(() => {
       isUsingKeyboardRef.current = true;
       document.addEventListener("pointerdown", handlePointer, { capture: true, once: true });
       document.addEventListener("pointermove", handlePointer, { capture: true, once: true });
-    };
-    const handlePointer = () => isUsingKeyboardRef.current = false;
+    }, "handleKeyDown");
+    const handlePointer = /* @__PURE__ */ __name21(() => isUsingKeyboardRef.current = false, "handlePointer");
     document.addEventListener("keydown", handleKeyDown, { capture: true });
     return () => {
       document.removeEventListener("keydown", handleKeyDown, { capture: true });
@@ -44691,11 +45404,11 @@ var Menu = (props) => {
     if (!open) {
       return;
     }
-    const handleBlur = () => handleOpenChange(false);
+    const handleBlur = /* @__PURE__ */ __name21(() => handleOpenChange(false), "handleBlur");
     window.addEventListener("blur", handleBlur);
     return () => window.removeEventListener("blur", handleBlur);
   }, [open, handleOpenChange]);
-  return /* @__PURE__ */ jsx32(Root2, { ...popperScope, children: /* @__PURE__ */ jsx32(
+  return /* @__PURE__ */ jsx32(Popper, { ...popperScope, children: /* @__PURE__ */ jsx32(
     MenuProvider,
     {
       scope: __scopeMenu,
@@ -44716,40 +45429,37 @@ var Menu = (props) => {
       )
     }
   ) });
-};
-Menu.displayName = MENU_NAME;
-var ANCHOR_NAME2 = "MenuAnchor";
-var MenuAnchor = React43.forwardRef(
-  (props, forwardedRef) => {
+}, "Menu");
+var MenuAnchor = /* @__PURE__ */ React43.forwardRef(
+  /* @__PURE__ */ __name21(function MenuAnchor2(props, forwardedRef) {
     const { __scopeMenu, ...anchorProps } = props;
     const popperScope = usePopperScope(__scopeMenu);
-    return /* @__PURE__ */ jsx32(Anchor, { ...popperScope, ...anchorProps, ref: forwardedRef });
-  }
+    return /* @__PURE__ */ jsx32(PopperAnchor, { ...popperScope, ...anchorProps, ref: forwardedRef });
+  }, "MenuAnchor")
 );
-MenuAnchor.displayName = ANCHOR_NAME2;
-var PORTAL_NAME2 = "MenuPortal";
-var [PortalProvider, usePortalContext] = createMenuContext(PORTAL_NAME2, {
+var PORTAL_NAME = "MenuPortal";
+var [PortalProvider, usePortalContext] = createMenuContext(PORTAL_NAME, {
   forceMount: void 0
 });
-var MenuPortal = (props) => {
+var MenuPortal = /* @__PURE__ */ __name21((props) => {
   const { __scopeMenu, forceMount, children, container } = props;
-  const context = useMenuContext(PORTAL_NAME2, __scopeMenu);
+  const context = useMenuContext(PORTAL_NAME, __scopeMenu);
   return /* @__PURE__ */ jsx32(PortalProvider, { scope: __scopeMenu, forceMount, children: /* @__PURE__ */ jsx32(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx32(Portal, { asChild: true, container, children }) }) });
-};
-MenuPortal.displayName = PORTAL_NAME2;
+}, "MenuPortal");
 var CONTENT_NAME2 = "MenuContent";
 var [MenuContentProvider, useMenuContentContext] = createMenuContext(CONTENT_NAME2);
-var MenuContent = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuContent = /* @__PURE__ */ React43.forwardRef(
+  /* @__PURE__ */ __name21(function MenuContent2(props, forwardedRef) {
     const portalContext = usePortalContext(CONTENT_NAME2, props.__scopeMenu);
     const { forceMount = portalContext.forceMount, ...contentProps } = props;
     const context = useMenuContext(CONTENT_NAME2, props.__scopeMenu);
     const rootContext = useMenuRootContext(CONTENT_NAME2, props.__scopeMenu);
     return /* @__PURE__ */ jsx32(Collection2.Provider, { scope: props.__scopeMenu, children: /* @__PURE__ */ jsx32(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx32(Collection2.Slot, { scope: props.__scopeMenu, children: rootContext.modal ? /* @__PURE__ */ jsx32(MenuRootContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ jsx32(MenuRootContentNonModal, { ...contentProps, ref: forwardedRef }) }) }) });
-  }
+  }, "MenuContent")
 );
-var MenuRootContentModal = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuRootContentModal = /* @__PURE__ */ React43.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name21(function MenuRootContentModal2(props, forwardedRef) {
     const context = useMenuContext(CONTENT_NAME2, props.__scopeMenu);
     const ref = React43.useRef(null);
     const composedRefs = useComposedRefs(forwardedRef, ref);
@@ -44773,9 +45483,9 @@ var MenuRootContentModal = React43.forwardRef(
         onDismiss: () => context.onOpenChange(false)
       }
     );
-  }
+  }, "MenuRootContentModal")
 );
-var MenuRootContentNonModal = React43.forwardRef((props, forwardedRef) => {
+var MenuRootContentNonModal = /* @__PURE__ */ React43.forwardRef(/* @__PURE__ */ __name21(function MenuRootContentNonModal2(props, forwardedRef) {
   const context = useMenuContext(CONTENT_NAME2, props.__scopeMenu);
   return /* @__PURE__ */ jsx32(
     MenuContentImpl,
@@ -44788,10 +45498,11 @@ var MenuRootContentNonModal = React43.forwardRef((props, forwardedRef) => {
       onDismiss: () => context.onOpenChange(false)
     }
   );
-});
+}, "MenuRootContentNonModal"));
 var Slot = createSlot("MenuContent.ScrollLock");
-var MenuContentImpl = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuContentImpl = /* @__PURE__ */ React43.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name21(function MenuContentImpl2(props, forwardedRef) {
     const {
       __scopeMenu,
       loop = false,
@@ -44806,6 +45517,7 @@ var MenuContentImpl = React43.forwardRef(
       onInteractOutside,
       onDismiss,
       disableOutsideScroll,
+      children,
       ...contentProps
     } = props;
     const context = useMenuContext(CONTENT_NAME2, __scopeMenu);
@@ -44815,16 +45527,33 @@ var MenuContentImpl = React43.forwardRef(
     const getItems = useCollection2(__scopeMenu);
     const [currentItemId, setCurrentItemId] = React43.useState(null);
     const contentRef = React43.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, contentRef, context.onContentChange);
+    const [branchNode, setBranchNode] = React43.useState(null);
+    useFocusScopeBranch(branchNode);
+    const { nodes: branchNodes, registry: branchRegistry } = useFocusScopeBranchRegistry();
+    const isModal = Boolean(trapFocus || disableOutsideScroll);
+    const composedRefs = useComposedRefs(
+      forwardedRef,
+      contentRef,
+      context.onContentChange,
+      setBranchNode
+    );
     const timerRef = React43.useRef(0);
     const searchRef = React43.useRef("");
     const pointerGraceTimerRef = React43.useRef(0);
     const pointerGraceIntentRef = React43.useRef(null);
     const pointerDirRef = React43.useRef("right");
     const lastPointerXRef = React43.useRef(0);
+    const shards = React43.useMemo(
+      () => disableOutsideScroll ? [contentRef, ...branchNodes.map((node) => ({ current: node }))] : [],
+      [contentRef, branchNodes, disableOutsideScroll]
+    );
     const ScrollLockWrapper = disableOutsideScroll ? Combination_default : React43.Fragment;
-    const scrollLockWrapperProps = disableOutsideScroll ? { as: Slot, allowPinchZoom: true } : void 0;
-    const handleTypeaheadSearch = (key) => {
+    const scrollLockWrapperProps = disableOutsideScroll ? {
+      as: Slot,
+      allowPinchZoom: true,
+      shards
+    } : void 0;
+    const handleTypeaheadSearch = /* @__PURE__ */ __name21((key) => {
       const search = searchRef.current + key;
       const items = getItems().filter((item) => !item.disabled);
       const currentItem = document.activeElement;
@@ -44832,15 +45561,15 @@ var MenuContentImpl = React43.forwardRef(
       const values = items.map((item) => item.textValue);
       const nextMatch = getNextMatch(values, search, currentMatch);
       const newItem = items.find((item) => item.textValue === nextMatch)?.ref.current;
-      (function updateSearch(value) {
+      (/* @__PURE__ */ __name21((function updateSearch(value) {
         searchRef.current = value;
         window.clearTimeout(timerRef.current);
         if (value !== "") timerRef.current = window.setTimeout(() => updateSearch(""), 1e3);
-      })(search);
+      }), "updateSearch"))(search);
       if (newItem) {
         setTimeout(() => newItem.focus());
       }
-    };
+    }, "handleTypeaheadSearch");
     React43.useEffect(() => {
       return () => window.clearTimeout(timerRef.current);
     }, []);
@@ -44883,6 +45612,7 @@ var MenuContentImpl = React43.forwardRef(
           {
             asChild: true,
             trapped: trapFocus,
+            branches: branchNodes,
             onMountAutoFocus: composeEventHandlers(onOpenAutoFocus, (event) => {
               event.preventDefault();
               contentRef.current?.focus({ preventScroll: true });
@@ -44899,7 +45629,7 @@ var MenuContentImpl = React43.forwardRef(
                 onInteractOutside,
                 onDismiss,
                 children: /* @__PURE__ */ jsx32(
-                  Root3,
+                  RovingFocusGroup,
                   {
                     asChild: true,
                     ...rovingFocusGroupScope,
@@ -44913,7 +45643,7 @@ var MenuContentImpl = React43.forwardRef(
                     }),
                     preventScrollOnEntryFocus: true,
                     children: /* @__PURE__ */ jsx32(
-                      Content,
+                      PopperContent,
                       {
                         role: "menu",
                         "aria-orientation": "vertical",
@@ -44959,7 +45689,8 @@ var MenuContentImpl = React43.forwardRef(
                               lastPointerXRef.current = event.clientX;
                             }
                           })
-                        )
+                        ),
+                        children: isModal ? /* @__PURE__ */ jsx32(FocusScopeBranchProvider, { value: branchRegistry, children }) : children
                       }
                     )
                   }
@@ -44970,36 +45701,20 @@ var MenuContentImpl = React43.forwardRef(
         ) })
       }
     );
-  }
-);
-MenuContent.displayName = CONTENT_NAME2;
-var GROUP_NAME2 = "MenuGroup";
-var MenuGroup = React43.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeMenu, ...groupProps } = props;
-    return /* @__PURE__ */ jsx32(Primitive.div, { role: "group", ...groupProps, ref: forwardedRef });
-  }
+  }, "MenuContentImpl")
 );
-MenuGroup.displayName = GROUP_NAME2;
-var LABEL_NAME = "MenuLabel";
-var MenuLabel = React43.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeMenu, ...labelProps } = props;
-    return /* @__PURE__ */ jsx32(Primitive.div, { ...labelProps, ref: forwardedRef });
-  }
-);
-MenuLabel.displayName = LABEL_NAME;
 var ITEM_NAME2 = "MenuItem";
 var ITEM_SELECT = "menu.itemSelect";
-var MenuItem = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuItem = /* @__PURE__ */ React43.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name21(function MenuItem2(props, forwardedRef) {
     const { disabled = false, onSelect, ...itemProps } = props;
     const ref = React43.useRef(null);
     const rootContext = useMenuRootContext(ITEM_NAME2, props.__scopeMenu);
     const contentContext = useMenuContentContext(ITEM_NAME2, props.__scopeMenu);
     const composedRefs = useComposedRefs(forwardedRef, ref);
     const isPointerDownRef = React43.useRef(false);
-    const handleSelect = () => {
+    const handleSelect = /* @__PURE__ */ __name21(() => {
       const menuItem = ref.current;
       if (!disabled && menuItem) {
         const itemSelectEvent = new CustomEvent(ITEM_SELECT, { bubbles: true, cancelable: true });
@@ -45011,7 +45726,7 @@ var MenuItem = React43.forwardRef(
           rootContext.onClose();
         }
       }
-    };
+    }, "handleSelect");
     return /* @__PURE__ */ jsx32(
       MenuItemImpl,
       {
@@ -45041,11 +45756,10 @@ var MenuItem = React43.forwardRef(
         })
       }
     );
-  }
+  }, "MenuItem")
 );
-MenuItem.displayName = ITEM_NAME2;
-var MenuItemImpl = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuItemImpl = /* @__PURE__ */ React43.forwardRef(
+  /* @__PURE__ */ __name21(function MenuItemImpl2(props, forwardedRef) {
     const { __scopeMenu, disabled = false, textValue, ...itemProps } = props;
     const contentContext = useMenuContentContext(ITEM_NAME2, __scopeMenu);
     const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);
@@ -45065,7 +45779,7 @@ var MenuItemImpl = React43.forwardRef(
         scope: __scopeMenu,
         disabled,
         textValue: textValue ?? textContent,
-        children: /* @__PURE__ */ jsx32(Item, { asChild: true, ...rovingFocusGroupScope, focusable: !disabled, children: /* @__PURE__ */ jsx32(
+        children: /* @__PURE__ */ jsx32(RovingFocusGroupItem, { asChild: true, ...rovingFocusGroupScope, focusable: !disabled, children: /* @__PURE__ */ jsx32(
           Primitive.div,
           {
             role: "menuitem",
@@ -45098,97 +45812,21 @@ var MenuItemImpl = React43.forwardRef(
         ) })
       }
     );
-  }
+  }, "MenuItemImpl")
 );
-var CHECKBOX_ITEM_NAME = "MenuCheckboxItem";
-var MenuCheckboxItem = React43.forwardRef(
-  (props, forwardedRef) => {
-    const { checked = false, onCheckedChange, ...checkboxItemProps } = props;
-    return /* @__PURE__ */ jsx32(ItemIndicatorProvider, { scope: props.__scopeMenu, checked, children: /* @__PURE__ */ jsx32(
-      MenuItem,
-      {
-        role: "menuitemcheckbox",
-        "aria-checked": isIndeterminate(checked) ? "mixed" : checked,
-        ...checkboxItemProps,
-        ref: forwardedRef,
-        "data-state": getCheckedState(checked),
-        onSelect: composeEventHandlers(
-          checkboxItemProps.onSelect,
-          () => onCheckedChange?.(isIndeterminate(checked) ? true : !checked),
-          { checkForDefaultPrevented: false }
-        )
-      }
-    ) });
-  }
-);
-MenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME;
 var RADIO_GROUP_NAME = "MenuRadioGroup";
 var [RadioGroupProvider, useRadioGroupContext] = createMenuContext(
   RADIO_GROUP_NAME,
-  { value: void 0, onValueChange: () => {
-  } }
-);
-var MenuRadioGroup = React43.forwardRef(
-  (props, forwardedRef) => {
-    const { value, onValueChange, ...groupProps } = props;
-    const handleValueChange = useCallbackRef(onValueChange);
-    return /* @__PURE__ */ jsx32(RadioGroupProvider, { scope: props.__scopeMenu, value, onValueChange: handleValueChange, children: /* @__PURE__ */ jsx32(MenuGroup, { ...groupProps, ref: forwardedRef }) });
-  }
+  { value: void 0, onValueChange: /* @__PURE__ */ __name21(() => {
+  }, "onValueChange") }
 );
-MenuRadioGroup.displayName = RADIO_GROUP_NAME;
-var RADIO_ITEM_NAME = "MenuRadioItem";
-var MenuRadioItem = React43.forwardRef(
-  (props, forwardedRef) => {
-    const { value, ...radioItemProps } = props;
-    const context = useRadioGroupContext(RADIO_ITEM_NAME, props.__scopeMenu);
-    const checked = value === context.value;
-    return /* @__PURE__ */ jsx32(ItemIndicatorProvider, { scope: props.__scopeMenu, checked, children: /* @__PURE__ */ jsx32(
-      MenuItem,
-      {
-        role: "menuitemradio",
-        "aria-checked": checked,
-        ...radioItemProps,
-        ref: forwardedRef,
-        "data-state": getCheckedState(checked),
-        onSelect: composeEventHandlers(
-          radioItemProps.onSelect,
-          () => context.onValueChange?.(value),
-          { checkForDefaultPrevented: false }
-        )
-      }
-    ) });
-  }
-);
-MenuRadioItem.displayName = RADIO_ITEM_NAME;
 var ITEM_INDICATOR_NAME = "MenuItemIndicator";
 var [ItemIndicatorProvider, useItemIndicatorContext] = createMenuContext(
   ITEM_INDICATOR_NAME,
   { checked: false }
 );
-var MenuItemIndicator = React43.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeMenu, forceMount, ...itemIndicatorProps } = props;
-    const indicatorContext = useItemIndicatorContext(ITEM_INDICATOR_NAME, __scopeMenu);
-    return /* @__PURE__ */ jsx32(
-      Presence,
-      {
-        present: forceMount || isIndeterminate(indicatorContext.checked) || indicatorContext.checked === true,
-        children: /* @__PURE__ */ jsx32(
-          Primitive.span,
-          {
-            ...itemIndicatorProps,
-            ref: forwardedRef,
-            "data-state": getCheckedState(indicatorContext.checked)
-          }
-        )
-      }
-    );
-  }
-);
-MenuItemIndicator.displayName = ITEM_INDICATOR_NAME;
-var SEPARATOR_NAME = "MenuSeparator";
-var MenuSeparator = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuSeparator = /* @__PURE__ */ React43.forwardRef(
+  /* @__PURE__ */ __name21(function MenuSeparator2(props, forwardedRef) {
     const { __scopeMenu, ...separatorProps } = props;
     return /* @__PURE__ */ jsx32(
       Primitive.div,
@@ -45199,21 +45837,11 @@ var MenuSeparator = React43.forwardRef(
         ref: forwardedRef
       }
     );
-  }
+  }, "MenuSeparator")
 );
-MenuSeparator.displayName = SEPARATOR_NAME;
-var ARROW_NAME2 = "MenuArrow";
-var MenuArrow = React43.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeMenu, ...arrowProps } = props;
-    const popperScope = usePopperScope(__scopeMenu);
-    return /* @__PURE__ */ jsx32(Arrow2, { ...popperScope, ...arrowProps, ref: forwardedRef });
-  }
-);
-MenuArrow.displayName = ARROW_NAME2;
 var SUB_NAME = "MenuSub";
 var [MenuSubProvider, useMenuSubContext] = createMenuContext(SUB_NAME);
-var MenuSub = (props) => {
+var MenuSub = /* @__PURE__ */ __name21((props) => {
   const { __scopeMenu, children, open = false, onOpenChange } = props;
   const parentMenuContext = useMenuContext(SUB_NAME, __scopeMenu);
   const popperScope = usePopperScope(__scopeMenu);
@@ -45224,7 +45852,7 @@ var MenuSub = (props) => {
     if (parentMenuContext.open === false) handleOpenChange(false);
     return () => handleOpenChange(false);
   }, [parentMenuContext.open, handleOpenChange]);
-  return /* @__PURE__ */ jsx32(Root2, { ...popperScope, children: /* @__PURE__ */ jsx32(
+  return /* @__PURE__ */ jsx32(Popper, { ...popperScope, children: /* @__PURE__ */ jsx32(
     MenuProvider,
     {
       scope: __scopeMenu,
@@ -45245,11 +45873,10 @@ var MenuSub = (props) => {
       )
     }
   ) });
-};
-MenuSub.displayName = SUB_NAME;
+}, "MenuSub");
 var SUB_TRIGGER_NAME = "MenuSubTrigger";
-var MenuSubTrigger = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuSubTrigger = /* @__PURE__ */ React43.forwardRef(
+  /* @__PURE__ */ __name21(function MenuSubTrigger2(props, forwardedRef) {
     const context = useMenuContext(SUB_TRIGGER_NAME, props.__scopeMenu);
     const rootContext = useMenuRootContext(SUB_TRIGGER_NAME, props.__scopeMenu);
     const subContext = useMenuSubContext(SUB_TRIGGER_NAME, props.__scopeMenu);
@@ -45351,12 +45978,11 @@ var MenuSubTrigger = React43.forwardRef(
         })
       }
     ) });
-  }
+  }, "MenuSubTrigger")
 );
-MenuSubTrigger.displayName = SUB_TRIGGER_NAME;
 var SUB_CONTENT_NAME = "MenuSubContent";
-var MenuSubContent = React43.forwardRef(
-  (props, forwardedRef) => {
+var MenuSubContent = /* @__PURE__ */ React43.forwardRef(
+  /* @__PURE__ */ __name21(function MenuSubContent2(props, forwardedRef) {
     const portalContext = usePortalContext(CONTENT_NAME2, props.__scopeMenu);
     const { forceMount = portalContext.forceMount, align = "start", ...subContentProps } = props;
     const context = useMenuContext(CONTENT_NAME2, props.__scopeMenu);
@@ -45372,7 +45998,7 @@ var MenuSubContent = React43.forwardRef(
         ...subContentProps,
         ref: composedRefs,
         align,
-        side: rootContext.dir === "rtl" ? "left" : "right",
+        side: rootContext.dir === Direction2.RTL ? "left" : "right",
         disableOutsidePointerEvents: false,
         disableOutsideScroll: false,
         trapFocus: false,
@@ -45399,18 +46025,20 @@ var MenuSubContent = React43.forwardRef(
         })
       }
     ) }) }) });
-  }
+  }, "MenuSubContent")
 );
-MenuSubContent.displayName = SUB_CONTENT_NAME;
 function getOpenState(open) {
   return open ? "open" : "closed";
 }
+__name21(getOpenState, "getOpenState");
 function isIndeterminate(checked) {
   return checked === "indeterminate";
 }
+__name21(isIndeterminate, "isIndeterminate");
 function getCheckedState(checked) {
   return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
 }
+__name21(getCheckedState, "getCheckedState");
 function focusFirst3(candidates) {
   const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
   for (const candidate of candidates) {
@@ -45419,9 +46047,11 @@ function focusFirst3(candidates) {
     if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
   }
 }
+__name21(focusFirst3, "focusFirst");
 function wrapArray2(array, startIndex) {
   return array.map((_, index2) => array[(startIndex + index2) % array.length]);
 }
+__name21(wrapArray2, "wrapArray");
 function getNextMatch(values, search, currentMatch) {
   const isRepeated = search.length > 1 && Array.from(search).every((char) => char === search[0]);
   const normalizedSearch = isRepeated ? search[0] : search;
@@ -45434,6 +46064,7 @@ function getNextMatch(values, search, currentMatch) {
   );
   return nextMatch !== currentMatch ? nextMatch : void 0;
 }
+__name21(getNextMatch, "getNextMatch");
 function isPointInPolygon(point, polygon2) {
   const { x, y } = point;
   let inside = false;
@@ -45449,33 +46080,22 @@ function isPointInPolygon(point, polygon2) {
   }
   return inside;
 }
+__name21(isPointInPolygon, "isPointInPolygon");
 function isPointerInGraceArea(event, area) {
   if (!area) return false;
   const cursorPos = { x: event.clientX, y: event.clientY };
   return isPointInPolygon(cursorPos, area);
 }
+__name21(isPointerInGraceArea, "isPointerInGraceArea");
 function whenMouse(handler) {
   return (event) => event.pointerType === "mouse" ? handler(event) : void 0;
 }
-var Root32 = Menu;
-var Anchor2 = MenuAnchor;
-var Portal2 = MenuPortal;
-var Content2 = MenuContent;
-var Group7 = MenuGroup;
-var Label = MenuLabel;
-var Item2 = MenuItem;
-var CheckboxItem = MenuCheckboxItem;
-var RadioGroup = MenuRadioGroup;
-var RadioItem = MenuRadioItem;
-var ItemIndicator = MenuItemIndicator;
-var Separator = MenuSeparator;
-var Arrow22 = MenuArrow;
-var Sub = MenuSub;
-var SubTrigger = MenuSubTrigger;
-var SubContent = MenuSubContent;
+__name21(whenMouse, "whenMouse");
 
 // node_modules/@radix-ui/react-dropdown-menu/dist/index.mjs
 import { jsx as jsx33 } from "react/jsx-runtime";
+var __defProp24 = Object.defineProperty;
+var __name22 = (target, value) => __defProp24(target, "name", { value, configurable: true });
 var DROPDOWN_MENU_NAME = "DropdownMenu";
 var [createDropdownMenuContext, createDropdownMenuScope] = createContextScope(
   DROPDOWN_MENU_NAME,
@@ -45483,7 +46103,7 @@ var [createDropdownMenuContext, createDropdownMenuScope] = createContextScope(
 );
 var useMenuScope = createMenuScope();
 var [DropdownMenuProvider, useDropdownMenuContext] = createDropdownMenuContext(DROPDOWN_MENU_NAME);
-var DropdownMenu = (props) => {
+var DropdownMenu = /* @__PURE__ */ __name22((props) => {
   const {
     __scopeDropdownMenu,
     children,
@@ -45512,19 +46132,19 @@ var DropdownMenu = (props) => {
       onOpenChange: setOpen,
       onOpenToggle: React44.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
       modal,
-      children: /* @__PURE__ */ jsx33(Root32, { ...menuScope, open, onOpenChange: setOpen, dir, modal, children })
+      children: /* @__PURE__ */ jsx33(Menu, { ...menuScope, open, onOpenChange: setOpen, dir, modal, children })
     }
   );
-};
-DropdownMenu.displayName = DROPDOWN_MENU_NAME;
+}, "DropdownMenu");
 var TRIGGER_NAME = "DropdownMenuTrigger";
-var DropdownMenuTrigger = React44.forwardRef(
-  (props, forwardedRef) => {
+var DropdownMenuTrigger = /* @__PURE__ */ React44.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name22(function DropdownMenuTrigger2(props, forwardedRef) {
     const { __scopeDropdownMenu, disabled = false, ...triggerProps } = props;
     const context = useDropdownMenuContext(TRIGGER_NAME, __scopeDropdownMenu);
     const menuScope = useMenuScope(__scopeDropdownMenu);
     const composedRefs = useComposedRefs(forwardedRef, context.triggerRef);
-    return /* @__PURE__ */ jsx33(Anchor2, { asChild: true, ...menuScope, children: /* @__PURE__ */ jsx33(
+    return /* @__PURE__ */ jsx33(MenuAnchor, { asChild: true, ...menuScope, children: /* @__PURE__ */ jsx33(
       Primitive.button,
       {
         type: "button",
@@ -45551,25 +46171,23 @@ var DropdownMenuTrigger = React44.forwardRef(
         })
       }
     ) });
-  }
+  }, "DropdownMenuTrigger")
 );
-DropdownMenuTrigger.displayName = TRIGGER_NAME;
-var PORTAL_NAME3 = "DropdownMenuPortal";
-var DropdownMenuPortal = (props) => {
+var DropdownMenuPortal = /* @__PURE__ */ __name22((props) => {
   const { __scopeDropdownMenu, ...portalProps } = props;
   const menuScope = useMenuScope(__scopeDropdownMenu);
-  return /* @__PURE__ */ jsx33(Portal2, { ...menuScope, ...portalProps });
-};
-DropdownMenuPortal.displayName = PORTAL_NAME3;
+  return /* @__PURE__ */ jsx33(MenuPortal, { ...menuScope, ...portalProps });
+}, "DropdownMenuPortal");
 var CONTENT_NAME3 = "DropdownMenuContent";
-var DropdownMenuContent = React44.forwardRef(
-  (props, forwardedRef) => {
+var DropdownMenuContent = /* @__PURE__ */ React44.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name22(function DropdownMenuContent2(props, forwardedRef) {
     const { __scopeDropdownMenu, ...contentProps } = props;
     const context = useDropdownMenuContext(CONTENT_NAME3, __scopeDropdownMenu);
     const menuScope = useMenuScope(__scopeDropdownMenu);
     const hasInteractedOutsideRef = React44.useRef(false);
     return /* @__PURE__ */ jsx33(
-      Content2,
+      MenuContent,
       {
         id: context.contentId,
         "aria-labelledby": context.triggerId,
@@ -45600,81 +46218,22 @@ var DropdownMenuContent = React44.forwardRef(
         }
       }
     );
-  }
-);
-DropdownMenuContent.displayName = CONTENT_NAME3;
-var GROUP_NAME3 = "DropdownMenuGroup";
-var DropdownMenuGroup = React44.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeDropdownMenu, ...groupProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ jsx33(Group7, { ...menuScope, ...groupProps, ref: forwardedRef });
-  }
-);
-DropdownMenuGroup.displayName = GROUP_NAME3;
-var LABEL_NAME2 = "DropdownMenuLabel";
-var DropdownMenuLabel = React44.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeDropdownMenu, ...labelProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ jsx33(Label, { ...menuScope, ...labelProps, ref: forwardedRef });
-  }
+  }, "DropdownMenuContent")
 );
-DropdownMenuLabel.displayName = LABEL_NAME2;
-var ITEM_NAME3 = "DropdownMenuItem";
-var DropdownMenuItem = React44.forwardRef(
-  (props, forwardedRef) => {
+var DropdownMenuItem = /* @__PURE__ */ React44.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ __name22(function DropdownMenuItem2(props, forwardedRef) {
     const { __scopeDropdownMenu, ...itemProps } = props;
     const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ jsx33(Item2, { ...menuScope, ...itemProps, ref: forwardedRef });
-  }
+    return /* @__PURE__ */ jsx33(MenuItem, { ...menuScope, ...itemProps, ref: forwardedRef });
+  }, "DropdownMenuItem")
 );
-DropdownMenuItem.displayName = ITEM_NAME3;
-var CHECKBOX_ITEM_NAME2 = "DropdownMenuCheckboxItem";
-var DropdownMenuCheckboxItem = React44.forwardRef((props, forwardedRef) => {
-  const { __scopeDropdownMenu, ...checkboxItemProps } = props;
-  const menuScope = useMenuScope(__scopeDropdownMenu);
-  return /* @__PURE__ */ jsx33(CheckboxItem, { ...menuScope, ...checkboxItemProps, ref: forwardedRef });
-});
-DropdownMenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME2;
-var RADIO_GROUP_NAME2 = "DropdownMenuRadioGroup";
-var DropdownMenuRadioGroup = React44.forwardRef((props, forwardedRef) => {
-  const { __scopeDropdownMenu, ...radioGroupProps } = props;
-  const menuScope = useMenuScope(__scopeDropdownMenu);
-  return /* @__PURE__ */ jsx33(RadioGroup, { ...menuScope, ...radioGroupProps, ref: forwardedRef });
-});
-DropdownMenuRadioGroup.displayName = RADIO_GROUP_NAME2;
-var RADIO_ITEM_NAME2 = "DropdownMenuRadioItem";
-var DropdownMenuRadioItem = React44.forwardRef((props, forwardedRef) => {
-  const { __scopeDropdownMenu, ...radioItemProps } = props;
-  const menuScope = useMenuScope(__scopeDropdownMenu);
-  return /* @__PURE__ */ jsx33(RadioItem, { ...menuScope, ...radioItemProps, ref: forwardedRef });
-});
-DropdownMenuRadioItem.displayName = RADIO_ITEM_NAME2;
-var INDICATOR_NAME = "DropdownMenuItemIndicator";
-var DropdownMenuItemIndicator = React44.forwardRef((props, forwardedRef) => {
-  const { __scopeDropdownMenu, ...itemIndicatorProps } = props;
-  const menuScope = useMenuScope(__scopeDropdownMenu);
-  return /* @__PURE__ */ jsx33(ItemIndicator, { ...menuScope, ...itemIndicatorProps, ref: forwardedRef });
-});
-DropdownMenuItemIndicator.displayName = INDICATOR_NAME;
-var SEPARATOR_NAME2 = "DropdownMenuSeparator";
-var DropdownMenuSeparator = React44.forwardRef((props, forwardedRef) => {
+var DropdownMenuSeparator = /* @__PURE__ */ React44.forwardRef(/* @__PURE__ */ __name22(function DropdownMenuSeparator2(props, forwardedRef) {
   const { __scopeDropdownMenu, ...separatorProps } = props;
   const menuScope = useMenuScope(__scopeDropdownMenu);
-  return /* @__PURE__ */ jsx33(Separator, { ...menuScope, ...separatorProps, ref: forwardedRef });
-});
-DropdownMenuSeparator.displayName = SEPARATOR_NAME2;
-var ARROW_NAME3 = "DropdownMenuArrow";
-var DropdownMenuArrow = React44.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeDropdownMenu, ...arrowProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ jsx33(Arrow22, { ...menuScope, ...arrowProps, ref: forwardedRef });
-  }
-);
-DropdownMenuArrow.displayName = ARROW_NAME3;
-var DropdownMenuSub = (props) => {
+  return /* @__PURE__ */ jsx33(MenuSeparator, { ...menuScope, ...separatorProps, ref: forwardedRef });
+}, "DropdownMenuSeparator"));
+var DropdownMenuSub = /* @__PURE__ */ __name22((props) => {
   const { __scopeDropdownMenu, children, open: openProp, onOpenChange, defaultOpen } = props;
   const menuScope = useMenuScope(__scopeDropdownMenu);
   const [open, setOpen] = useControllableState({
@@ -45683,21 +46242,18 @@ var DropdownMenuSub = (props) => {
     onChange: onOpenChange,
     caller: "DropdownMenuSub"
   });
-  return /* @__PURE__ */ jsx33(Sub, { ...menuScope, open, onOpenChange: setOpen, children });
-};
-var SUB_TRIGGER_NAME2 = "DropdownMenuSubTrigger";
-var DropdownMenuSubTrigger = React44.forwardRef((props, forwardedRef) => {
+  return /* @__PURE__ */ jsx33(MenuSub, { ...menuScope, open, onOpenChange: setOpen, children });
+}, "DropdownMenuSub");
+var DropdownMenuSubTrigger = /* @__PURE__ */ React44.forwardRef(/* @__PURE__ */ __name22(function DropdownMenuSubTrigger2(props, forwardedRef) {
   const { __scopeDropdownMenu, ...subTriggerProps } = props;
   const menuScope = useMenuScope(__scopeDropdownMenu);
-  return /* @__PURE__ */ jsx33(SubTrigger, { ...menuScope, ...subTriggerProps, ref: forwardedRef });
-});
-DropdownMenuSubTrigger.displayName = SUB_TRIGGER_NAME2;
-var SUB_CONTENT_NAME2 = "DropdownMenuSubContent";
-var DropdownMenuSubContent = React44.forwardRef((props, forwardedRef) => {
+  return /* @__PURE__ */ jsx33(MenuSubTrigger, { ...menuScope, ...subTriggerProps, ref: forwardedRef });
+}, "DropdownMenuSubTrigger"));
+var DropdownMenuSubContent = /* @__PURE__ */ React44.forwardRef(/* @__PURE__ */ __name22(function DropdownMenuSubContent2(props, forwardedRef) {
   const { __scopeDropdownMenu, ...subContentProps } = props;
   const menuScope = useMenuScope(__scopeDropdownMenu);
   return /* @__PURE__ */ jsx33(
-    SubContent,
+    MenuSubContent,
     {
       ...menuScope,
       ...subContentProps,
@@ -45715,17 +46271,7 @@ var DropdownMenuSubContent = React44.forwardRef((props, forwardedRef) => {
       }
     }
   );
-});
-DropdownMenuSubContent.displayName = SUB_CONTENT_NAME2;
-var Root22 = DropdownMenu;
-var Trigger = DropdownMenuTrigger;
-var Portal22 = DropdownMenuPortal;
-var Content22 = DropdownMenuContent;
-var Item22 = DropdownMenuItem;
-var Separator2 = DropdownMenuSeparator;
-var Sub2 = DropdownMenuSub;
-var SubTrigger2 = DropdownMenuSubTrigger;
-var SubContent2 = DropdownMenuSubContent;
+}, "DropdownMenuSubContent"));
 
 // src/components/AppearanceMenu.tsx
 import { useState as useState36 } from "react";
@@ -45838,10 +46384,10 @@ var AppearanceMenu = () => {
   const [appearanceSubOpen, setAppearanceSubOpen] = useState36(false);
   const [hoveredItem, setHoveredItem] = useState36(null);
   return /* @__PURE__ */ jsxs8(Fragment11, { children: [
-    /* @__PURE__ */ jsx35(Separator2, { style: separatorStyles }),
-    /* @__PURE__ */ jsxs8(Sub2, { onOpenChange: setAppearanceSubOpen, children: [
+    /* @__PURE__ */ jsx35(DropdownMenuSeparator, { style: separatorStyles }),
+    /* @__PURE__ */ jsxs8(DropdownMenuSub, { onOpenChange: setAppearanceSubOpen, children: [
       /* @__PURE__ */ jsxs8(
-        SubTrigger2,
+        DropdownMenuSubTrigger,
         {
           style: {
             ...itemStyles,
@@ -45868,15 +46414,15 @@ var AppearanceMenu = () => {
           ]
         }
       ),
-      /* @__PURE__ */ jsx35(Portal22, { children: /* @__PURE__ */ jsxs8(
-        SubContent2,
+      /* @__PURE__ */ jsx35(DropdownMenuPortal, { children: /* @__PURE__ */ jsxs8(
+        DropdownMenuSubContent,
         {
           style: { ...contentStyles, marginLeft: -2 },
           collisionPadding: 10,
           avoidCollisions: true,
           children: [
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -45896,9 +46442,9 @@ var AppearanceMenu = () => {
                 ]
               }
             ),
-            /* @__PURE__ */ jsx35(Separator2, { style: separatorStyles }),
+            /* @__PURE__ */ jsx35(DropdownMenuSeparator, { style: separatorStyles }),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -45919,7 +46465,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -45940,7 +46486,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -45961,7 +46507,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -45982,7 +46528,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -46003,7 +46549,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -46027,7 +46573,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -46048,7 +46594,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -46069,7 +46615,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -46090,7 +46636,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -46111,7 +46657,7 @@ var AppearanceMenu = () => {
               }
             ),
             /* @__PURE__ */ jsxs8(
-              Item22,
+              DropdownMenuItem,
               {
                 style: {
                   ...itemStyles,
@@ -46237,10 +46783,10 @@ var ContextMenu = ({
         width: 0,
         height: 0
       },
-      children: /* @__PURE__ */ jsxs9(Root22, { open: true, modal: false, children: [
-        /* @__PURE__ */ jsx36(Trigger, { asChild: true, children: /* @__PURE__ */ jsx36("div", { style: { position: "absolute", width: 1, height: 1 } }) }),
-        /* @__PURE__ */ jsx36(Portal22, { children: /* @__PURE__ */ jsxs9(
-          Content22,
+      children: /* @__PURE__ */ jsxs9(DropdownMenu, { open: true, modal: false, children: [
+        /* @__PURE__ */ jsx36(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx36("div", { style: { position: "absolute", width: 1, height: 1 } }) }),
+        /* @__PURE__ */ jsx36(DropdownMenuPortal, { children: /* @__PURE__ */ jsxs9(
+          DropdownMenuContent,
           {
             style: contentStyles2,
             collisionPadding: 10,
@@ -46248,9 +46794,9 @@ var ContextMenu = ({
             sideOffset: 0,
             align: "start",
             children: [
-              /* @__PURE__ */ jsxs9(Sub2, { onOpenChange: setCameraSubOpen, children: [
+              /* @__PURE__ */ jsxs9(DropdownMenuSub, { onOpenChange: setCameraSubOpen, children: [
                 /* @__PURE__ */ jsxs9(
-                  SubTrigger2,
+                  DropdownMenuSubTrigger,
                   {
                     style: {
                       ...itemStyles2,
@@ -46286,14 +46832,14 @@ var ContextMenu = ({
                     ]
                   }
                 ),
-                /* @__PURE__ */ jsx36(Portal22, { children: /* @__PURE__ */ jsx36(
-                  SubContent2,
+                /* @__PURE__ */ jsx36(DropdownMenuPortal, { children: /* @__PURE__ */ jsx36(
+                  DropdownMenuSubContent,
                   {
                     style: { ...contentStyles2, marginLeft: -2 },
                     collisionPadding: 10,
                     avoidCollisions: true,
                     children: cameraOptions.map((option) => /* @__PURE__ */ jsxs9(
-                      Item22,
+                      DropdownMenuItem,
                       {
                         style: {
                           ...itemStyles2,
@@ -46318,7 +46864,7 @@ var ContextMenu = ({
                 ) })
               ] }),
               /* @__PURE__ */ jsxs9(
-                Item22,
+                DropdownMenuItem,
                 {
                   style: {
                     ...itemStyles2,
@@ -46339,7 +46885,7 @@ var ContextMenu = ({
                 }
               ),
               /* @__PURE__ */ jsxs9(
-                Item22,
+                DropdownMenuItem,
                 {
                   style: {
                     ...itemStyles2,
@@ -46362,9 +46908,9 @@ var ContextMenu = ({
                 }
               ),
               /* @__PURE__ */ jsx36(AppearanceMenu, {}),
-              /* @__PURE__ */ jsx36(Separator2, { style: separatorStyles2 }),
+              /* @__PURE__ */ jsx36(DropdownMenuSeparator, { style: separatorStyles2 }),
               /* @__PURE__ */ jsx36(
-                Item22,
+                DropdownMenuItem,
                 {
                   style: {
                     ...itemStyles2,
@@ -46378,9 +46924,9 @@ var ContextMenu = ({
                   children: /* @__PURE__ */ jsx36("span", { style: { display: "flex", alignItems: "center" }, children: "Download GLTF" })
                 }
               ),
-              /* @__PURE__ */ jsx36(Separator2, { style: separatorStyles2 }),
+              /* @__PURE__ */ jsx36(DropdownMenuSeparator, { style: separatorStyles2 }),
               /* @__PURE__ */ jsxs9(
-                Item22,
+                DropdownMenuItem,
                 {
                   style: {
                     ...itemStyles2,
@@ -46415,9 +46961,9 @@ var ContextMenu = ({
                   ]
                 }
               ),
-              /* @__PURE__ */ jsx36(Separator2, { style: separatorStyles2 }),
+              /* @__PURE__ */ jsx36(DropdownMenuSeparator, { style: separatorStyles2 }),
               /* @__PURE__ */ jsxs9(
-                Item22,
+                DropdownMenuItem,
                 {
                   style: {
                     ...itemStyles2,
@@ -46444,7 +46990,7 @@ var ContextMenu = ({
                   ]
                 }
               ),
-              /* @__PURE__ */ jsx36(Separator2, { style: separatorStyles2 }),
+              /* @__PURE__ */ jsx36(DropdownMenuSeparator, { style: separatorStyles2 }),
               /* @__PURE__ */ jsx36(
                 "div",
                 {
@@ -46483,14 +47029,14 @@ var ContextMenu = ({
 };
 
 // src/components/KeyboardShortcutsDialog.tsx
-import { useEffect as useEffect47, useMemo as useMemo30, useRef as useRef27, useState as useState38 } from "react";
+import { useEffect as useEffect47, useMemo as useMemo33, useRef as useRef28, useState as useState38 } from "react";
 import { jsx as jsx37, jsxs as jsxs10 } from "react/jsx-runtime";
 var KeyboardShortcutsDialog = ({
   open,
   onClose
 }) => {
   const [query, setQuery] = useState38("");
-  const inputRef = useRef27(null);
+  const inputRef = useRef28(null);
   const hotkeys = useHotkeyRegistry();
   useEffect47(() => {
     if (!open) return void 0;
@@ -46510,7 +47056,7 @@ var KeyboardShortcutsDialog = ({
       }, 0);
     }
   }, [open]);
-  const filteredHotkeys = useMemo30(() => {
+  const filteredHotkeys = useMemo33(() => {
     const normalizedQuery = query.trim().toLowerCase();
     if (!normalizedQuery) {
       return hotkeys;
@@ -46686,7 +47232,7 @@ var CadViewerInner = (props) => {
     const stored = window.localStorage.getItem("cadViewerEngine");
     return stored === "jscad" || stored === "manifold" ? stored : "manifold";
   });
-  const containerRef = useRef28(null);
+  const containerRef = useRef29(null);
   const [isKeyboardShortcutsDialogOpen, setIsKeyboardShortcutsDialogOpen] = useState39(false);
   const [autoRotate, setAutoRotate] = useState39(() => {
     const stored = window.localStorage.getItem("cadViewerAutoRotate");
@@ -46700,7 +47246,7 @@ var CadViewerInner = (props) => {
   const { cameraType, setCameraType } = useCameraController();
   const { visibility, setLayerVisibility } = useLayerVisibility();
   const { showToast } = useToast();
-  const cameraControllerRef = useRef28(null);
+  const cameraControllerRef = useRef29(null);
   const externalCameraControllerReady = props.onCameraControllerReady;
   const {
     menuVisible,
@@ -46709,10 +47255,10 @@ var CadViewerInner = (props) => {
     contextMenuEventHandlers,
     setMenuVisible
   } = useContextMenu({ containerRef });
-  const autoRotateUserToggledRef = useRef28(autoRotateUserToggled);
+  const autoRotateUserToggledRef = useRef29(autoRotateUserToggled);
   autoRotateUserToggledRef.current = autoRotateUserToggled;
-  const isAnimatingRef = useRef28(false);
-  const lastPresetSelectTime = useRef28(0);
+  const isAnimatingRef = useRef29(false);
+  const lastPresetSelectTime = useRef29(0);
   const PRESET_COOLDOWN = 1e3;
   const handleUserInteraction = useCallback25(() => {
     if (isAnimatingRef.current || Date.now() - lastPresetSelectTime.current < PRESET_COOLDOWN) {
@@ -47225,10 +47771,10 @@ async function convertCircuitJsonTo3dSvg(circuitJson, options = {}) {
 
 // src/hooks/exporter/gltf.ts
 import { GLTFExporter as GLTFExporter3 } from "three-stdlib";
-import { useEffect as useEffect49, useState as useState40, useMemo as useMemo31, useCallback as useCallback26 } from "react";
+import { useEffect as useEffect49, useState as useState40, useMemo as useMemo34, useCallback as useCallback26 } from "react";
 function useSaveGltfAs(options = {}) {
   const parse2 = useParser(options);
-  const link = useMemo31(() => document.createElement("a"), []);
+  const link = useMemo34(() => document.createElement("a"), []);
   const saveAs = async (filename) => {
     const name = filename ?? options.filename ?? "";
     if (options.binary == null) options.binary = name.endsWith(".glb");
@@ -47263,7 +47809,7 @@ function useExportGltfUrl(options = {}) {
   return [ref, url, error];
 }
 function useParser(options = {}) {
-  const exporter = useMemo31(() => new GLTFExporter3(), []);
+  const exporter = useMemo34(() => new GLTFExporter3(), []);
   return (instance) => {
     const { promise, resolve, reject } = Promise.withResolvers();
     exporter.parse(