@rfkit/charts 1.9.1 → 1.10.1

package/index.js

@@ -1167,7 +1167,7 @@ var __webpack_modules__ = {
 }
 
 [data-rfkit-charts-root] .translate-x-0 {
-  --tw-translate-x: 0;
+  --tw-translate-x: 0px;
   translate: var(--tw-translate-x) var(--tw-translate-y);
 }
 
@@ -1182,7 +1182,7 @@ var __webpack_modules__ = {
 }
 
 [data-rfkit-charts-root] .translate-y-0 {
-  --tw-translate-y: 0;
+  --tw-translate-y: 0px;
   translate: var(--tw-translate-x) var(--tw-translate-y);
 }
 
@@ -3001,7 +3001,7 @@ var __webpack_modules__ = {
 }
 
 [data-rfkit-charts-root] .data-\\[state\\=unchecked\\]\\:translate-x-0[data-state="unchecked"] {
-  --tw-translate-x: 0;
+  --tw-translate-x: 0px;
   translate: var(--tw-translate-x) var(--tw-translate-y);
 }
 
@@ -6560,6 +6560,15 @@ function createChartRuntime(initialState) {
     if (currentGlobalID) runtimeRegistry.set(currentGlobalID, runtime);
     return runtime;
 }
+const scheduleRuntimeCleanup = (cleanup)=>{
+    let cancelled = false;
+    queueMicrotask(()=>{
+        if (!cancelled) cleanup();
+    });
+    return ()=>{
+        cancelled = true;
+    };
+};
 function useAppContext() {
     const context = (0, __WEBPACK_EXTERNAL_MODULE_react__.useContext)(store_context);
     if (!context) throw new Error('useStore must be used within a StoreProvider');
@@ -6604,6 +6613,7 @@ const Store = (props)=>{
     const { dispatch, store } = runtime;
     const globalID = (0, __WEBPACK_EXTERNAL_MODULE_react__.useSyncExternalStore)(store.subscribe, ()=>store.getState().globalID, ()=>store.getState().globalID);
     const globalIDRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(globalID);
+    const cancelRuntimeCleanupRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
     (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
         globalIDRef.current = globalID;
         runtime.setGlobalID(globalID);
@@ -6611,12 +6621,19 @@ const Store = (props)=>{
         globalID,
         runtime
     ]);
-    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>()=>{
-            runtime.destroy();
-            releaseChartsRuntimeOwners([
-                globalIDRef.current
-            ]);
-        }, [
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        cancelRuntimeCleanupRef.current?.();
+        cancelRuntimeCleanupRef.current = null;
+        return ()=>{
+            cancelRuntimeCleanupRef.current = scheduleRuntimeCleanup(()=>{
+                runtime.destroy();
+                releaseChartsRuntimeOwners([
+                    globalIDRef.current
+                ]);
+                cancelRuntimeCleanupRef.current = null;
+            });
+        };
+    }, [
         runtime
     ]);
     const value1 = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>({
@@ -11059,17 +11076,57 @@ const TOOLBAR_CONTENT_GRADIENT_CLASS_NAME = 'w-[60px] justify-stretch';
 const TOOLBAR_TRIGGER_ICON_CLASS_NAME = 'inline-flex h-full min-w-4 shrink-0 items-center justify-center text-primary';
 const TOOLBAR_GLYPH_CLASS_NAME = 'inline-flex size-4 shrink-0 items-center justify-center [&_svg]:size-full [&_svg]:shrink-0';
 const TOOLBAR_DROPDOWN_CONTENT_CLASS_NAME = 'border-border/80 bg-secondary/92 text-foreground shadow-[0_10px_28px_color-mix(in_srgb,var(--background)_60%,transparent)] backdrop-blur-xl';
-"undefined" != typeof window && window.document && window.document.createElement;
-function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
-    return function(event) {
+var __defProp = Object.defineProperty;
+var __name = (target, value1)=>__defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
+var dist_canUseDOM = !!("undefined" != typeof window && window.document && window.document.createElement);
+function dist_composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+    return /* @__PURE__ */ __name(function(event) {
         originalEventHandler?.(event);
         if (false === checkForDefaultPrevented || !event || !event.defaultPrevented) return ourEventHandler?.(event);
-    };
+    }, "handleEvent");
+}
+__name(dist_composeEventHandlers, "composeEventHandlers");
+function getOwnerWindow(element) {
+    if (!dist_canUseDOM) throw new Error("Cannot access window outside of the DOM");
+    return element?.ownerDocument?.defaultView ?? window;
+}
+__name(getOwnerWindow, "getOwnerWindow");
+function getOwnerDocument(element) {
+    if (!dist_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 "IFRAME" === element.tagName;
 }
+__name(isFrame, "isFrame");
+var dist_defProp = Object.defineProperty;
+var dist_name = (target, value1)=>dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 function setRef(ref, value1) {
     if ("function" == typeof ref) return ref(value1);
     if (null != ref) ref.current = value1;
 }
+dist_name(setRef, "setRef");
 function dist_composeRefs(...refs) {
     return (node)=>{
         let hasCleanup = false;
@@ -11087,9 +11144,43 @@ function dist_composeRefs(...refs) {
         };
     };
 }
-function useComposedRefs(...refs) {
+dist_name(dist_composeRefs, "composeRefs");
+function dist_useComposedRefs(...refs) {
     return __WEBPACK_EXTERNAL_MODULE_react__.useCallback(dist_composeRefs(...refs), refs);
 }
+dist_name(dist_useComposedRefs, "useComposedRefs");
+var react_context_dist_defProp = Object.defineProperty;
+var react_context_dist_name = (target, value1)=>react_context_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
+function createContext2(rootComponentName, defaultContext) {
+    const Context = __WEBPACK_EXTERNAL_MODULE_react__.createContext(defaultContext);
+    Context.displayName = rootComponentName + "Context";
+    const Provider = /* @__PURE__ */ react_context_dist_name((props)=>{
+        const { children, ...context } = props;
+        const value1 = __WEBPACK_EXTERNAL_MODULE_react__.useMemo(()=>context, Object.values(context));
+        return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Context.Provider, {
+            value: value1,
+            children
+        });
+    }, "Provider");
+    Provider.displayName = rootComponentName + "Provider";
+    function useContext2(consumerName, options = {}) {
+        const { optional = false } = options;
+        const context = __WEBPACK_EXTERNAL_MODULE_react__.useContext(Context);
+        if (context) return context;
+        if (void 0 !== defaultContext) return defaultContext;
+        if (optional) return;
+        throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+    }
+    react_context_dist_name(useContext2, "useContext");
+    return [
+        Provider,
+        useContext2
+    ];
+}
+react_context_dist_name(createContext2, "createContext");
 function createContextScope(scopeName, createContextScopeDeps = []) {
     let defaultContexts = [];
     function createContext3(rootComponentName, defaultContext) {
@@ -11100,7 +11191,7 @@ function createContextScope(scopeName, createContextScopeDeps = []) {
             ...defaultContexts,
             defaultContext
         ];
-        const Provider = (props)=>{
+        const Provider = /* @__PURE__ */ react_context_dist_name((props)=>{
             const { scope, children, ...context } = props;
             const Context = scope?.[scopeName]?.[index] || BaseContext;
             const value1 = __WEBPACK_EXTERNAL_MODULE_react__.useMemo(()=>context, Object.values(context));
@@ -11108,7 +11199,7 @@ function createContextScope(scopeName, createContextScopeDeps = []) {
                 value: value1,
                 children
             });
-        };
+        }, "Provider");
         Provider.displayName = rootComponentName + "Provider";
         function useContext2(consumerName, scope, options = {}) {
             const { optional = false } = options;
@@ -11119,14 +11210,16 @@ function createContextScope(scopeName, createContextScopeDeps = []) {
             if (optional) return;
             throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
         }
+        react_context_dist_name(useContext2, "useContext");
         return [
             Provider,
             useContext2
         ];
     }
-    const createScope = ()=>{
+    react_context_dist_name(createContext3, "createContext");
+    const createScope = /* @__PURE__ */ react_context_dist_name(()=>{
         const scopeContexts = defaultContexts.map((defaultContext)=>__WEBPACK_EXTERNAL_MODULE_react__.createContext(defaultContext));
-        return function(scope) {
+        return /* @__PURE__ */ react_context_dist_name(function(scope) {
             const contexts = scope?.[scopeName] || scopeContexts;
             return __WEBPACK_EXTERNAL_MODULE_react__.useMemo(()=>({
                     [`__scope${scopeName}`]: {
@@ -11137,23 +11230,24 @@ function createContextScope(scopeName, createContextScopeDeps = []) {
                 scope,
                 contexts
             ]);
-        };
-    };
+        }, "useScope");
+    }, "createScope");
     createScope.scopeName = scopeName;
     return [
         createContext3,
         composeContextScopes(createScope, ...createContextScopeDeps)
     ];
 }
+react_context_dist_name(createContextScope, "createContextScope");
 function composeContextScopes(...scopes) {
     const baseScope = scopes[0];
     if (1 === scopes.length) return baseScope;
-    const createScope = ()=>{
+    const createScope = /* @__PURE__ */ react_context_dist_name(()=>{
         const scopeHooks = scopes.map((createScope2)=>({
                 useScope: createScope2(),
                 scopeName: createScope2.scopeName
             }));
-        return function(overrideScopes) {
+        return /* @__PURE__ */ react_context_dist_name(function(overrideScopes) {
             const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName })=>{
                 const scopeProps = useScope(overrideScopes);
                 const currentScope = scopeProps[`__scope${scopeName}`];
@@ -11167,21 +11261,49 @@ function composeContextScopes(...scopes) {
                 }), [
                 nextScopes
             ]);
-        };
-    };
+        }, "useComposedScopes");
+    }, "createScope");
     createScope.scopeName = baseScope.scopeName;
     return createScope;
 }
+react_context_dist_name(composeContextScopes, "composeContextScopes");
+var IS_DEVELOPMENT = false;
 var useLayoutEffect2 = globalThis?.document ? __WEBPACK_EXTERNAL_MODULE_react__.useLayoutEffect : ()=>{};
+var react_use_effect_event_dist_defProp = Object.defineProperty;
+var react_use_effect_event_dist_name = (target, value1)=>react_use_effect_event_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
+var useReactEffectEvent = __WEBPACK_EXTERNAL_MODULE_react__[" useEffectEvent ".trim().toString()];
+var useReactInsertionEffect = __WEBPACK_EXTERNAL_MODULE_react__[" useInsertionEffect ".trim().toString()];
+function useEffectEvent(callback) {
+    if ("function" == typeof useReactEffectEvent) return useReactEffectEvent(callback);
+    const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(()=>{
+        throw new Error("Cannot call an event handler while rendering.");
+    });
+    if ("function" == typeof useReactInsertionEffect) useReactInsertionEffect(()=>{
+        ref.current = callback;
+    });
+    else useLayoutEffect2(()=>{
+        ref.current = callback;
+    });
+    return __WEBPACK_EXTERNAL_MODULE_react__.useMemo(()=>(...args)=>ref.current?.(...args), []);
+}
+react_use_effect_event_dist_name(useEffectEvent, "useEffectEvent");
+var react_use_controllable_state_dist_defProp = Object.defineProperty;
+var react_use_controllable_state_dist_name = (target, value1)=>react_use_controllable_state_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var useInsertionEffect = __WEBPACK_EXTERNAL_MODULE_react__[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
-function dist_useControllableState({ prop, defaultProp, onChange = ()=>{}, caller }) {
+function dist_useControllableState({ prop, defaultProp, onChange = /* @__PURE__ */ react_use_controllable_state_dist_name(()=>{}, "onChange"), caller }) {
     const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
         defaultProp,
         onChange
     });
     const isControlled = void 0 !== prop;
     const value1 = isControlled ? prop : uncontrolledProp;
-    {
+    if (IS_DEVELOPMENT) {
         const isControlledRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(void 0 !== prop);
         __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
             const wasControlled = isControlledRef.current;
@@ -11212,6 +11334,7 @@ function dist_useControllableState({ prop, defaultProp, onChange = ()=>{}, calle
         setValue
     ];
 }
+react_use_controllable_state_dist_name(dist_useControllableState, "useControllableState");
 function useUncontrolledState({ defaultProp, onChange }) {
     const [value1, setValue] = __WEBPACK_EXTERNAL_MODULE_react__.useState(defaultProp);
     const prevValueRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(value1);
@@ -11236,10 +11359,91 @@ function useUncontrolledState({ defaultProp, onChange }) {
         onChangeRef
     ];
 }
+react_use_controllable_state_dist_name(useUncontrolledState, "useUncontrolledState");
 function isFunction(value1) {
     return "function" == typeof value1;
 }
-Symbol("RADIX:SYNC_STATE");
+react_use_controllable_state_dist_name(isFunction, "isFunction");
+var SYNC_STATE = Symbol("RADIX:SYNC_STATE");
+function useControllableStateReducer(reducer, userArgs, initialArg, init) {
+    const { prop: controlledState, defaultProp, onChange: onChangeProp, caller } = userArgs;
+    const isControlled = void 0 !== controlledState;
+    const onChange = useEffectEvent(onChangeProp);
+    if (IS_DEVELOPMENT) {
+        const isControlledRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(void 0 !== controlledState);
+        __WEBPACK_EXTERNAL_MODULE_react__.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] = __WEBPACK_EXTERNAL_MODULE_react__.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 = __WEBPACK_EXTERNAL_MODULE_react__.useRef(uncontrolledState);
+    __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
+        if (prevValueRef.current !== uncontrolledState) {
+            prevValueRef.current = uncontrolledState;
+            if (!isControlled) onChange(uncontrolledState);
+        }
+    }, [
+        uncontrolledState,
+        prevValueRef,
+        isControlled
+    ]);
+    const state = __WEBPACK_EXTERNAL_MODULE_react__.useMemo(()=>{
+        const isControlled2 = void 0 !== controlledState;
+        if (isControlled2) return {
+            ...internalState,
+            state: controlledState
+        };
+        return internalState;
+    }, [
+        internalState,
+        controlledState
+    ]);
+    __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
+        if (isControlled && !Object.is(controlledState, internalState.state)) dispatch({
+            type: SYNC_STATE,
+            state: controlledState
+        });
+    }, [
+        controlledState,
+        internalState.state,
+        isControlled
+    ]);
+    return [
+        state,
+        dispatch
+    ];
+}
+react_use_controllable_state_dist_name(useControllableStateReducer, "useControllableStateReducer");
+var react_slot_dist_defProp = Object.defineProperty;
+var react_slot_dist_name = (target, value1)=>react_slot_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 function createSlot(ownerName) {
     const Slot2 = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
         let { children, ...slotProps } = props;
@@ -11260,7 +11464,7 @@ function createSlot(ownerName) {
         if (slottableElement) slottableElement = __WEBPACK_EXTERNAL_MODULE_react__.cloneElement(slottableElement, void 0, newChildren);
         else if (!hasSlottable && 1 === __WEBPACK_EXTERNAL_MODULE_react__.Children.count(children) && __WEBPACK_EXTERNAL_MODULE_react__.isValidElement(children)) slottableElement = children;
         const slottableElementRef = slottableElement ? getElementRef(slottableElement) : void 0;
-        const composedRef = useComposedRefs(forwardedRef, slottableElementRef);
+        const composedRef = dist_useComposedRefs(forwardedRef, slottableElementRef);
         if (!slottableElement) {
             if (children || 0 === children) throw new Error(hasSlottable ? createSlottableError(ownerName) : createSlotError(ownerName));
             return children;
@@ -11272,21 +11476,23 @@ function createSlot(ownerName) {
     Slot2.displayName = `${ownerName}.Slot`;
     return Slot2;
 }
+react_slot_dist_name(createSlot, "createSlot");
 var SLOTTABLE_IDENTIFIER = Symbol.for("radix.slottable");
 function createSlottable(ownerName) {
-    const Slottable2 = (props)=>"child" in props ? props.children(props.child) : props.children;
+    const Slottable2 = /* @__PURE__ */ react_slot_dist_name((props)=>"child" in props ? props.children(props.child) : props.children, "Slottable");
     Slottable2.displayName = `${ownerName}.Slottable`;
     Slottable2.__radixId = SLOTTABLE_IDENTIFIER;
     return Slottable2;
 }
-var getSlottableElementFromSlottable = (slottable, child)=>{
+react_slot_dist_name(createSlottable, "createSlottable");
+var getSlottableElementFromSlottable = /* @__PURE__ */ react_slot_dist_name((slottable, child)=>{
     if ("child" in slottable.props) {
         const child2 = slottable.props.child;
         if (!__WEBPACK_EXTERNAL_MODULE_react__.isValidElement(child2)) return null;
         return __WEBPACK_EXTERNAL_MODULE_react__.cloneElement(child2, void 0, slottable.props.children(child2.props.children));
     }
     return __WEBPACK_EXTERNAL_MODULE_react__.isValidElement(child) ? child : null;
-};
+}, "getSlottableElementFromSlottable");
 function mergeProps(slotProps, childProps) {
     const overrideProps = {
         ...childProps
@@ -11316,6 +11522,7 @@ function mergeProps(slotProps, childProps) {
         ...overrideProps
     };
 }
+react_slot_dist_name(mergeProps, "mergeProps");
 function getElementRef(element) {
     let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
     let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
@@ -11325,19 +11532,28 @@ function getElementRef(element) {
     if (mayWarn) return element.props.ref;
     return element.props.ref || element.ref;
 }
+react_slot_dist_name(getElementRef, "getElementRef");
 function isSlottable(child) {
     return __WEBPACK_EXTERNAL_MODULE_react__.isValidElement(child) && "function" == typeof child.type && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
 }
+react_slot_dist_name(isSlottable, "isSlottable");
 var REACT_LAZY_TYPE = Symbol.for("react.lazy");
 function isLazyComponent(element) {
     return null != element && "object" == typeof element && "$$typeof" in element && element.$$typeof === REACT_LAZY_TYPE && "_payload" in element && isPromiseLike(element._payload);
 }
+react_slot_dist_name(isLazyComponent, "isLazyComponent");
 function isPromiseLike(value1) {
     return "object" == typeof value1 && null !== value1 && "then" in value1;
 }
-var createSlotError = (ownerName)=>`${ownerName} failed to slot onto its children. Expected a single React element child or \`Slottable\`.`;
-var createSlottableError = (ownerName)=>`${ownerName} failed to slot onto its \`Slottable\`. Expected \`Slottable\` to receive a single React element child.`;
+react_slot_dist_name(isPromiseLike, "isPromiseLike");
+var createSlotError = /* @__PURE__ */ react_slot_dist_name((ownerName)=>`${ownerName} failed to slot onto its children. Expected a single React element child or \`Slottable\`.`, "createSlotError");
+var createSlottableError = /* @__PURE__ */ react_slot_dist_name((ownerName)=>`${ownerName} failed to slot onto its \`Slottable\`. Expected \`Slottable\` to receive a single React element child.`, "createSlottableError");
 var use = __WEBPACK_EXTERNAL_MODULE_react__[" use ".trim().toString()];
+var react_primitive_dist_defProp = Object.defineProperty;
+var react_primitive_dist_name = (target, value1)=>react_primitive_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var NODES = [
     "a",
     "button",
@@ -11357,7 +11573,7 @@ var NODES = [
     "svg",
     "ul"
 ];
-var Primitive = NODES.reduce((primitive, node)=>{
+var dist_Primitive = NODES.reduce((primitive, node)=>{
     const Slot = createSlot(`Primitive.${node}`);
     const Node1 = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
         const { asChild, ...primitiveProps } = props;
@@ -11377,7 +11593,13 @@ var Primitive = NODES.reduce((primitive, node)=>{
 function dispatchDiscreteCustomEvent(target, event) {
     if (target) __WEBPACK_EXTERNAL_MODULE_react_dom_7136dc57__.flushSync(()=>target.dispatchEvent(event));
 }
+react_primitive_dist_name(dispatchDiscreteCustomEvent, "dispatchDiscreteCustomEvent");
 "use client";
+var react_collection_dist_defProp = Object.defineProperty;
+var react_collection_dist_name = (target, value1)=>react_collection_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 function createCollection(name) {
     const PROVIDER_NAME = name + "CollectionProvider";
     const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);
@@ -11387,7 +11609,7 @@ function createCollection(name) {
         },
         itemMap: /* @__PURE__ */ new Map()
     });
-    const CollectionProvider = (props)=>{
+    const CollectionProvider = /* @__PURE__ */ react_collection_dist_name((props)=>{
         const { scope, children } = props;
         const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
         const itemMap = __WEBPACK_EXTERNAL_MODULE_react__.useRef(/* @__PURE__ */ new Map()).current;
@@ -11397,14 +11619,14 @@ function createCollection(name) {
             collectionRef: ref,
             children
         });
-    };
+    }, "CollectionProvider");
     CollectionProvider.displayName = PROVIDER_NAME;
     const COLLECTION_SLOT_NAME = name + "CollectionSlot";
     const CollectionSlotImpl = createSlot(COLLECTION_SLOT_NAME);
     const CollectionSlot = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
         const { scope, children } = props;
         const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
-        const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
+        const composedRefs = dist_useComposedRefs(forwardedRef, context.collectionRef);
         return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(CollectionSlotImpl, {
             ref: composedRefs,
             children
@@ -11417,7 +11639,7 @@ function createCollection(name) {
     const CollectionItemSlot = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
         const { scope, children, ...itemData } = props;
         const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-        const composedRefs = useComposedRefs(forwardedRef, ref);
+        const composedRefs = dist_useComposedRefs(forwardedRef, ref);
         const context = useCollectionContext(ITEM_SLOT_NAME, scope);
         __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
             context.itemMap.set(ref, {
@@ -11450,6 +11672,7 @@ function createCollection(name) {
         ]);
         return getItems;
     }
+    react_collection_dist_name(useCollection, "useCollection");
     return [
         {
             Provider: CollectionProvider,
@@ -11460,21 +11683,501 @@ function createCollection(name) {
         createCollectionScope
     ];
 }
+react_collection_dist_name(createCollection, "createCollection");
+var __instanciated = /* @__PURE__ */ new WeakMap();
+var OrderedDict = class _OrderedDict extends Map {
+    static{
+        react_collection_dist_name(this, "OrderedDict");
+    }
+    #keys;
+    constructor(entries){
+        super(entries);
+        this.#keys = [
+            ...super.keys()
+        ];
+        __instanciated.set(this, true);
+    }
+    set(key, value1) {
+        if (__instanciated.get(this)) if (this.has(key)) this.#keys[this.#keys.indexOf(key)] = key;
+        else this.#keys.push(key);
+        super.set(key, value1);
+        return this;
+    }
+    insert(index, key, value1) {
+        const has = this.has(key);
+        const length = this.#keys.length;
+        const relativeIndex = toSafeInteger(index);
+        let actualIndex = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;
+        const safeIndex = actualIndex < 0 || actualIndex >= length ? -1 : actualIndex;
+        if (safeIndex === this.size || has && safeIndex === this.size - 1 || -1 === safeIndex) {
+            this.set(key, value1);
+            return this;
+        }
+        const size = this.size + (has ? 0 : 1);
+        if (relativeIndex < 0) actualIndex++;
+        const keys = [
+            ...this.#keys
+        ];
+        let nextValue;
+        let shouldSkip = false;
+        for(let i = actualIndex; i < size; 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, value1);
+        } 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(index, key, value1) {
+        const copy = new _OrderedDict(this);
+        copy.insert(index, key, value1);
+        return copy;
+    }
+    before(key) {
+        const index = this.#keys.indexOf(key) - 1;
+        if (index < 0) return;
+        return this.entryAt(index);
+    }
+    setBefore(key, newKey, value1) {
+        const index = this.#keys.indexOf(key);
+        if (-1 === index) return this;
+        return this.insert(index, newKey, value1);
+    }
+    after(key) {
+        let index = this.#keys.indexOf(key);
+        index = -1 === index || index === this.size - 1 ? -1 : index + 1;
+        if (-1 === index) return;
+        return this.entryAt(index);
+    }
+    setAfter(key, newKey, value1) {
+        const index = this.#keys.indexOf(key);
+        if (-1 === index) return this;
+        return this.insert(index + 1, newKey, value1);
+    }
+    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(index) {
+        const key = this.keyAt(index);
+        if (void 0 !== key) return this.delete(key);
+        return false;
+    }
+    at(index) {
+        const key = at(this.#keys, index);
+        if (void 0 !== key) return this.get(key);
+    }
+    entryAt(index) {
+        const key = at(this.#keys, index);
+        if (void 0 !== key) return [
+            key,
+            this.get(key)
+        ];
+    }
+    indexOf(key) {
+        return this.#keys.indexOf(key);
+    }
+    keyAt(index) {
+        return at(this.#keys, index);
+    }
+    from(key, offset) {
+        const index = this.indexOf(key);
+        if (-1 === index) return;
+        let dest = index + offset;
+        if (dest < 0) dest = 0;
+        if (dest >= this.size) dest = this.size - 1;
+        return this.at(dest);
+    }
+    keyFrom(key, offset) {
+        const index = this.indexOf(key);
+        if (-1 === index) return;
+        let dest = index + offset;
+        if (dest < 0) dest = 0;
+        if (dest >= this.size) dest = this.size - 1;
+        return this.keyAt(dest);
+    }
+    find(predicate, thisArg) {
+        let index = 0;
+        for (const entry of this){
+            if (Reflect.apply(predicate, thisArg, [
+                entry,
+                index,
+                this
+            ])) return entry;
+            index++;
+        }
+    }
+    findIndex(predicate, thisArg) {
+        let index = 0;
+        for (const entry of this){
+            if (Reflect.apply(predicate, thisArg, [
+                entry,
+                index,
+                this
+            ])) return index;
+            index++;
+        }
+        return -1;
+    }
+    filter(predicate, thisArg) {
+        const entries = [];
+        let index = 0;
+        for (const entry of this){
+            if (Reflect.apply(predicate, thisArg, [
+                entry,
+                index,
+                this
+            ])) entries.push(entry);
+            index++;
+        }
+        return new _OrderedDict(entries);
+    }
+    map(callbackfn, thisArg) {
+        const entries = [];
+        let index = 0;
+        for (const entry of this){
+            entries.push([
+                entry[0],
+                Reflect.apply(callbackfn, thisArg, [
+                    entry,
+                    index,
+                    this
+                ])
+            ]);
+            index++;
+        }
+        return new _OrderedDict(entries);
+    }
+    reduce(...args) {
+        const [callbackfn, initialValue] = args;
+        let index = 0;
+        let accumulator = initialValue ?? this.at(0);
+        for (const entry of this){
+            accumulator = 0 === index && 1 === args.length ? entry : Reflect.apply(callbackfn, this, [
+                accumulator,
+                entry,
+                index,
+                this
+            ]);
+            index++;
+        }
+        return accumulator;
+    }
+    reduceRight(...args) {
+        const [callbackfn, initialValue] = args;
+        let accumulator = initialValue ?? this.at(-1);
+        for(let index = this.size - 1; index >= 0; index--){
+            const entry = this.at(index);
+            accumulator = index === this.size - 1 && 1 === args.length ? entry : Reflect.apply(callbackfn, this, [
+                accumulator,
+                entry,
+                index,
+                this
+            ]);
+        }
+        return accumulator;
+    }
+    toSorted(compareFn) {
+        const entries = [
+            ...this.entries()
+        ].sort(compareFn);
+        return new _OrderedDict(entries);
+    }
+    toReversed() {
+        const reversed = new _OrderedDict();
+        for(let index = this.size - 1; index >= 0; index--){
+            const key = this.keyAt(index);
+            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 (void 0 === start) return result;
+        if (start < 0) start += this.size;
+        if (void 0 !== end && end > 0) stop = end - 1;
+        for(let index = start; index <= stop; index++){
+            const key = this.keyAt(index);
+            const element = this.get(key);
+            result.set(key, element);
+        }
+        return result;
+    }
+    every(predicate, thisArg) {
+        let index = 0;
+        for (const entry of this){
+            if (!Reflect.apply(predicate, thisArg, [
+                entry,
+                index,
+                this
+            ])) return false;
+            index++;
+        }
+        return true;
+    }
+    some(predicate, thisArg) {
+        let index = 0;
+        for (const entry of this){
+            if (Reflect.apply(predicate, thisArg, [
+                entry,
+                index,
+                this
+            ])) return true;
+            index++;
+        }
+        return false;
+    }
+};
+function at(array, index) {
+    if ("at" in Array.prototype) return Array.prototype.at.call(array, index);
+    const actualIndex = toSafeIndex(array, index);
+    return -1 === actualIndex ? void 0 : array[actualIndex];
+}
+react_collection_dist_name(at, "at");
+function toSafeIndex(array, index) {
+    const length = array.length;
+    const relativeIndex = toSafeInteger(index);
+    const actualIndex = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;
+    return actualIndex < 0 || actualIndex >= length ? -1 : actualIndex;
+}
+react_collection_dist_name(toSafeIndex, "toSafeIndex");
+function toSafeInteger(number) {
+    return number !== number || 0 === number ? 0 : Math.trunc(number);
+}
+react_collection_dist_name(toSafeInteger, "toSafeInteger");
+function createCollection2(name) {
+    const PROVIDER_NAME = name + "CollectionProvider";
+    const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);
+    const [CollectionContextProvider, useCollectionContext] = createCollectionContext(PROVIDER_NAME, {
+        collectionElement: null,
+        collectionRef: {
+            current: null
+        },
+        collectionRefObject: {
+            current: null
+        },
+        itemMap: new OrderedDict(),
+        setItemMap: /* @__PURE__ */ react_collection_dist_name(()=>void 0, "setItemMap")
+    });
+    const CollectionProvider = /* @__PURE__ */ react_collection_dist_name(({ state, ...props })=>state ? /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(CollectionProviderImpl, {
+            ...props,
+            state
+        }) : /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(CollectionInit, {
+            ...props
+        }), "CollectionProvider");
+    CollectionProvider.displayName = PROVIDER_NAME;
+    const CollectionInit = /* @__PURE__ */ react_collection_dist_name((props)=>{
+        const state = useInitCollection();
+        return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(CollectionProviderImpl, {
+            ...props,
+            state
+        });
+    }, "CollectionInit");
+    CollectionInit.displayName = PROVIDER_NAME + "Init";
+    const CollectionProviderImpl = /* @__PURE__ */ react_collection_dist_name((props)=>{
+        const { scope, children, state } = props;
+        const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
+        const [collectionElement, setCollectionElement] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
+        const composeRefs = dist_useComposedRefs(ref, setCollectionElement);
+        const [itemMap, setItemMap] = state;
+        __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
+            if (!collectionElement) return;
+            const observer = getChildListObserver(()=>{});
+            observer.observe(collectionElement, {
+                childList: true,
+                subtree: true
+            });
+            return ()=>{
+                observer.disconnect();
+            };
+        }, [
+            collectionElement
+        ]);
+        return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(CollectionContextProvider, {
+            scope,
+            itemMap,
+            setItemMap,
+            collectionRef: composeRefs,
+            collectionRefObject: ref,
+            collectionElement,
+            children
+        });
+    }, "CollectionProviderImpl");
+    CollectionProviderImpl.displayName = PROVIDER_NAME + "Impl";
+    const COLLECTION_SLOT_NAME = name + "CollectionSlot";
+    const CollectionSlotImpl = createSlot(COLLECTION_SLOT_NAME);
+    const CollectionSlot = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+        const { scope, children } = props;
+        const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
+        const composedRefs = dist_useComposedRefs(forwardedRef, context.collectionRef);
+        return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(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 = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+        const { scope, children, ...itemData } = props;
+        const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
+        const [element, setElement] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
+        const composedRefs = dist_useComposedRefs(forwardedRef, ref, setElement);
+        const context = useCollectionContext(ITEM_SLOT_NAME, scope);
+        const { setItemMap } = context;
+        const itemDataRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(itemData);
+        if (!shallowEqual(itemDataRef.current, itemData)) itemDataRef.current = itemData;
+        const memoizedItemData = itemDataRef.current;
+        __WEBPACK_EXTERNAL_MODULE_react__.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__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(CollectionItemSlotImpl, {
+            ...{
+                [ITEM_DATA_ATTR]: ""
+            },
+            ref: composedRefs,
+            children
+        });
+    });
+    CollectionItemSlot.displayName = ITEM_SLOT_NAME;
+    function useInitCollection() {
+        return __WEBPACK_EXTERNAL_MODULE_react__.useState(new OrderedDict());
+    }
+    react_collection_dist_name(useInitCollection, "useInitCollection");
+    function useCollection(scope) {
+        const { itemMap } = useCollectionContext(name + "CollectionConsumer", scope);
+        return itemMap;
+    }
+    react_collection_dist_name(useCollection, "useCollection");
+    const functions = {
+        createCollectionScope,
+        useCollection,
+        useInitCollection
+    };
+    return [
+        {
+            Provider: CollectionProvider,
+            Slot: CollectionSlot,
+            ItemSlot: CollectionItemSlot
+        },
+        functions
+    ];
+}
+react_collection_dist_name(createCollection2, "createCollection");
+function shallowEqual(a, b) {
+    if (a === b) return true;
+    if ("object" != typeof a || "object" != typeof b) return false;
+    if (null == a || null == b) 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;
+}
+react_collection_dist_name(shallowEqual, "shallowEqual");
+function isElementPreceding(a, b) {
+    return !!(b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_PRECEDING);
+}
+react_collection_dist_name(isElementPreceding, "isElementPreceding");
+function sortByDocumentPosition(a, b) {
+    return a[1].element && b[1].element ? isElementPreceding(a[1].element, b[1].element) ? -1 : 1 : 0;
+}
+react_collection_dist_name(sortByDocumentPosition, "sortByDocumentPosition");
+function getChildListObserver(callback) {
+    const observer = new MutationObserver((mutationsList)=>{
+        for (const mutation of mutationsList)if ("childList" === mutation.type) return void callback();
+    });
+    return observer;
+}
+react_collection_dist_name(getChildListObserver, "getChildListObserver");
 "use client";
+var react_direction_dist_defProp = Object.defineProperty;
+var react_direction_dist_name = (target, value1)=>react_direction_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var DirectionContext = __WEBPACK_EXTERNAL_MODULE_react__.createContext(void 0);
 function useDirection(localDir) {
     const globalDir = __WEBPACK_EXTERNAL_MODULE_react__.useContext(DirectionContext);
     return localDir || globalDir || "ltr";
 }
-function useCallbackRef(callback) {
+react_direction_dist_name(useDirection, "useDirection");
+var react_use_callback_ref_dist_defProp = Object.defineProperty;
+var react_use_callback_ref_dist_name = (target, value1)=>react_use_callback_ref_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
+function dist_useCallbackRef(callback) {
     const callbackRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(callback);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         callbackRef.current = callback;
     });
     return __WEBPACK_EXTERNAL_MODULE_react__.useMemo(()=>(...args)=>callbackRef.current?.(...args), []);
 }
+react_use_callback_ref_dist_name(dist_useCallbackRef, "useCallbackRef");
 "use client";
-var DISMISSABLE_LAYER_NAME = "DismissableLayer";
+var react_dismissable_layer_dist_defProp = Object.defineProperty;
+var react_dismissable_layer_dist_name = (target, value1)=>react_dismissable_layer_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var CONTEXT_UPDATE = "dismissableLayer.update";
 var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
 var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
@@ -11485,13 +12188,13 @@ var DismissableLayerContext = __WEBPACK_EXTERNAL_MODULE_react__.createContext({
     branches: /* @__PURE__ */ new Set(),
     dismissableSurfaces: /* @__PURE__ */ new Set()
 });
-var DismissableLayer = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var DismissableLayer = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_dismissable_layer_dist_name(function(props, forwardedRef) {
     const { disableOutsidePointerEvents = false, deferPointerDownOutside = false, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, onDismiss, ...layerProps } = props;
     const context = __WEBPACK_EXTERNAL_MODULE_react__.useContext(DismissableLayerContext);
     const [node, setNode] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     const ownerDocument = node?.ownerDocument ?? globalThis?.document;
     const [, force] = __WEBPACK_EXTERNAL_MODULE_react__.useState({});
-    const composedRefs = useComposedRefs(forwardedRef, setNode);
+    const composedRefs = dist_useComposedRefs(forwardedRef, setNode);
     const layers = Array.from(context.layers);
     const [highestLayerWithOutsidePointerEventsDisabled] = [
         ...context.layersWithOutsidePointerEventsDisabled
@@ -11533,7 +12236,7 @@ var DismissableLayer = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forw
         if (!event.defaultPrevented) onDismiss?.();
     }, ownerDocument);
     const isHighestLayer = node ? index === layers.length - 1 : false;
-    const handleKeyDown = useCallbackRef((event)=>{
+    const handleKeyDown = dist_useCallbackRef((event)=>{
         if ("Escape" !== event.key) return;
         onEscapeKeyDown?.(event);
         if (!event.defaultPrevented && onDismiss) {
@@ -11587,49 +12290,42 @@ var DismissableLayer = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forw
         context
     ]);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
-        const handleUpdate = ()=>force({});
+        const handleUpdate = /* @__PURE__ */ react_dismissable_layer_dist_name(()=>force({}), "handleUpdate");
         document.addEventListener(CONTEXT_UPDATE, handleUpdate);
         return ()=>document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
     }, []);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         ...layerProps,
         ref: composedRefs,
         style: {
             pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
             ...props.style
         },
-        onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),
-        onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),
-        onPointerDownCapture: composeEventHandlers(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture)
+        onFocusCapture: dist_composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),
+        onBlurCapture: dist_composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),
+        onPointerDownCapture: dist_composeEventHandlers(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture)
     });
-});
-DismissableLayer.displayName = DISMISSABLE_LAYER_NAME;
-var BRANCH_NAME = "DismissableLayerBranch";
-var DismissableLayerBranch = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "DismissableLayer"));
+function useDismissableLayerSurface() {
     const context = __WEBPACK_EXTERNAL_MODULE_react__.useContext(DismissableLayerContext);
-    const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
+    const [node, setNode] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
-        const node = ref.current;
-        if (node) {
-            context.branches.add(node);
-            return ()=>{
-                context.branches.delete(node);
-            };
-        }
+        if (!node) return;
+        context.dismissableSurfaces.add(node);
+        return ()=>{
+            context.dismissableSurfaces.delete(node);
+        };
     }, [
-        context.branches
+        node,
+        context.dismissableSurfaces
     ]);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
-        ...props,
-        ref: composedRefs
-    });
-});
-DismissableLayerBranch.displayName = BRANCH_NAME;
-var IS_TRUE = ()=>true;
+    return setNode;
+}
+react_dismissable_layer_dist_name(useDismissableLayerSurface, "useDismissableLayerSurface");
+var IS_TRUE = /* @__PURE__ */ react_dismissable_layer_dist_name(()=>true, "IS_TRUE");
 function usePointerDownOutside(onPointerDownOutside, args) {
     const { ownerDocument = globalThis?.document, deferPointerDownOutside = false, isDeferredPointerDownOutsideRef, dismissableSurfaces, shouldHandlePointerDownOutside = IS_TRUE } = args;
-    const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);
+    const handlePointerDownOutside = dist_useCallbackRef(onPointerDownOutside);
     const isPointerInsideReactTreeRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
     const isPointerDownOutsideRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
     const interceptedOutsideInteractionEventsRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(/* @__PURE__ */ new Map());
@@ -11640,9 +12336,11 @@ function usePointerDownOutside(onPointerDownOutside, args) {
             isDeferredPointerDownOutsideRef.current = false;
             interceptedOutsideInteractionEventsRef.current.clear();
         }
+        react_dismissable_layer_dist_name(resetOutsideInteraction, "resetOutsideInteraction");
         function isOutsideInteractionIntercepted() {
             return Array.from(interceptedOutsideInteractionEventsRef.current.values()).some(Boolean);
         }
+        react_dismissable_layer_dist_name(isOutsideInteractionIntercepted, "isOutsideInteractionIntercepted");
         function handleInteractionCapture(event) {
             if (!isPointerDownOutsideRef.current) return;
             const target = event.target;
@@ -11654,10 +12352,12 @@ function usePointerDownOutside(onPointerDownOutside, args) {
                 if (isPointerDownOutsideRef.current) handleClickRef.current();
             }, 0);
         }
+        react_dismissable_layer_dist_name(handleInteractionCapture, "handleInteractionCapture");
         function handleInteractionBubble(event) {
             if (isPointerDownOutsideRef.current) interceptedOutsideInteractionEventsRef.current.set(event.type, false);
         }
-        const handlePointerDown = (event)=>{
+        react_dismissable_layer_dist_name(handleInteractionBubble, "handleInteractionBubble");
+        const handlePointerDown = /* @__PURE__ */ react_dismissable_layer_dist_name((event)=>{
             if (event.target && !isPointerInsideReactTreeRef.current) {
                 let handleAndDispatchPointerDownOutsideEvent2 = function() {
                     ownerDocument.removeEventListener("click", handleClickRef.current);
@@ -11667,6 +12367,7 @@ function usePointerDownOutside(onPointerDownOutside, args) {
                         discrete: true
                     });
                 };
+                react_dismissable_layer_dist_name(handleAndDispatchPointerDownOutsideEvent2, "handleAndDispatchPointerDownOutsideEvent");
                 if (!shouldHandlePointerDownOutside(event.target)) {
                     ownerDocument.removeEventListener("click", handleClickRef.current);
                     resetOutsideInteraction();
@@ -11691,7 +12392,7 @@ function usePointerDownOutside(onPointerDownOutside, args) {
                 resetOutsideInteraction();
             }
             isPointerInsideReactTreeRef.current = false;
-        };
+        }, "handlePointerDown");
         const outsideInteractionEvents = [
             "pointerup",
             "mousedown",
@@ -11725,14 +12426,15 @@ function usePointerDownOutside(onPointerDownOutside, args) {
         shouldHandlePointerDownOutside
     ]);
     return {
-        onPointerDownCapture: ()=>isPointerInsideReactTreeRef.current = true
+        onPointerDownCapture: /* @__PURE__ */ react_dismissable_layer_dist_name(()=>isPointerInsideReactTreeRef.current = true, "onPointerDownCapture")
     };
 }
+react_dismissable_layer_dist_name(usePointerDownOutside, "usePointerDownOutside");
 function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
-    const handleFocusOutside = useCallbackRef(onFocusOutside);
+    const handleFocusOutside = dist_useCallbackRef(onFocusOutside);
     const isFocusInsideReactTreeRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
-        const handleFocus = (event)=>{
+        const handleFocus = /* @__PURE__ */ react_dismissable_layer_dist_name((event)=>{
             if (event.target && !isFocusInsideReactTreeRef.current) {
                 const eventDetail = {
                     originalEvent: event
@@ -11741,7 +12443,7 @@ function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
                     discrete: false
                 });
             }
-        };
+        }, "handleFocus");
         ownerDocument.addEventListener("focusin", handleFocus);
         return ()=>ownerDocument.removeEventListener("focusin", handleFocus);
     }, [
@@ -11749,14 +12451,16 @@ function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
         handleFocusOutside
     ]);
     return {
-        onFocusCapture: ()=>isFocusInsideReactTreeRef.current = true,
-        onBlurCapture: ()=>isFocusInsideReactTreeRef.current = false
+        onFocusCapture: /* @__PURE__ */ react_dismissable_layer_dist_name(()=>isFocusInsideReactTreeRef.current = true, "onFocusCapture"),
+        onBlurCapture: /* @__PURE__ */ react_dismissable_layer_dist_name(()=>isFocusInsideReactTreeRef.current = false, "onBlurCapture")
     };
 }
+react_dismissable_layer_dist_name(useFocusOutside, "useFocusOutside");
 function dispatchUpdate() {
     const event = new CustomEvent(CONTEXT_UPDATE);
     document.dispatchEvent(event);
 }
+react_dismissable_layer_dist_name(dispatchUpdate, "dispatchUpdate");
 function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
     const target = detail.originalEvent.target;
     const event = new CustomEvent(name, {
@@ -11770,9 +12474,20 @@ function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
     if (discrete) dispatchDiscreteCustomEvent(target, event);
     else target.dispatchEvent(event);
 }
+react_dismissable_layer_dist_name(handleAndDispatchCustomEvent, "handleAndDispatchCustomEvent");
 "use client";
+var react_focus_guards_dist_defProp = Object.defineProperty;
+var react_focus_guards_dist_name = (target, value1)=>react_focus_guards_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var dist_count = 0;
 var guards = null;
+function FocusGuards(props) {
+    useFocusGuards();
+    return props.children;
+}
+react_focus_guards_dist_name(FocusGuards, "FocusGuards");
 function useFocusGuards() {
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (!guards) guards = {
@@ -11793,6 +12508,7 @@ function useFocusGuards() {
         };
     }, []);
 }
+react_focus_guards_dist_name(useFocusGuards, "useFocusGuards");
 function createFocusGuard() {
     const element = document.createElement("span");
     element.setAttribute("data-radix-focus-guard", "");
@@ -11803,21 +12519,26 @@ function createFocusGuard() {
     element.style.pointerEvents = "none";
     return element;
 }
+react_focus_guards_dist_name(createFocusGuard, "createFocusGuard");
 "use client";
+var react_focus_scope_dist_defProp = Object.defineProperty;
+var react_focus_scope_dist_name = (target, value1)=>react_focus_scope_dist_defProp(target, "name", {
+        value: value1,
+        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 = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var FocusScope = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_focus_scope_dist_name(function(props, forwardedRef) {
     const { loop = false, trapped = false, onMountAutoFocus: onMountAutoFocusProp, onUnmountAutoFocus: onUnmountAutoFocusProp, ...scopeProps } = props;
     const [container, setContainer] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
-    const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);
-    const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);
+    const onMountAutoFocus = dist_useCallbackRef(onMountAutoFocusProp);
+    const onUnmountAutoFocus = dist_useCallbackRef(onUnmountAutoFocusProp);
     const lastFocusedElementRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, setContainer);
+    const composedRefs = dist_useComposedRefs(forwardedRef, setContainer);
     const focusScope = __WEBPACK_EXTERNAL_MODULE_react__.useRef({
         paused: false,
         pause () {
@@ -11848,6 +12569,9 @@ var FocusScope = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedR
                 if (focusedElement !== document.body) return;
                 for (const mutation of mutations)if (mutation.removedNodes.length > 0) dist_focus(container);
             };
+            react_focus_scope_dist_name(handleFocusIn2, "handleFocusIn");
+            react_focus_scope_dist_name(handleFocusOut2, "handleFocusOut");
+            react_focus_scope_dist_name(handleMutations2, "handleMutations");
             document.addEventListener("focusin", handleFocusIn2);
             document.addEventListener("focusout", handleFocusOut2);
             const mutationObserver = new MutationObserver(handleMutations2);
@@ -11931,14 +12655,13 @@ var FocusScope = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedR
         trapped,
         focusScope.paused
     ]);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         tabIndex: -1,
         ...scopeProps,
         ref: composedRefs,
         onKeyDown: handleKeyDown
     });
-});
-FocusScope.displayName = FOCUS_SCOPE_NAME;
+}, "FocusScope"));
 function focusFirst(candidates, { select = false } = {}) {
     const previouslyFocusedElement = document.activeElement;
     for (const candidate of candidates){
@@ -11948,6 +12671,7 @@ function focusFirst(candidates, { select = false } = {}) {
         if (document.activeElement !== previouslyFocusedElement) return;
     }
 }
+react_focus_scope_dist_name(focusFirst, "focusFirst");
 function getTabbableEdges(container) {
     const candidates = getTabbableCandidates(container);
     const first = findVisible(candidates, container);
@@ -11957,18 +12681,20 @@ function getTabbableEdges(container) {
         last
     ];
 }
+react_focus_scope_dist_name(getTabbableEdges, "getTabbableEdges");
 function getTabbableCandidates(container) {
     const nodes = [];
     const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
-        acceptNode: (node)=>{
+        acceptNode: /* @__PURE__ */ react_focus_scope_dist_name((node)=>{
             const isHiddenInput = "INPUT" === node.tagName && "hidden" === node.type;
             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;
 }
+react_focus_scope_dist_name(getTabbableCandidates, "getTabbableCandidates");
 function findVisible(elements, container) {
     const canUseCheckVisibility = "function" == typeof container.checkVisibility && container.checkVisibility({
         checkVisibilityCSS: true
@@ -11982,6 +12708,7 @@ function findVisible(elements, container) {
         if (!hidden) return element;
     }
 }
+react_focus_scope_dist_name(findVisible, "findVisible");
 function isHidden(node, { upTo }) {
     if ("hidden" === getComputedStyle(node).visibility) return true;
     while(node){
@@ -11991,9 +12718,11 @@ function isHidden(node, { upTo }) {
     }
     return false;
 }
+react_focus_scope_dist_name(isHidden, "isHidden");
 function isSelectableInput(element) {
     return element instanceof HTMLInputElement && "select" in element;
 }
+react_focus_scope_dist_name(isSelectableInput, "isSelectableInput");
 function dist_focus(element, { select = false } = {}) {
     if (element && element.focus) {
         const previouslyFocusedElement = document.activeElement;
@@ -12003,6 +12732,7 @@ function dist_focus(element, { select = false } = {}) {
         if (element !== previouslyFocusedElement && isSelectableInput(element) && select) element.select();
     }
 }
+react_focus_scope_dist_name(dist_focus, "focus");
 var focusScopesStack = createFocusScopesStack();
 function createFocusScopesStack() {
     let stack = [];
@@ -12019,6 +12749,7 @@ function createFocusScopesStack() {
         }
     };
 }
+react_focus_scope_dist_name(createFocusScopesStack, "createFocusScopesStack");
 function arrayRemove(array, item) {
     const updatedArray = [
         ...array
@@ -12027,20 +12758,11 @@ function arrayRemove(array, item) {
     if (-1 !== index) updatedArray.splice(index, 1);
     return updatedArray;
 }
+react_focus_scope_dist_name(arrayRemove, "arrayRemove");
 function removeLinks(items) {
     return items.filter((item)=>"A" !== item.tagName);
 }
-var useReactId = __WEBPACK_EXTERNAL_MODULE_react__[" useId ".trim().toString()] || (()=>void 0);
-var react_id_dist_count = 0;
-function useId(deterministicId) {
-    const [id, setId] = __WEBPACK_EXTERNAL_MODULE_react__.useState(useReactId());
-    useLayoutEffect2(()=>{
-        if (!deterministicId) setId((reactId)=>reactId ?? String(react_id_dist_count++));
-    }, [
-        deterministicId
-    ]);
-    return deterministicId || (id ? `radix-${id}` : "");
-}
+react_focus_scope_dist_name(removeLinks, "removeLinks");
 const floating_ui_utils_sides = [
     'top',
     'right',
@@ -12152,12 +12874,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: null != (_padding$top = padding.top) ? _padding$top : 0,
+        right: null != (_padding$right = padding.right) ? _padding$right : 0,
+        bottom: null != (_padding$bottom = padding.bottom) ? _padding$bottom : 0,
+        left: null != (_padding$left = padding.left) ? _padding$left : 0
     };
 }
 function floating_ui_utils_getPaddingObject(padding) {
@@ -12223,14 +12945,8 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
                 y: reference.y
             };
     }
-    switch(floating_ui_utils_getAlignment(placement)){
-        case 'start':
-            coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
-            break;
-        case 'end':
-            coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
-            break;
-    }
+    const alignment = floating_ui_utils_getAlignment(placement);
+    if (alignment) coords[alignmentAxis] += commonAlign * ('end' === alignment ? 1 : -1) * (rtl && isVertical ? -1 : 1);
     return coords;
 }
 async function detectOverflow(state, options) {
@@ -12254,10 +12970,7 @@ async function detectOverflow(state, options) {
         height: rects.floating.height
     } : rects.reference;
     const offsetParent = await (null == platform.getOffsetParent ? void 0 : platform.getOffsetParent(elements.floating));
-    const offsetScale = await (null == platform.isElement ? void 0 : platform.isElement(offsetParent)) ? await (null == platform.getScale ? void 0 : platform.getScale(offsetParent)) || {
-        x: 1,
-        y: 1
-    } : {
+    const offsetScale = await (null == platform.isElement ? void 0 : platform.isElement(offsetParent)) && await (null == platform.getScale ? void 0 : platform.getScale(offsetParent)) || {
         x: 1,
         y: 1
     };
@@ -12365,12 +13078,11 @@ const floating_ui_core_arrow = (options)=>({
             const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
             const minPadding = floating_ui_utils_min(paddingObject[minProp], largestPossiblePadding);
             const maxPadding = floating_ui_utils_min(paddingObject[maxProp], largestPossiblePadding);
-            const min$1 = minPadding;
             const max = clientSize - arrowDimensions[length] - maxPadding;
             const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-            const offset = clamp(min$1, center, max);
-            const shouldAddOffset = !middlewareData.arrow && null != floating_ui_utils_getAlignment(placement) && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
-            const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
+            const offset = clamp(minPadding, center, max);
+            const shouldAddOffset = !middlewareData.arrow && null != floating_ui_utils_getAlignment(placement) && center !== offset && rects.reference[length] / 2 - (center < minPadding ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+            const alignmentOffset = shouldAddOffset ? center < minPadding ? center - minPadding : center - max : 0;
             return {
                 [axis]: coords[axis] + alignmentOffset,
                 data: {
@@ -12597,24 +13309,13 @@ const shift = function(options) {
                 y
             };
             const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-            const crossAxis = floating_ui_utils_getSideAxis(floating_ui_utils_getSide(placement));
+            const crossAxis = floating_ui_utils_getSideAxis(placement);
             const mainAxis = getOppositeAxis(crossAxis);
             let mainAxisCoord = coords[mainAxis];
             let crossAxisCoord = coords[crossAxis];
-            if (checkMainAxis) {
-                const minSide = 'y' === mainAxis ? 'top' : 'left';
-                const maxSide = 'y' === mainAxis ? 'bottom' : 'right';
-                const min = mainAxisCoord + overflow[minSide];
-                const max = mainAxisCoord - overflow[maxSide];
-                mainAxisCoord = clamp(min, mainAxisCoord, max);
-            }
-            if (checkCrossAxis) {
-                const minSide = 'y' === crossAxis ? 'top' : 'left';
-                const maxSide = 'y' === crossAxis ? 'bottom' : 'right';
-                const min = crossAxisCoord + overflow[minSide];
-                const max = crossAxisCoord - overflow[maxSide];
-                crossAxisCoord = clamp(min, crossAxisCoord, max);
-            }
+            const clampCoord = (axis, coord)=>clamp(coord + overflow['y' === axis ? 'top' : 'left'], coord, coord - overflow['y' === axis ? 'bottom' : 'right']);
+            if (checkMainAxis) mainAxisCoord = clampCoord(mainAxis, mainAxisCoord);
+            if (checkCrossAxis) crossAxisCoord = clampCoord(crossAxis, crossAxisCoord);
             const limitedCoords = limiter.fn({
                 ...state,
                 [mainAxis]: mainAxisCoord,
@@ -12639,6 +13340,7 @@ const limitShift = function(options) {
     return {
         options,
         fn (state) {
+            var _rawOffset$mainAxis, _rawOffset$crossAxis;
             const { x, y, placement, rects, middlewareData } = state;
             const { offset = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true } = floating_ui_utils_evaluate(options, state);
             const coords = {
@@ -12654,9 +13356,8 @@ const limitShift = function(options) {
                 mainAxis: rawOffset,
                 crossAxis: 0
             } : {
-                mainAxis: 0,
-                crossAxis: 0,
-                ...rawOffset
+                mainAxis: null != (_rawOffset$mainAxis = rawOffset.mainAxis) ? _rawOffset$mainAxis : 0,
+                crossAxis: null != (_rawOffset$crossAxis = rawOffset.crossAxis) ? _rawOffset$crossAxis : 0
             };
             if (checkMainAxis) {
                 const len = 'y' === mainAxis ? 'height' : 'width';
@@ -12687,7 +13388,6 @@ const floating_ui_core_size = function(options) {
         name: 'size',
         options,
         async fn (state) {
-            var _state$middlewareData, _state$middlewareData2;
             const { placement, rects, platform, elements } = state;
             const { apply = ()=>{}, ...detectOverflowOptions } = floating_ui_utils_evaluate(options, state);
             const overflow = await platform.detectOverflow(state, detectOverflowOptions);
@@ -12708,19 +13408,14 @@ const floating_ui_core_size = function(options) {
             const maximumClippingWidth = width - overflow.left - overflow.right;
             const overflowAvailableHeight = floating_ui_utils_min(height - overflow[heightSide], maximumClippingHeight);
             const overflowAvailableWidth = floating_ui_utils_min(width - overflow[widthSide], maximumClippingWidth);
-            const noShift = !state.middlewareData.shift;
+            const shiftData = state.middlewareData.shift;
+            const noShift = !shiftData;
             let availableHeight = overflowAvailableHeight;
             let availableWidth = overflowAvailableWidth;
-            if (null != (_state$middlewareData = state.middlewareData.shift) && _state$middlewareData.enabled.x) availableWidth = maximumClippingWidth;
-            if (null != (_state$middlewareData2 = state.middlewareData.shift) && _state$middlewareData2.enabled.y) availableHeight = maximumClippingHeight;
-            if (noShift && !alignment) {
-                const xMin = floating_ui_utils_max(overflow.left, 0);
-                const xMax = floating_ui_utils_max(overflow.right, 0);
-                const yMin = floating_ui_utils_max(overflow.top, 0);
-                const yMax = floating_ui_utils_max(overflow.bottom, 0);
-                if (isYAxis) availableWidth = width - 2 * (0 !== xMin || 0 !== xMax ? xMin + xMax : floating_ui_utils_max(overflow.left, overflow.right));
-                else availableHeight = height - 2 * (0 !== yMin || 0 !== yMax ? yMin + yMax : floating_ui_utils_max(overflow.top, overflow.bottom));
-            }
+            if (null != shiftData && shiftData.enabled.x) availableWidth = maximumClippingWidth;
+            if (null != shiftData && shiftData.enabled.y) availableHeight = maximumClippingHeight;
+            if (noShift && !alignment) if (isYAxis) availableWidth = width - 2 * floating_ui_utils_max(overflow.left, overflow.right);
+            else availableHeight = height - 2 * floating_ui_utils_max(overflow.top, overflow.bottom);
             await apply({
                 ...state,
                 availableWidth,
@@ -12828,7 +13523,7 @@ function getParentNode(node) {
 }
 function getNearestOverflowAncestor(node) {
     const parentNode = getParentNode(node);
-    if (isLastTraversableNode(parentNode)) return node.ownerDocument ? node.ownerDocument.body : node.body;
+    if (isLastTraversableNode(parentNode)) return (node.ownerDocument || node).body;
     if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
     return getNearestOverflowAncestor(parentNode);
 }
@@ -12894,8 +13589,7 @@ function getVisualOffsets(element) {
 }
 function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
     if (void 0 === isFixed) isFixed = false;
-    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) return false;
-    return isFixed;
+    return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow(element);
 }
 function floating_ui_dom_getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
     if (void 0 === includeScale) includeScale = false;
@@ -12911,12 +13605,12 @@ function floating_ui_dom_getBoundingClientRect(element, includeScale, isFixedStr
     let y = (clientRect.top + visualOffsets.y) / scale.y;
     let width = clientRect.width / scale.x;
     let height = clientRect.height / scale.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 = floating_ui_utils_dom_getComputedStyle(currentIFrame);
@@ -12966,7 +13660,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     let scale = createCoords(1);
     const offsets = createCoords(0);
     const isOffsetParentAnElement = isHTMLElement(offsetParent);
-    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (isOffsetParentAnElement || !isFixed) {
         if ('body' !== getNodeName(offsetParent) || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
         if (isOffsetParentAnElement) {
             const offsetRect = floating_ui_dom_getBoundingClientRect(offsetParent);
@@ -12984,15 +13678,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 width = floating_ui_utils_max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
     const height = floating_ui_utils_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 ('rtl' === floating_ui_utils_dom_getComputedStyle(body).direction) x += floating_ui_utils_max(html.clientWidth, body.clientWidth) - width;
     return {
@@ -13003,7 +13696,9 @@ function getDocumentRect(element) {
     };
 }
 const SCROLLBAR_MAX = 25;
-function getViewportRect(element, strategy) {
+function getViewportRect(element, strategy, rootBoundary) {
+    if (void 0 === rootBoundary) rootBoundary = 'viewport';
+    const isLayoutViewport = 'layoutViewport' === rootBoundary;
     const win = getWindow(element);
     const html = getDocumentElement(element);
     const visualViewport = win.visualViewport;
@@ -13012,12 +13707,19 @@ function getViewportRect(element, strategy) {
     let x = 0;
     let y = 0;
     if (visualViewport) {
-        width = visualViewport.width;
-        height = visualViewport.height;
-        const visualViewportBased = isWebKit();
-        if (!visualViewportBased || visualViewportBased && 'fixed' === strategy) {
-            x = visualViewport.offsetLeft;
-            y = visualViewport.offsetTop;
+        const layoutRelativeClientCoords = !isWebKit() || 'fixed' === strategy;
+        if (isLayoutViewport) {
+            if (!layoutRelativeClientCoords) {
+                x = -visualViewport.offsetLeft;
+                y = -visualViewport.offsetTop;
+            }
+        } else {
+            width = visualViewport.width;
+            height = visualViewport.height;
+            if (layoutRelativeClientCoords) {
+                x = visualViewport.offsetLeft;
+                y = visualViewport.offsetTop;
+            }
         }
     }
     const windowScrollbarX = getWindowScrollBarX(html);
@@ -13026,9 +13728,10 @@ function getViewportRect(element, strategy) {
         const body = doc.body;
         const bodyStyles = getComputedStyle(body);
         const bodyMarginInline = 'CSS1Compat' === doc.compatMode ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
-        const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
-        if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) width -= clippingStableScrollbarWidth;
-    } else if (windowScrollbarX <= SCROLLBAR_MAX) width += windowScrollbarX;
+        const reservedWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+        const gutter = 'stable both-edges' === getComputedStyle(html).scrollbarGutter ? reservedWidth / 2 : reservedWidth;
+        if (gutter <= SCROLLBAR_MAX) width -= gutter;
+    }
     return {
         width,
         height,
@@ -13040,7 +13743,7 @@ function getInnerBoundingClientRect(element, strategy) {
     const clientRect = floating_ui_dom_getBoundingClientRect(element, true, 'fixed' === strategy);
     const top = clientRect.top + element.clientTop;
     const left = clientRect.left + element.clientLeft;
-    const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+    const scale = getScale(element);
     const width = element.clientWidth * scale.x;
     const height = element.clientHeight * scale.y;
     const x = left * scale.x;
@@ -13054,7 +13757,7 @@ function getInnerBoundingClientRect(element, strategy) {
 }
 function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
     let rect;
-    if ('viewport' === clippingAncestor) rect = getViewportRect(element, strategy);
+    if ('viewport' === clippingAncestor || 'layoutViewport' === clippingAncestor) rect = getViewportRect(element, strategy, clippingAncestor);
     else if ('document' === clippingAncestor) rect = getDocumentRect(getDocumentElement(element));
     else if (isElement(clippingAncestor)) rect = getInnerBoundingClientRect(clippingAncestor, strategy);
     else {
@@ -13068,25 +13771,20 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
     }
     return floating_ui_utils_rectToClientRect(rect);
 }
-function hasFixedPositionAncestor(element, stopNode) {
-    const parentNode = getParentNode(element);
-    if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) return false;
-    return 'fixed' === floating_ui_utils_dom_getComputedStyle(parentNode).position || 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) && 'body' !== getNodeName(el));
-    let currentContainingBlockComputedStyle = null;
+    let lastKeptComputedStyle = null;
     const elementIsFixed = 'fixed' === floating_ui_utils_dom_getComputedStyle(element).position;
     let currentNode = elementIsFixed ? getParentNode(element) : element;
     while(isElement(currentNode) && !isLastTraversableNode(currentNode)){
         const computedStyle = floating_ui_utils_dom_getComputedStyle(currentNode);
         const currentNodeIsContaining = isContainingBlock(currentNode);
-        if (!currentNodeIsContaining && 'fixed' === computedStyle.position) currentContainingBlockComputedStyle = null;
-        const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && 'static' === computedStyle.position && !!currentContainingBlockComputedStyle && ('absolute' === currentContainingBlockComputedStyle.position || 'fixed' === currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+        const lastPosition = lastKeptComputedStyle ? lastKeptComputedStyle.position : elementIsFixed ? 'fixed' : '';
+        const shouldDropCurrentNode = !currentNodeIsContaining && ('fixed' === lastPosition || 'absolute' === lastPosition && 'static' === computedStyle.position);
         if (shouldDropCurrentNode) result = result.filter((ancestor)=>ancestor !== currentNode);
-        else currentContainingBlockComputedStyle = computedStyle;
+        else lastKeptComputedStyle = computedStyle;
         currentNode = getParentNode(currentNode);
     }
     cache.set(element, result);
@@ -13135,18 +13833,15 @@ 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 ('body' !== getNodeName(offsetParent) || isOverflowElement(documentElement)) scroll = getNodeScroll(offsetParent);
         if (isOffsetParentAnElement) {
             const offsetRect = floating_ui_dom_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 ? createCoords(0) : getHTMLOffset(documentElement, scroll);
     const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
     const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
@@ -13215,7 +13910,7 @@ const floating_ui_dom_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);
@@ -13245,6 +13940,7 @@ 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();
                 if (ratio) refresh(false, ratio);
@@ -13252,7 +13948,6 @@ function observeMove(element, onMove) {
                     refresh(false, 1e-7);
                 }, 1000);
             }
-            if (1 === ratio && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) refresh();
             isFirstUpdate = false;
         }
         try {
@@ -13265,8 +13960,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 (void 0 === options) options = {};
@@ -13277,12 +13978,10 @@ function autoUpdate(reference, floating, update, options) {
         ...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) {
@@ -13332,11 +14031,9 @@ const floating_ui_dom_arrow = floating_ui_core_arrow;
 const floating_ui_dom_limitShift = limitShift;
 const floating_ui_dom_computePosition = (reference, floating, options)=>{
     const cache = new Map();
-    const mergedOptions = {
-        platform: floating_ui_dom_platform,
-        ...options
-    };
+    const mergedOptions = null != options ? options : {};
     const platformWithCache = {
+        ...floating_ui_dom_platform,
         ...mergedOptions.platform,
         _c: cache
     };
@@ -13645,10 +14342,14 @@ const floating_ui_react_dom_arrow = (options, deps)=>{
         ]
     };
 };
-var NAME = "Arrow";
-var Arrow = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var react_arrow_dist_defProp = Object.defineProperty;
+var react_arrow_dist_name = (target, value1)=>react_arrow_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
+var Arrow = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_arrow_dist_name(function(props, forwardedRef) {
     const { children, width = 10, height = 5, ...arrowProps } = props;
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.svg, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.svg, {
         ...arrowProps,
         ref: forwardedRef,
         width,
@@ -13659,9 +14360,13 @@ var Arrow = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>
             points: "0,0 30,0 15,10"
         })
     });
-});
-Arrow.displayName = NAME;
+}, "Arrow"));
 var react_arrow_dist_Root = Arrow;
+var react_use_size_dist_defProp = Object.defineProperty;
+var react_use_size_dist_name = (target, value1)=>react_use_size_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 function useSize(element) {
     const [size, setSize] = __WEBPACK_EXTERNAL_MODULE_react__.useState(void 0);
     useLayoutEffect2(()=>{
@@ -13701,11 +14406,17 @@ function useSize(element) {
     ]);
     return size;
 }
+react_use_size_dist_name(useSize, "useSize");
 "use client";
+var react_popper_dist_defProp = Object.defineProperty;
+var react_popper_dist_name = (target, value1)=>react_popper_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var POPPER_NAME = "Popper";
 var [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME);
 var [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME);
-var Popper = (props)=>{
+var Popper = /* @__PURE__ */ react_popper_dist_name((props)=>{
     const { __scopePopper, children } = props;
     const [anchor, setAnchor] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     const [placementState, setPlacementState] = __WEBPACK_EXTERNAL_MODULE_react__.useState(void 0);
@@ -13717,10 +14428,9 @@ var Popper = (props)=>{
         setPlacementState,
         children
     });
-};
-Popper.displayName = POPPER_NAME;
+}, "Popper");
 var ANCHOR_NAME = "PopperAnchor";
-var PopperAnchor = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var PopperAnchor = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_popper_dist_name(function(props, forwardedRef) {
     const { __scopePopper, virtualRef, ...anchorProps } = props;
     const context = usePopperContext(ANCHOR_NAME, __scopePopper);
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
@@ -13731,7 +14441,7 @@ var PopperAnchor = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwarde
     }, [
         onAnchorChange
     ]);
-    const composedRefs = useComposedRefs(forwardedRef, callbackRef);
+    const composedRefs = dist_useComposedRefs(forwardedRef, callbackRef);
     const anchorRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (!virtualRef) return;
@@ -13742,21 +14452,20 @@ var PopperAnchor = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwarde
     const sideAndAlign = context.placementState && getSideAndAlignFromPlacement(context.placementState);
     const placedSide = sideAndAlign?.[0];
     const placedAlign = sideAndAlign?.[1];
-    return virtualRef ? null : /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return virtualRef ? null : /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         "data-radix-popper-side": placedSide,
         "data-radix-popper-align": placedAlign,
         ...anchorProps,
         ref: composedRefs
     });
-});
-PopperAnchor.displayName = ANCHOR_NAME;
+}, "PopperAnchor"));
 var CONTENT_NAME = "PopperContent";
 var [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME);
-var PopperContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var PopperContent = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_popper_dist_name(function(props, forwardedRef) {
     const { __scopePopper, side = "bottom", sideOffset = 0, align = "center", alignOffset = 0, arrowPadding = 0, avoidCollisions = true, collisionBoundary = [], collisionPadding: collisionPaddingProp = 0, sticky = "partial", hideWhenDetached = false, updatePositionStrategy = "optimized", onPlaced, ...contentProps } = props;
     const context = usePopperContext(CONTENT_NAME, __scopePopper);
     const [content, setContent] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
-    const composedRefs = useComposedRefs(forwardedRef, setContent);
+    const composedRefs = dist_useComposedRefs(forwardedRef, setContent);
     const [arrow, setArrow] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     const arrowSize = useSize(arrow);
     const arrowWidth = arrowSize?.width ?? 0;
@@ -13781,12 +14490,12 @@ var PopperContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forward
     const { refs, floatingStyles, placement, isPositioned, middlewareData } = useFloating({
         strategy: "fixed",
         placement: desiredPlacement,
-        whileElementsMounted: (...args)=>{
+        whileElementsMounted: /* @__PURE__ */ react_popper_dist_name((...args)=>{
             const cleanup = autoUpdate(...args, {
                 animationFrame: "always" === updatePositionStrategy
             });
             return cleanup;
-        },
+        }, "whileElementsMounted"),
         elements: {
             reference: context.anchor
         },
@@ -13806,14 +14515,14 @@ var PopperContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forward
             }),
             floating_ui_react_dom_size({
                 ...detectOverflowOptions,
-                apply: ({ elements, rects, availableWidth, availableHeight })=>{
+                apply: /* @__PURE__ */ react_popper_dist_name(({ 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")
             }),
             arrow && floating_ui_react_dom_arrow({
                 element: arrow,
@@ -13841,7 +14550,7 @@ var PopperContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forward
         setPlacementState
     ]);
     const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
-    const handlePlaced = useCallbackRef(onPlaced);
+    const handlePlaced = dist_useCallbackRef(onPlaced);
     useLayoutEffect2(()=>{
         if (isPositioned) handlePlaced?.();
     }, [
@@ -13883,20 +14592,19 @@ var PopperContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forward
             arrowX,
             arrowY,
             shouldHideArrow: cannotCenterArrow,
-            children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+            children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
                 "data-side": placedSide,
                 "data-align": placedAlign,
                 ...contentProps,
                 ref: composedRefs,
                 style: {
                     ...contentProps.style,
-                    animation: isPositioned ? void 0 : "none"
+                    animation: isPositioned ? contentProps.style?.animation : "none"
                 }
             })
         })
     });
-});
-PopperContent.displayName = CONTENT_NAME;
+}, "PopperContent"));
 var ARROW_NAME = "PopperArrow";
 var OPPOSITE_SIDE = {
     top: "bottom",
@@ -13904,7 +14612,7 @@ var OPPOSITE_SIDE = {
     bottom: "top",
     left: "right"
 };
-var PopperArrow = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(function(props, forwardedRef) {
+var PopperArrow = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_popper_dist_name(function(props, forwardedRef) {
     const { __scopePopper, ...arrowProps } = props;
     const contentContext = useContentContext(ARROW_NAME, __scopePopper);
     const baseSide = OPPOSITE_SIDE[contentContext.placedSide];
@@ -13938,12 +14646,12 @@ var PopperArrow = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(function(props, f
             }
         })
     });
-});
-PopperArrow.displayName = ARROW_NAME;
+}, "PopperArrow"));
 function isNotNull(value1) {
     return null !== value1;
 }
-var transformOrigin = (options)=>({
+react_popper_dist_name(isNotNull, "isNotNull");
+var transformOrigin = /* @__PURE__ */ react_popper_dist_name((options)=>({
         name: "transformOrigin",
         options,
         fn (data) {
@@ -13982,7 +14690,7 @@ var transformOrigin = (options)=>({
                 }
             };
         }
-    });
+    }), "transformOrigin");
 function getSideAndAlignFromPlacement(placement) {
     const [side, align = "center"] = placement.split("-");
     return [
@@ -13990,31 +14698,41 @@ function getSideAndAlignFromPlacement(placement) {
         align
     ];
 }
+react_popper_dist_name(getSideAndAlignFromPlacement, "getSideAndAlignFromPlacement");
 var Root2 = Popper;
 var Anchor = PopperAnchor;
 var Content = PopperContent;
 var dist_Arrow = PopperArrow;
 "use client";
-var PORTAL_NAME = "Portal";
-var Portal = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var react_portal_dist_defProp = Object.defineProperty;
+var react_portal_dist_name = (target, value1)=>react_portal_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
+var Portal = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_portal_dist_name(function(props, forwardedRef) {
     const { container: containerProp, ...portalProps } = props;
     const [mounted, setMounted] = __WEBPACK_EXTERNAL_MODULE_react__.useState(false);
     useLayoutEffect2(()=>setMounted(true), []);
     const container = containerProp || mounted && globalThis?.document?.body;
-    return container ? __WEBPACK_EXTERNAL_MODULE_react_dom_7136dc57__.createPortal(/* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return container ? __WEBPACK_EXTERNAL_MODULE_react_dom_7136dc57__.createPortal(/* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         ...portalProps,
         ref: forwardedRef
     }), container) : null;
-});
-Portal.displayName = PORTAL_NAME;
+}, "Portal"));
 "use client";
+var react_presence_dist_defProp = Object.defineProperty;
+var react_presence_dist_name = (target, value1)=>react_presence_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 function useStateMachine(initialState, machine) {
     return __WEBPACK_EXTERNAL_MODULE_react__.useReducer((state, event)=>{
         const nextState = machine[state][event];
         return nextState ?? state;
     }, initialState);
 }
-var Presence = (props)=>{
+react_presence_dist_name(useStateMachine, "useStateMachine");
+var dist_Presence = /* @__PURE__ */ react_presence_dist_name((props)=>{
     const { present, children } = props;
     const presence = usePresence(present);
     const child = "function" == typeof children ? children({
@@ -14025,8 +14743,7 @@ var Presence = (props)=>{
     return forceMount || presence.isPresent ? __WEBPACK_EXTERNAL_MODULE_react__.cloneElement(child, {
         ref
     }) : null;
-};
-Presence.displayName = "Presence";
+}, "Presence");
 function usePresence(present) {
     const [node, setNode] = __WEBPACK_EXTERNAL_MODULE_react__.useState();
     const stylesRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
@@ -14080,7 +14797,7 @@ function usePresence(present) {
         if (node) {
             let timeoutId;
             const ownerWindow = node.ownerDocument.defaultView ?? window;
-            const handleAnimationEnd = (event)=>{
+            const handleAnimationEnd = /* @__PURE__ */ react_presence_dist_name((event)=>{
                 const currentAnimationName = getAnimationName(stylesRef.current);
                 const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
                 if (event.target === node && isCurrentAnimation) {
@@ -14093,10 +14810,10 @@ function usePresence(present) {
                         });
                     }
                 }
-            };
-            const handleAnimationStart = (event)=>{
+            }, "handleAnimationEnd");
+            const handleAnimationStart = /* @__PURE__ */ react_presence_dist_name((event)=>{
                 if (event.target === node) prevAnimationNameRef.current = getAnimationName(stylesRef.current);
-            };
+            }, "handleAnimationStart");
             node.addEventListener("animationstart", handleAnimationStart);
             node.addEventListener("animationcancel", handleAnimationEnd);
             node.addEventListener("animationend", handleAnimationEnd);
@@ -14127,10 +14844,12 @@ function usePresence(present) {
         }, [])
     };
 }
+react_presence_dist_name(usePresence, "usePresence");
 function dist_setRef(ref, value1) {
     if ("function" == typeof ref) return ref(value1);
     if (null != ref) ref.current = value1;
 }
+react_presence_dist_name(dist_setRef, "setRef");
 function useStableComposedRefs(...refs) {
     const refsRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(refs);
     refsRef.current = refs;
@@ -14151,9 +14870,11 @@ function useStableComposedRefs(...refs) {
         };
     }, []);
 }
+react_presence_dist_name(useStableComposedRefs, "useStableComposedRefs");
 function getAnimationName(styles) {
     return styles?.animationName || "none";
 }
+react_presence_dist_name(getAnimationName, "getAnimationName");
 function dist_getElementRef(element) {
     let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
     let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
@@ -14163,6 +14884,29 @@ function dist_getElementRef(element) {
     if (mayWarn) return element.props.ref;
     return element.props.ref || element.ref;
 }
+react_presence_dist_name(dist_getElementRef, "getElementRef");
+var react_id_dist_defProp = Object.defineProperty;
+var react_id_dist_name = (target, value1)=>react_id_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
+var useReactId = __WEBPACK_EXTERNAL_MODULE_react__[" useId ".trim().toString()] || (()=>void 0);
+var react_id_dist_count = 0;
+function dist_useId(deterministicId) {
+    const [id, setId] = __WEBPACK_EXTERNAL_MODULE_react__.useState(useReactId());
+    useLayoutEffect2(()=>{
+        if (!deterministicId) setId((reactId)=>reactId ?? String(react_id_dist_count++));
+    }, [
+        deterministicId
+    ]);
+    return deterministicId || (id ? `radix-${id}` : "");
+}
+react_id_dist_name(dist_useId, "useId");
+var react_use_is_hydrated_dist_defProp = Object.defineProperty;
+var react_use_is_hydrated_dist_name = (target, value1)=>react_use_is_hydrated_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var _isHydrated = false;
 function useIsHydrated() {
     const [isHydrated, setIsHydrated] = __WEBPACK_EXTERNAL_MODULE_react__.useState(_isHydrated);
@@ -14174,15 +14918,23 @@ function useIsHydrated() {
     }, []);
     return isHydrated;
 }
+react_use_is_hydrated_dist_name(useIsHydrated, "useIsHydrated");
 var useReactSyncExternalStore = __WEBPACK_EXTERNAL_MODULE_react__[" useSyncExternalStore ".trim().toString()];
 function dist_subscribe() {
     return ()=>{};
 }
+react_use_is_hydrated_dist_name(dist_subscribe, "subscribe");
 function useIsHydratedModern() {
     return useReactSyncExternalStore(dist_subscribe, ()=>true, ()=>false);
 }
+react_use_is_hydrated_dist_name(useIsHydratedModern, "useIsHydratedModern");
 var useIsHydrated2 = "function" == typeof useReactSyncExternalStore ? useIsHydratedModern : useIsHydrated;
 "use client";
+var react_roving_focus_dist_defProp = Object.defineProperty;
+var react_roving_focus_dist_name = (target, value1)=>react_roving_focus_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var ENTRY_FOCUS = "rovingFocusGroup.onEntryFocus";
 var dist_EVENT_OPTIONS = {
     bubbles: false,
@@ -14194,7 +14946,8 @@ var [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContext
     dist_createCollectionScope
 ]);
 var [RovingFocusProvider, useRovingFocusContext] = createRovingFocusGroupContext(GROUP_NAME);
-var RovingFocusGroup = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>/* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Collection.Provider, {
+var RovingFocusGroup = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_roving_focus_dist_name(function(props, forwardedRef) {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Collection.Provider, {
         scope: props.__scopeRovingFocusGroup,
         children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Collection.Slot, {
             scope: props.__scopeRovingFocusGroup,
@@ -14203,12 +14956,12 @@ var RovingFocusGroup = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forw
                 ref: forwardedRef
             })
         })
-    }));
-RovingFocusGroup.displayName = GROUP_NAME;
-var RovingFocusGroupImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+    });
+}, "RovingFocusGroup"));
+var RovingFocusGroupImpl = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_roving_focus_dist_name(function(props, forwardedRef) {
     const { __scopeRovingFocusGroup, orientation, loop = false, dir, currentTabStopId: currentTabStopIdProp, defaultCurrentTabStopId, onCurrentTabStopIdChange, onEntryFocus, preventScrollOnEntryFocus = false, ...groupProps } = props;
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
+    const composedRefs = dist_useComposedRefs(forwardedRef, ref);
     const direction = useDirection(dir);
     const [currentTabStopId, setCurrentTabStopId] = dist_useControllableState({
         prop: currentTabStopIdProp,
@@ -14217,7 +14970,7 @@ var RovingFocusGroupImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
         caller: GROUP_NAME
     });
     const [isTabbingBackOut, setIsTabbingBackOut] = __WEBPACK_EXTERNAL_MODULE_react__.useState(false);
-    const handleEntryFocus = useCallbackRef(onEntryFocus);
+    const handleEntryFocus = dist_useCallbackRef(onEntryFocus);
     const getItems = dist_useCollection(__scopeRovingFocusGroup);
     const isClickFocusRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
     const [focusableItemsCount, setFocusableItemsCount] = __WEBPACK_EXTERNAL_MODULE_react__.useState(0);
@@ -14242,7 +14995,7 @@ var RovingFocusGroupImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
         onItemShiftTab: __WEBPACK_EXTERNAL_MODULE_react__.useCallback(()=>setIsTabbingBackOut(true), []),
         onFocusableItemAdd: __WEBPACK_EXTERNAL_MODULE_react__.useCallback(()=>setFocusableItemsCount((prevCount)=>prevCount + 1), []),
         onFocusableItemRemove: __WEBPACK_EXTERNAL_MODULE_react__.useCallback(()=>setFocusableItemsCount((prevCount)=>prevCount - 1), []),
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
             tabIndex: isTabbingBackOut || 0 === focusableItemsCount ? -1 : 0,
             "data-orientation": orientation,
             ...groupProps,
@@ -14251,10 +15004,10 @@ var RovingFocusGroupImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
                 outline: "none",
                 ...props.style
             },
-            onMouseDown: composeEventHandlers(props.onMouseDown, ()=>{
+            onMouseDown: dist_composeEventHandlers(props.onMouseDown, ()=>{
                 isClickFocusRef.current = true;
             }),
-            onFocus: composeEventHandlers(props.onFocus, (event)=>{
+            onFocus: dist_composeEventHandlers(props.onFocus, (event)=>{
                 const isKeyboardFocus = !isClickFocusRef.current;
                 if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {
                     const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, dist_EVENT_OPTIONS);
@@ -14274,14 +15027,14 @@ var RovingFocusGroupImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
                 }
                 isClickFocusRef.current = false;
             }),
-            onBlur: composeEventHandlers(props.onBlur, ()=>setIsTabbingBackOut(false))
+            onBlur: dist_composeEventHandlers(props.onBlur, ()=>setIsTabbingBackOut(false))
         })
     });
-});
+}, "RovingFocusGroupImpl"));
 var ITEM_NAME = "RovingFocusGroupItem";
-var RovingFocusGroupItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var RovingFocusGroupItem = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_roving_focus_dist_name(function(props, forwardedRef) {
     const { __scopeRovingFocusGroup, focusable = true, active = false, tabStopId, children, ...itemProps } = props;
-    const autoId = useId();
+    const autoId = dist_useId();
     const id = tabStopId || autoId;
     const context = useRovingFocusContext(ITEM_NAME, __scopeRovingFocusGroup);
     const isCurrentTabStop = context.currentTabStopId === id;
@@ -14313,17 +15066,17 @@ var RovingFocusGroupItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
         id,
         focusable,
         active,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.span, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.span, {
             tabIndex: isCurrentTabStop ? 0 : -1,
             "data-orientation": context.orientation,
             ...itemProps,
             ref: forwardedRef,
-            onMouseDown: composeEventHandlers(props.onMouseDown, (event)=>{
+            onMouseDown: dist_composeEventHandlers(props.onMouseDown, (event)=>{
                 if (focusable) context.onItemFocus(id);
                 else event.preventDefault();
             }),
-            onFocus: composeEventHandlers(props.onFocus, ()=>context.onItemFocus(id)),
-            onKeyDown: composeEventHandlers(props.onKeyDown, (event)=>{
+            onFocus: dist_composeEventHandlers(props.onFocus, ()=>context.onItemFocus(id)),
+            onKeyDown: dist_composeEventHandlers(props.onKeyDown, (event)=>{
                 if ("Tab" === event.key && event.shiftKey) return void context.onItemShiftTab();
                 if (event.target !== event.currentTarget) return;
                 const focusIntent = getFocusIntent(event, context.orientation, context.dir);
@@ -14347,8 +15100,7 @@ var RovingFocusGroupItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
             }) : children
         })
     });
-});
-RovingFocusGroupItem.displayName = ITEM_NAME;
+}, "RovingFocusGroupItem"));
 var MAP_KEY_TO_FOCUS_INTENT = {
     ArrowLeft: "prev",
     ArrowUp: "prev",
@@ -14363,6 +15115,7 @@ function getDirectionAwareKey(key, dir) {
     if ("rtl" !== dir) return key;
     return "ArrowLeft" === key ? "ArrowRight" : "ArrowRight" === key ? "ArrowLeft" : key;
 }
+react_roving_focus_dist_name(getDirectionAwareKey, "getDirectionAwareKey");
 function getFocusIntent(event, orientation, dir) {
     const key = getDirectionAwareKey(event.key, dir);
     if ("vertical" === orientation && [
@@ -14375,6 +15128,7 @@ function getFocusIntent(event, orientation, dir) {
     ].includes(key)) return;
     return MAP_KEY_TO_FOCUS_INTENT[key];
 }
+react_roving_focus_dist_name(getFocusIntent, "getFocusIntent");
 function dist_focusFirst(candidates, preventScroll = false) {
     const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
     for (const candidate of candidates){
@@ -14385,9 +15139,11 @@ function dist_focusFirst(candidates, preventScroll = false) {
         if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
     }
 }
+react_roving_focus_dist_name(dist_focusFirst, "focusFirst");
 function wrapArray(array, startIndex) {
     return array.map((_, index)=>array[(startIndex + index) % array.length]);
 }
+react_roving_focus_dist_name(wrapArray, "wrapArray");
 var react_roving_focus_dist_Root = RovingFocusGroup;
 var Item = RovingFocusGroupItem;
 var getDefaultParent = function(originalTarget) {
@@ -15150,6 +15906,11 @@ var ReactRemoveScroll = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(function(pr
 ReactRemoveScroll.classNames = RemoveScroll.classNames;
 const Combination = ReactRemoveScroll;
 "use client";
+var react_menu_dist_defProp = Object.defineProperty;
+var react_menu_dist_name = (target, value1)=>react_menu_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var SELECTION_KEYS = [
     "Enter",
     " "
@@ -15168,24 +15929,11 @@ var FIRST_LAST_KEYS = [
     ...FIRST_KEYS,
     ...LAST_KEYS
 ];
-var SUB_OPEN_KEYS = {
-    ltr: [
-        ...SELECTION_KEYS,
-        "ArrowRight"
-    ],
-    rtl: [
-        ...SELECTION_KEYS,
-        "ArrowLeft"
-    ]
-};
-var SUB_CLOSE_KEYS = {
-    ltr: [
-        "ArrowLeft"
-    ],
-    rtl: [
-        "ArrowRight"
-    ]
-};
+[
+    ...SELECTION_KEYS
+], [
+    ...SELECTION_KEYS
+];
 var MENU_NAME = "Menu";
 var [dist_Collection, react_menu_dist_useCollection, react_menu_dist_createCollectionScope] = createCollection(MENU_NAME);
 var [createMenuContext, createMenuScope] = createContextScope(MENU_NAME, [
@@ -15197,15 +15945,15 @@ var usePopperScope = createPopperScope();
 var useRovingFocusGroupScope = createRovingFocusGroupScope();
 var [MenuProvider, useMenuContext] = createMenuContext(MENU_NAME);
 var [MenuRootProvider, useMenuRootContext] = createMenuContext(MENU_NAME);
-var Menu = (props)=>{
+var Menu = /* @__PURE__ */ react_menu_dist_name((props)=>{
     const { __scopeMenu, open = false, children, dir, onOpenChange, modal = true } = props;
     const popperScope = usePopperScope(__scopeMenu);
     const [content, setContent] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     const isUsingKeyboardRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
-    const handleOpenChange = useCallbackRef(onOpenChange);
+    const handleOpenChange = dist_useCallbackRef(onOpenChange);
     const direction = useDirection(dir);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
-        const handleKeyDown = ()=>{
+        const handleKeyDown = /* @__PURE__ */ react_menu_dist_name(()=>{
             isUsingKeyboardRef.current = true;
             document.addEventListener("pointerdown", handlePointer, {
                 capture: true,
@@ -15215,8 +15963,8 @@ var Menu = (props)=>{
                 capture: true,
                 once: true
             });
-        };
-        const handlePointer = ()=>isUsingKeyboardRef.current = false;
+        }, "handleKeyDown");
+        const handlePointer = /* @__PURE__ */ react_menu_dist_name(()=>isUsingKeyboardRef.current = false, "handlePointer");
         document.addEventListener("keydown", handleKeyDown, {
             capture: true
         });
@@ -15234,7 +15982,7 @@ var Menu = (props)=>{
     }, []);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (!open) return;
-        const handleBlur = ()=>handleOpenChange(false);
+        const handleBlur = /* @__PURE__ */ react_menu_dist_name(()=>handleOpenChange(false), "handleBlur");
         window.addEventListener("blur", handleBlur);
         return ()=>window.removeEventListener("blur", handleBlur);
     }, [
@@ -15261,10 +16009,8 @@ var Menu = (props)=>{
             })
         })
     });
-};
-Menu.displayName = MENU_NAME;
-var dist_ANCHOR_NAME = "MenuAnchor";
-var MenuAnchor = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "Menu");
+var MenuAnchor = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const { __scopeMenu, ...anchorProps } = props;
     const popperScope = usePopperScope(__scopeMenu);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Anchor, {
@@ -15272,19 +16018,18 @@ var MenuAnchor = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedR
         ...anchorProps,
         ref: forwardedRef
     });
-});
-MenuAnchor.displayName = dist_ANCHOR_NAME;
-var dist_PORTAL_NAME = "MenuPortal";
-var [PortalProvider, usePortalContext] = createMenuContext(dist_PORTAL_NAME, {
+}, "MenuAnchor"));
+var PORTAL_NAME = "MenuPortal";
+var [PortalProvider, usePortalContext] = createMenuContext(PORTAL_NAME, {
     forceMount: void 0
 });
-var MenuPortal = (props)=>{
+var MenuPortal = /* @__PURE__ */ react_menu_dist_name((props)=>{
     const { __scopeMenu, forceMount, children, container } = props;
-    const context = useMenuContext(dist_PORTAL_NAME, __scopeMenu);
+    const context = useMenuContext(PORTAL_NAME, __scopeMenu);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(PortalProvider, {
         scope: __scopeMenu,
         forceMount,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
             present: forceMount || context.open,
             children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Portal, {
                 asChild: true,
@@ -15293,18 +16038,17 @@ var MenuPortal = (props)=>{
             })
         })
     });
-};
-MenuPortal.displayName = dist_PORTAL_NAME;
+}, "MenuPortal");
 var dist_CONTENT_NAME = "MenuContent";
 var [MenuContentProvider, useMenuContentContext] = createMenuContext(dist_CONTENT_NAME);
-var MenuContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var MenuContent = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const portalContext = usePortalContext(dist_CONTENT_NAME, props.__scopeMenu);
     const { forceMount = portalContext.forceMount, ...contentProps } = props;
     const context = useMenuContext(dist_CONTENT_NAME, props.__scopeMenu);
     const rootContext = useMenuRootContext(dist_CONTENT_NAME, props.__scopeMenu);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Collection.Provider, {
         scope: props.__scopeMenu,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
             present: forceMount || context.open,
             children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Collection.Slot, {
                 scope: props.__scopeMenu,
@@ -15318,11 +16062,11 @@ var MenuContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwarded
             })
         })
     });
-});
-var MenuRootContentModal = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "MenuContent"));
+var MenuRootContentModal = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const context = useMenuContext(dist_CONTENT_NAME, props.__scopeMenu);
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
+    const composedRefs = dist_useComposedRefs(forwardedRef, ref);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         const content = ref.current;
         if (content) return hideOthers(content);
@@ -15333,13 +16077,13 @@ var MenuRootContentModal = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
         trapFocus: context.open,
         disableOutsidePointerEvents: context.open,
         disableOutsideScroll: true,
-        onFocusOutside: composeEventHandlers(props.onFocusOutside, (event)=>event.preventDefault(), {
+        onFocusOutside: dist_composeEventHandlers(props.onFocusOutside, (event)=>event.preventDefault(), {
             checkForDefaultPrevented: false
         }),
         onDismiss: ()=>context.onOpenChange(false)
     });
-});
-var MenuRootContentNonModal = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "MenuRootContentModal"));
+var MenuRootContentNonModal = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const context = useMenuContext(dist_CONTENT_NAME, props.__scopeMenu);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuContentImpl, {
         ...props,
@@ -15349,9 +16093,9 @@ var MenuRootContentNonModal = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
         disableOutsideScroll: false,
         onDismiss: ()=>context.onOpenChange(false)
     });
-});
+}, "MenuRootContentNonModal"));
 var react_menu_dist_Slot = createSlot("MenuContent.ScrollLock");
-var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var MenuContentImpl = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const { __scopeMenu, loop = false, trapFocus, onOpenAutoFocus, onCloseAutoFocus, disableOutsidePointerEvents, onEntryFocus, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, onDismiss, disableOutsideScroll, ...contentProps } = props;
     const context = useMenuContext(dist_CONTENT_NAME, __scopeMenu);
     const rootContext = useMenuRootContext(dist_CONTENT_NAME, __scopeMenu);
@@ -15360,7 +16104,7 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
     const getItems = react_menu_dist_useCollection(__scopeMenu);
     const [currentItemId, setCurrentItemId] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     const contentRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, contentRef, context.onContentChange);
+    const composedRefs = dist_useComposedRefs(forwardedRef, contentRef, context.onContentChange);
     const timerRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(0);
     const searchRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef("");
     const pointerGraceTimerRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(0);
@@ -15372,7 +16116,7 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
         as: react_menu_dist_Slot,
         allowPinchZoom: true
     } : void 0;
-    const handleTypeaheadSearch = (key)=>{
+    const handleTypeaheadSearch = /* @__PURE__ */ react_menu_dist_name((key)=>{
         const search = searchRef.current + key;
         const items = getItems().filter((item)=>!item.disabled);
         const currentItem = document.activeElement;
@@ -15380,13 +16124,8 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
         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(value1) {
-            searchRef.current = value1;
-            window.clearTimeout(timerRef.current);
-            if ("" !== value1) timerRef.current = window.setTimeout(()=>updateSearch(""), 1e3);
-        })(search);
         if (newItem) setTimeout(()=>newItem.focus());
-    };
+    }, "handleTypeaheadSearch");
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>()=>window.clearTimeout(timerRef.current), []);
     useFocusGuards();
     const isPointerMovingToSubmenu = __WEBPACK_EXTERNAL_MODULE_react__.useCallback((event)=>{
@@ -15422,7 +16161,7 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
             children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(FocusScope, {
                 asChild: true,
                 trapped: trapFocus,
-                onMountAutoFocus: composeEventHandlers(onOpenAutoFocus, (event)=>{
+                onMountAutoFocus: dist_composeEventHandlers(onOpenAutoFocus, (event)=>{
                     event.preventDefault();
                     contentRef.current?.focus({
                         preventScroll: true
@@ -15445,7 +16184,7 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
                         loop,
                         currentTabStopId: currentItemId,
                         onCurrentTabStopIdChange: setCurrentItemId,
-                        onEntryFocus: composeEventHandlers(onEntryFocus, (event)=>{
+                        onEntryFocus: dist_composeEventHandlers(onEntryFocus, (event)=>{
                             if (!rootContext.isUsingKeyboardRef.current) event.preventDefault();
                         }),
                         preventScrollOnEntryFocus: true,
@@ -15462,7 +16201,7 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
                                 outline: "none",
                                 ...contentProps.style
                             },
-                            onKeyDown: composeEventHandlers(contentProps.onKeyDown, (event)=>{
+                            onKeyDown: dist_composeEventHandlers(contentProps.onKeyDown, (event)=>{
                                 const target = event.target;
                                 const isKeyDownInside = target.closest("[data-radix-menu-content]") === event.currentTarget;
                                 const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
@@ -15480,13 +16219,13 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
                                 if (LAST_KEYS.includes(event.key)) candidateNodes.reverse();
                                 react_menu_dist_focusFirst(candidateNodes);
                             }),
-                            onBlur: composeEventHandlers(props.onBlur, (event)=>{
+                            onBlur: dist_composeEventHandlers(props.onBlur, (event)=>{
                                 if (!event.currentTarget.contains(event.target)) {
                                     window.clearTimeout(timerRef.current);
                                     searchRef.current = "";
                                 }
                             }),
-                            onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse((event)=>{
+                            onPointerMove: dist_composeEventHandlers(props.onPointerMove, whenMouse((event)=>{
                                 const target = event.target;
                                 const pointerXHasChanged = lastPointerXRef.current !== event.clientX;
                                 if (event.currentTarget.contains(target) && pointerXHasChanged) {
@@ -15501,37 +16240,17 @@ var MenuContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwa
             })
         })
     });
-});
-MenuContent.displayName = dist_CONTENT_NAME;
-var dist_GROUP_NAME = "MenuGroup";
-var MenuGroup = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeMenu, ...groupProps } = props;
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
-        role: "group",
-        ...groupProps,
-        ref: forwardedRef
-    });
-});
-MenuGroup.displayName = dist_GROUP_NAME;
-var LABEL_NAME = "MenuLabel";
-var MenuLabel = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeMenu, ...labelProps } = props;
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
-        ...labelProps,
-        ref: forwardedRef
-    });
-});
-MenuLabel.displayName = LABEL_NAME;
+}, "MenuContentImpl"));
 var dist_ITEM_NAME = "MenuItem";
 var ITEM_SELECT = "menu.itemSelect";
-var MenuItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var MenuItem = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const { disabled = false, onSelect, ...itemProps } = props;
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
     const rootContext = useMenuRootContext(dist_ITEM_NAME, props.__scopeMenu);
     const contentContext = useMenuContentContext(dist_ITEM_NAME, props.__scopeMenu);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
+    const composedRefs = dist_useComposedRefs(forwardedRef, ref);
     const isPointerDownRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
-    const handleSelect = ()=>{
+    const handleSelect = /* @__PURE__ */ react_menu_dist_name(()=>{
         const menuItem = ref.current;
         if (!disabled && menuItem) {
             const itemSelectEvent = new CustomEvent(ITEM_SELECT, {
@@ -15545,20 +16264,20 @@ var MenuItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef
             if (itemSelectEvent.defaultPrevented) isPointerDownRef.current = false;
             else rootContext.onClose();
         }
-    };
+    }, "handleSelect");
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuItemImpl, {
         ...itemProps,
         ref: composedRefs,
         disabled,
-        onClick: composeEventHandlers(props.onClick, handleSelect),
+        onClick: dist_composeEventHandlers(props.onClick, handleSelect),
         onPointerDown: (event)=>{
             props.onPointerDown?.(event);
             isPointerDownRef.current = true;
         },
-        onPointerUp: composeEventHandlers(props.onPointerUp, (event)=>{
+        onPointerUp: dist_composeEventHandlers(props.onPointerUp, (event)=>{
             if (!isPointerDownRef.current) event.currentTarget?.click();
         }),
-        onKeyDown: composeEventHandlers(props.onKeyDown, (event)=>{
+        onKeyDown: dist_composeEventHandlers(props.onKeyDown, (event)=>{
             if (disabled || event.target !== event.currentTarget) return;
             const isTypingAhead = "" !== contentContext.searchRef.current;
             if (isTypingAhead && " " === event.key) return;
@@ -15568,14 +16287,13 @@ var MenuItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef
             }
         })
     });
-});
-MenuItem.displayName = dist_ITEM_NAME;
-var MenuItemImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "MenuItem"));
+var MenuItemImpl = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const { __scopeMenu, disabled = false, textValue, ...itemProps } = props;
     const contentContext = useMenuContentContext(dist_ITEM_NAME, __scopeMenu);
     const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
+    const composedRefs = dist_useComposedRefs(forwardedRef, ref);
     const [isFocused, setIsFocused] = __WEBPACK_EXTERNAL_MODULE_react__.useState(false);
     const [textContent, setTextContent] = __WEBPACK_EXTERNAL_MODULE_react__.useState("");
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
@@ -15592,14 +16310,14 @@ var MenuItemImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwarde
             asChild: true,
             ...rovingFocusGroupScope,
             focusable: !disabled,
-            children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+            children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
                 role: "menuitem",
                 "data-highlighted": isFocused ? "" : void 0,
                 "aria-disabled": disabled || void 0,
                 "data-disabled": disabled ? "" : void 0,
                 ...itemProps,
                 ref: composedRefs,
-                onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse((event)=>{
+                onPointerMove: dist_composeEventHandlers(props.onPointerMove, whenMouse((event)=>{
                     if (disabled) contentContext.onItemLeave(event);
                     else {
                         contentContext.onItemEnter(event);
@@ -15611,321 +16329,45 @@ var MenuItemImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwarde
                         }
                     }
                 })),
-                onPointerLeave: composeEventHandlers(props.onPointerLeave, whenMouse((event)=>contentContext.onItemLeave(event))),
-                onFocus: composeEventHandlers(props.onFocus, ()=>setIsFocused(true)),
-                onBlur: composeEventHandlers(props.onBlur, ()=>setIsFocused(false))
-            })
-        })
-    });
-});
-var CHECKBOX_ITEM_NAME = "MenuCheckboxItem";
-var MenuCheckboxItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { checked = false, onCheckedChange, ...checkboxItemProps } = props;
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ItemIndicatorProvider, {
-        scope: props.__scopeMenu,
-        checked,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(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
+                onPointerLeave: dist_composeEventHandlers(props.onPointerLeave, whenMouse((event)=>contentContext.onItemLeave(event))),
+                onFocus: dist_composeEventHandlers(props.onFocus, ()=>setIsFocused(true)),
+                onBlur: dist_composeEventHandlers(props.onBlur, ()=>setIsFocused(false))
             })
         })
     });
-});
-MenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME;
+}, "MenuItemImpl"));
 var RADIO_GROUP_NAME = "MenuRadioGroup";
 var [RadioGroupProvider, useRadioGroupContext] = createMenuContext(RADIO_GROUP_NAME, {
     value: void 0,
-    onValueChange: ()=>{}
-});
-var MenuRadioGroup = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { value: value1, onValueChange, ...groupProps } = props;
-    const handleValueChange = useCallbackRef(onValueChange);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(RadioGroupProvider, {
-        scope: props.__scopeMenu,
-        value: value1,
-        onValueChange: handleValueChange,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuGroup, {
-            ...groupProps,
-            ref: forwardedRef
-        })
-    });
-});
-MenuRadioGroup.displayName = RADIO_GROUP_NAME;
-var RADIO_ITEM_NAME = "MenuRadioItem";
-var MenuRadioItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { value: value1, ...radioItemProps } = props;
-    const context = useRadioGroupContext(RADIO_ITEM_NAME, props.__scopeMenu);
-    const checked = value1 === context.value;
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ItemIndicatorProvider, {
-        scope: props.__scopeMenu,
-        checked,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuItem, {
-            role: "menuitemradio",
-            "aria-checked": checked,
-            ...radioItemProps,
-            ref: forwardedRef,
-            "data-state": getCheckedState(checked),
-            onSelect: composeEventHandlers(radioItemProps.onSelect, ()=>context.onValueChange?.(value1), {
-                checkForDefaultPrevented: false
-            })
-        })
-    });
+    onValueChange: /* @__PURE__ */ react_menu_dist_name(()=>{}, "onValueChange")
 });
-MenuRadioItem.displayName = RADIO_ITEM_NAME;
 var ITEM_INDICATOR_NAME = "MenuItemIndicator";
 var [ItemIndicatorProvider, useItemIndicatorContext] = createMenuContext(ITEM_INDICATOR_NAME, {
     checked: false
 });
-var MenuItemIndicator = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeMenu, forceMount, ...itemIndicatorProps } = props;
-    const indicatorContext = useItemIndicatorContext(ITEM_INDICATOR_NAME, __scopeMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
-        present: forceMount || isIndeterminate(indicatorContext.checked) || true === indicatorContext.checked,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.span, {
-            ...itemIndicatorProps,
-            ref: forwardedRef,
-            "data-state": getCheckedState(indicatorContext.checked)
-        })
-    });
-});
-MenuItemIndicator.displayName = ITEM_INDICATOR_NAME;
-var SEPARATOR_NAME = "MenuSeparator";
-var MenuSeparator = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var MenuSeparator = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_menu_dist_name(function(props, forwardedRef) {
     const { __scopeMenu, ...separatorProps } = props;
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         role: "separator",
         "aria-orientation": "horizontal",
         ...separatorProps,
         ref: forwardedRef
     });
-});
-MenuSeparator.displayName = SEPARATOR_NAME;
-var dist_ARROW_NAME = "MenuArrow";
-var MenuArrow = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeMenu, ...arrowProps } = props;
-    const popperScope = usePopperScope(__scopeMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Arrow, {
-        ...popperScope,
-        ...arrowProps,
-        ref: forwardedRef
-    });
-});
-MenuArrow.displayName = dist_ARROW_NAME;
+}, "MenuSeparator"));
 var SUB_NAME = "MenuSub";
 var [MenuSubProvider, useMenuSubContext] = createMenuContext(SUB_NAME);
-var MenuSub = (props)=>{
-    const { __scopeMenu, children, open = false, onOpenChange } = props;
-    const parentMenuContext = useMenuContext(SUB_NAME, __scopeMenu);
-    const popperScope = usePopperScope(__scopeMenu);
-    const [trigger, setTrigger] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
-    const [content, setContent] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
-    const handleOpenChange = useCallbackRef(onOpenChange);
-    __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
-        if (false === parentMenuContext.open) handleOpenChange(false);
-        return ()=>handleOpenChange(false);
-    }, [
-        parentMenuContext.open,
-        handleOpenChange
-    ]);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Root2, {
-        ...popperScope,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuProvider, {
-            scope: __scopeMenu,
-            open,
-            onOpenChange: handleOpenChange,
-            content,
-            onContentChange: setContent,
-            children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuSubProvider, {
-                scope: __scopeMenu,
-                contentId: useId(),
-                triggerId: useId(),
-                trigger,
-                onTriggerChange: setTrigger,
-                children
-            })
-        })
-    });
-};
-MenuSub.displayName = SUB_NAME;
-var SUB_TRIGGER_NAME = "MenuSubTrigger";
-var MenuSubTrigger = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((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);
-    const contentContext = useMenuContentContext(SUB_TRIGGER_NAME, props.__scopeMenu);
-    const openTimerRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const { pointerGraceTimerRef, onPointerGraceIntentChange } = contentContext;
-    const scope = {
-        __scopeMenu: props.__scopeMenu
-    };
-    const clearOpenTimer = __WEBPACK_EXTERNAL_MODULE_react__.useCallback(()=>{
-        if (openTimerRef.current) window.clearTimeout(openTimerRef.current);
-        openTimerRef.current = null;
-    }, []);
-    __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>clearOpenTimer, [
-        clearOpenTimer
-    ]);
-    __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
-        const pointerGraceTimer = pointerGraceTimerRef.current;
-        return ()=>{
-            window.clearTimeout(pointerGraceTimer);
-            onPointerGraceIntentChange(null);
-        };
-    }, [
-        pointerGraceTimerRef,
-        onPointerGraceIntentChange
-    ]);
-    const composedRefs = useComposedRefs(forwardedRef, subContext.onTriggerChange);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuAnchor, {
-        asChild: true,
-        ...scope,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuItemImpl, {
-            id: subContext.triggerId,
-            "aria-haspopup": "menu",
-            "aria-expanded": context.open,
-            "aria-controls": context.open ? subContext.contentId : void 0,
-            "data-state": getOpenState(context.open),
-            ...props,
-            ref: composedRefs,
-            onClick: (event)=>{
-                props.onClick?.(event);
-                if (props.disabled || event.defaultPrevented) return;
-                event.currentTarget.focus();
-                if (!context.open) context.onOpenChange(true);
-            },
-            onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse((event)=>{
-                contentContext.onItemEnter(event);
-                if (event.defaultPrevented) return;
-                if (!props.disabled && !context.open && !openTimerRef.current) {
-                    contentContext.onPointerGraceIntentChange(null);
-                    openTimerRef.current = window.setTimeout(()=>{
-                        context.onOpenChange(true);
-                        clearOpenTimer();
-                    }, 100);
-                }
-            })),
-            onPointerLeave: composeEventHandlers(props.onPointerLeave, whenMouse((event)=>{
-                clearOpenTimer();
-                const contentRect = context.content?.getBoundingClientRect();
-                if (contentRect) {
-                    const side = context.content?.dataset.side;
-                    const rightSide = "right" === side;
-                    const bleed = rightSide ? -5 : 5;
-                    const contentNearEdge = contentRect[rightSide ? "left" : "right"];
-                    const contentFarEdge = contentRect[rightSide ? "right" : "left"];
-                    contentContext.onPointerGraceIntentChange({
-                        area: [
-                            {
-                                x: event.clientX + bleed,
-                                y: event.clientY
-                            },
-                            {
-                                x: contentNearEdge,
-                                y: contentRect.top
-                            },
-                            {
-                                x: contentFarEdge,
-                                y: contentRect.top
-                            },
-                            {
-                                x: contentFarEdge,
-                                y: contentRect.bottom
-                            },
-                            {
-                                x: contentNearEdge,
-                                y: contentRect.bottom
-                            }
-                        ],
-                        side
-                    });
-                    window.clearTimeout(pointerGraceTimerRef.current);
-                    pointerGraceTimerRef.current = window.setTimeout(()=>contentContext.onPointerGraceIntentChange(null), 300);
-                } else {
-                    contentContext.onTriggerLeave(event);
-                    if (event.defaultPrevented) return;
-                    contentContext.onPointerGraceIntentChange(null);
-                }
-            })),
-            onKeyDown: composeEventHandlers(props.onKeyDown, (event)=>{
-                if (props.disabled || event.target !== event.currentTarget) return;
-                const isTypingAhead = "" !== contentContext.searchRef.current;
-                if (isTypingAhead && " " === event.key) return;
-                if (SUB_OPEN_KEYS[rootContext.dir].includes(event.key)) {
-                    context.onOpenChange(true);
-                    context.content?.focus();
-                    event.preventDefault();
-                }
-            })
-        })
-    });
-});
-MenuSubTrigger.displayName = SUB_TRIGGER_NAME;
-var SUB_CONTENT_NAME = "MenuSubContent";
-var MenuSubContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const portalContext = usePortalContext(dist_CONTENT_NAME, props.__scopeMenu);
-    const { forceMount = portalContext.forceMount, align = "start", ...subContentProps } = props;
-    const context = useMenuContext(dist_CONTENT_NAME, props.__scopeMenu);
-    const rootContext = useMenuRootContext(dist_CONTENT_NAME, props.__scopeMenu);
-    const subContext = useMenuSubContext(SUB_CONTENT_NAME, props.__scopeMenu);
-    const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Collection.Provider, {
-        scope: props.__scopeMenu,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
-            present: forceMount || context.open,
-            children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Collection.Slot, {
-                scope: props.__scopeMenu,
-                children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MenuContentImpl, {
-                    id: subContext.contentId,
-                    "aria-labelledby": subContext.triggerId,
-                    ...subContentProps,
-                    ref: composedRefs,
-                    align,
-                    side: "rtl" === rootContext.dir ? "left" : "right",
-                    disableOutsidePointerEvents: false,
-                    disableOutsideScroll: false,
-                    trapFocus: false,
-                    onOpenAutoFocus: (event)=>{
-                        if (rootContext.isUsingKeyboardRef.current) ref.current?.focus();
-                        event.preventDefault();
-                    },
-                    onCloseAutoFocus: (event)=>event.preventDefault(),
-                    onFocusOutside: composeEventHandlers(props.onFocusOutside, (event)=>{
-                        if (event.target !== subContext.trigger) context.onOpenChange(false);
-                    }),
-                    onEscapeKeyDown: composeEventHandlers(props.onEscapeKeyDown, (event)=>{
-                        rootContext.onClose();
-                        event.preventDefault();
-                    }),
-                    onKeyDown: composeEventHandlers(props.onKeyDown, (event)=>{
-                        const isKeyDownInside = event.currentTarget.contains(event.target);
-                        const isCloseKey = SUB_CLOSE_KEYS[rootContext.dir].includes(event.key);
-                        if (isKeyDownInside && isCloseKey) {
-                            context.onOpenChange(false);
-                            subContext.trigger?.focus();
-                            event.preventDefault();
-                        }
-                    })
-                })
-            })
-        })
-    });
-});
-MenuSubContent.displayName = SUB_CONTENT_NAME;
 function getOpenState(open) {
     return open ? "open" : "closed";
 }
+react_menu_dist_name(getOpenState, "getOpenState");
 function isIndeterminate(checked) {
     return "indeterminate" === checked;
 }
+react_menu_dist_name(isIndeterminate, "isIndeterminate");
 function getCheckedState(checked) {
     return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
 }
+react_menu_dist_name(getCheckedState, "getCheckedState");
 function react_menu_dist_focusFirst(candidates) {
     const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
     for (const candidate of candidates){
@@ -15934,9 +16376,11 @@ function react_menu_dist_focusFirst(candidates) {
         if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
     }
 }
+react_menu_dist_name(react_menu_dist_focusFirst, "focusFirst");
 function dist_wrapArray(array, startIndex) {
     return array.map((_, index)=>array[(startIndex + index) % array.length]);
 }
+react_menu_dist_name(dist_wrapArray, "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;
@@ -15947,6 +16391,7 @@ function getNextMatch(values, search, currentMatch) {
     const nextMatch = wrappedValues.find((value1)=>value1.toLowerCase().startsWith(normalizedSearch.toLowerCase()));
     return nextMatch !== currentMatch ? nextMatch : void 0;
 }
+react_menu_dist_name(getNextMatch, "getNextMatch");
 function isPointInPolygon(point, polygon) {
     const { x, y } = point;
     let inside = false;
@@ -15962,6 +16407,7 @@ function isPointInPolygon(point, polygon) {
     }
     return inside;
 }
+react_menu_dist_name(isPointInPolygon, "isPointInPolygon");
 function isPointerInGraceArea(event, area) {
     if (!area) return false;
     const cursorPos = {
@@ -15970,32 +16416,30 @@ function isPointerInGraceArea(event, area) {
     };
     return isPointInPolygon(cursorPos, area);
 }
+react_menu_dist_name(isPointerInGraceArea, "isPointerInGraceArea");
 function whenMouse(handler) {
     return (event)=>"mouse" === event.pointerType ? handler(event) : void 0;
 }
+react_menu_dist_name(whenMouse, "whenMouse");
 var Root3 = Menu;
 var Anchor2 = MenuAnchor;
 var dist_Portal = MenuPortal;
 var Content2 = MenuContent;
-var Group = MenuGroup;
-var Label = MenuLabel;
 var Item2 = MenuItem;
-var CheckboxItem = MenuCheckboxItem;
-var RadioGroup = MenuRadioGroup;
-var RadioItem = MenuRadioItem;
-var ItemIndicator = MenuItemIndicator;
 var Separator = MenuSeparator;
-var Arrow2 = MenuArrow;
-var SubTrigger = MenuSubTrigger;
-var SubContent = MenuSubContent;
 "use client";
+var react_dropdown_menu_dist_defProp = Object.defineProperty;
+var react_dropdown_menu_dist_name = (target, value1)=>react_dropdown_menu_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var DROPDOWN_MENU_NAME = "DropdownMenu";
 var [createDropdownMenuContext, createDropdownMenuScope] = createContextScope(DROPDOWN_MENU_NAME, [
     createMenuScope
 ]);
 var useMenuScope = createMenuScope();
 var [DropdownMenuProvider, useDropdownMenuContext] = createDropdownMenuContext(DROPDOWN_MENU_NAME);
-var DropdownMenu = (props)=>{
+var DropdownMenu = /* @__PURE__ */ react_dropdown_menu_dist_name((props)=>{
     const { __scopeDropdownMenu, children, dir, open: openProp, defaultOpen, onOpenChange, modal = true } = props;
     const menuScope = useMenuScope(__scopeDropdownMenu);
     const triggerRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
@@ -16007,9 +16451,9 @@ var DropdownMenu = (props)=>{
     });
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(DropdownMenuProvider, {
         scope: __scopeDropdownMenu,
-        triggerId: useId(),
+        triggerId: dist_useId(),
         triggerRef,
-        contentId: useId(),
+        contentId: dist_useId(),
         open,
         onOpenChange: setOpen,
         onOpenToggle: __WEBPACK_EXTERNAL_MODULE_react__.useCallback(()=>setOpen((prevOpen)=>!prevOpen), [
@@ -16025,18 +16469,17 @@ var DropdownMenu = (props)=>{
             children
         })
     });
-};
-DropdownMenu.displayName = DROPDOWN_MENU_NAME;
+}, "DropdownMenu");
 var TRIGGER_NAME = "DropdownMenuTrigger";
-var DropdownMenuTrigger = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var DropdownMenuTrigger = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_dropdown_menu_dist_name(function(props, forwardedRef) {
     const { __scopeDropdownMenu, disabled = false, ...triggerProps } = props;
     const context = useDropdownMenuContext(TRIGGER_NAME, __scopeDropdownMenu);
     const menuScope = useMenuScope(__scopeDropdownMenu);
-    const composedRefs = useComposedRefs(forwardedRef, context.triggerRef);
+    const composedRefs = dist_useComposedRefs(forwardedRef, context.triggerRef);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Anchor2, {
         asChild: true,
         ...menuScope,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.button, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.button, {
             type: "button",
             id: context.triggerId,
             "aria-haspopup": "menu",
@@ -16047,13 +16490,13 @@ var DropdownMenuTrigger = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
             disabled,
             ...triggerProps,
             ref: composedRefs,
-            onPointerDown: composeEventHandlers(props.onPointerDown, (event)=>{
+            onPointerDown: dist_composeEventHandlers(props.onPointerDown, (event)=>{
                 if (!disabled && 0 === event.button && false === event.ctrlKey) {
                     context.onOpenToggle();
                     if (!context.open) event.preventDefault();
                 }
             }),
-            onKeyDown: composeEventHandlers(props.onKeyDown, (event)=>{
+            onKeyDown: dist_composeEventHandlers(props.onKeyDown, (event)=>{
                 if (disabled) return;
                 if ([
                     "Enter",
@@ -16068,20 +16511,17 @@ var DropdownMenuTrigger = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
             })
         })
     });
-});
-DropdownMenuTrigger.displayName = TRIGGER_NAME;
-var react_dropdown_menu_dist_PORTAL_NAME = "DropdownMenuPortal";
-var DropdownMenuPortal = (props)=>{
+}, "DropdownMenuTrigger"));
+var DropdownMenuPortal = /* @__PURE__ */ react_dropdown_menu_dist_name((props)=>{
     const { __scopeDropdownMenu, ...portalProps } = props;
     const menuScope = useMenuScope(__scopeDropdownMenu);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Portal, {
         ...menuScope,
         ...portalProps
     });
-};
-DropdownMenuPortal.displayName = react_dropdown_menu_dist_PORTAL_NAME;
+}, "DropdownMenuPortal");
 var react_dropdown_menu_dist_CONTENT_NAME = "DropdownMenuContent";
-var DropdownMenuContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var DropdownMenuContent = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_dropdown_menu_dist_name(function(props, forwardedRef) {
     const { __scopeDropdownMenu, ...contentProps } = props;
     const context = useDropdownMenuContext(react_dropdown_menu_dist_CONTENT_NAME, __scopeDropdownMenu);
     const menuScope = useMenuScope(__scopeDropdownMenu);
@@ -16092,12 +16532,12 @@ var DropdownMenuContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
         ...menuScope,
         ...contentProps,
         ref: forwardedRef,
-        onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event)=>{
+        onCloseAutoFocus: dist_composeEventHandlers(props.onCloseAutoFocus, (event)=>{
             if (!hasInteractedOutsideRef.current) context.triggerRef.current?.focus();
             hasInteractedOutsideRef.current = false;
             event.preventDefault();
         }),
-        onInteractOutside: composeEventHandlers(props.onInteractOutside, (event)=>{
+        onInteractOutside: dist_composeEventHandlers(props.onInteractOutside, (event)=>{
             const originalEvent = event.detail.originalEvent;
             const ctrlLeftClick = 0 === originalEvent.button && true === originalEvent.ctrlKey;
             const isRightClick = 2 === originalEvent.button || ctrlLeftClick;
@@ -16112,32 +16552,8 @@ var DropdownMenuContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
             "--radix-dropdown-menu-trigger-height": "var(--radix-popper-anchor-height)"
         }
     });
-});
-DropdownMenuContent.displayName = react_dropdown_menu_dist_CONTENT_NAME;
-var react_dropdown_menu_dist_GROUP_NAME = "DropdownMenuGroup";
-var DropdownMenuGroup = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...groupProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Group, {
-        ...menuScope,
-        ...groupProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuGroup.displayName = react_dropdown_menu_dist_GROUP_NAME;
-var dist_LABEL_NAME = "DropdownMenuLabel";
-var DropdownMenuLabel = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...labelProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Label, {
-        ...menuScope,
-        ...labelProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuLabel.displayName = dist_LABEL_NAME;
-var react_dropdown_menu_dist_ITEM_NAME = "DropdownMenuItem";
-var DropdownMenuItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "DropdownMenuContent"));
+var DropdownMenuItem = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_dropdown_menu_dist_name(function(props, forwardedRef) {
     const { __scopeDropdownMenu, ...itemProps } = props;
     const menuScope = useMenuScope(__scopeDropdownMenu);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Item2, {
@@ -16145,54 +16561,8 @@ var DropdownMenuItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forw
         ...itemProps,
         ref: forwardedRef
     });
-});
-DropdownMenuItem.displayName = react_dropdown_menu_dist_ITEM_NAME;
-var dist_CHECKBOX_ITEM_NAME = "DropdownMenuCheckboxItem";
-var DropdownMenuCheckboxItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...checkboxItemProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(CheckboxItem, {
-        ...menuScope,
-        ...checkboxItemProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuCheckboxItem.displayName = dist_CHECKBOX_ITEM_NAME;
-var dist_RADIO_GROUP_NAME = "DropdownMenuRadioGroup";
-var DropdownMenuRadioGroup = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...radioGroupProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(RadioGroup, {
-        ...menuScope,
-        ...radioGroupProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuRadioGroup.displayName = dist_RADIO_GROUP_NAME;
-var dist_RADIO_ITEM_NAME = "DropdownMenuRadioItem";
-var DropdownMenuRadioItem = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...radioItemProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(RadioItem, {
-        ...menuScope,
-        ...radioItemProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuRadioItem.displayName = dist_RADIO_ITEM_NAME;
-var INDICATOR_NAME = "DropdownMenuItemIndicator";
-var DropdownMenuItemIndicator = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...itemIndicatorProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ItemIndicator, {
-        ...menuScope,
-        ...itemIndicatorProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuItemIndicator.displayName = INDICATOR_NAME;
-var dist_SEPARATOR_NAME = "DropdownMenuSeparator";
-var DropdownMenuSeparator = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "DropdownMenuItem"));
+var DropdownMenuSeparator = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_dropdown_menu_dist_name(function(props, forwardedRef) {
     const { __scopeDropdownMenu, ...separatorProps } = props;
     const menuScope = useMenuScope(__scopeDropdownMenu);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Separator, {
@@ -16200,55 +16570,13 @@ var DropdownMenuSeparator = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
         ...separatorProps,
         ref: forwardedRef
     });
-});
-DropdownMenuSeparator.displayName = dist_SEPARATOR_NAME;
-var react_dropdown_menu_dist_ARROW_NAME = "DropdownMenuArrow";
-var DropdownMenuArrow = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...arrowProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Arrow2, {
-        ...menuScope,
-        ...arrowProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuArrow.displayName = react_dropdown_menu_dist_ARROW_NAME;
-var dist_SUB_TRIGGER_NAME = "DropdownMenuSubTrigger";
-var DropdownMenuSubTrigger = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...subTriggerProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(SubTrigger, {
-        ...menuScope,
-        ...subTriggerProps,
-        ref: forwardedRef
-    });
-});
-DropdownMenuSubTrigger.displayName = dist_SUB_TRIGGER_NAME;
-var dist_SUB_CONTENT_NAME = "DropdownMenuSubContent";
-var DropdownMenuSubContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeDropdownMenu, ...subContentProps } = props;
-    const menuScope = useMenuScope(__scopeDropdownMenu);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(SubContent, {
-        ...menuScope,
-        ...subContentProps,
-        ref: forwardedRef,
-        style: {
-            ...props.style,
-            "--radix-dropdown-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
-            "--radix-dropdown-menu-content-available-width": "var(--radix-popper-available-width)",
-            "--radix-dropdown-menu-content-available-height": "var(--radix-popper-available-height)",
-            "--radix-dropdown-menu-trigger-width": "var(--radix-popper-anchor-width)",
-            "--radix-dropdown-menu-trigger-height": "var(--radix-popper-anchor-height)"
-        }
-    });
-});
-DropdownMenuSubContent.displayName = dist_SUB_CONTENT_NAME;
+}, "DropdownMenuSeparator"));
 var dist_Root2 = DropdownMenu;
 var Trigger = DropdownMenuTrigger;
-var Portal2 = DropdownMenuPortal;
+var dist_Portal2 = DropdownMenuPortal;
 var dist_Content2 = DropdownMenuContent;
 var dist_Item2 = DropdownMenuItem;
-var Separator2 = DropdownMenuSeparator;
+var dist_Separator2 = DropdownMenuSeparator;
 const useSafeLayoutEffect = 'undefined' == typeof window ? __WEBPACK_EXTERNAL_MODULE_react__.useEffect : __WEBPACK_EXTERNAL_MODULE_react__.useLayoutEffect;
 const incrementPortalUsers = (container)=>{
     const current = Number.parseInt(container.getAttribute('data-rfkit-charts-portal-users') ?? '0', 10);
@@ -16290,7 +16618,7 @@ dropdown_menu_DropdownMenuTrigger.displayName = Trigger.displayName;
 function dropdown_menu_DropdownMenuPortal({ ...props }) {
     const container = useChartsPortalContainer('dropdown-menu');
     if (!container) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Portal2, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Portal2, {
         "data-slot": "dropdown-menu-portal",
         container: container,
         ...props
@@ -16313,27 +16641,39 @@ const dropdown_menu_DropdownMenuItem = /*#__PURE__*/ __WEBPACK_EXTERNAL_MODULE_r
         ...props
     }));
 dropdown_menu_DropdownMenuItem.displayName = dist_Item2.displayName;
-const dropdown_menu_DropdownMenuSeparator = /*#__PURE__*/ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Separator2, {
+const dropdown_menu_DropdownMenuSeparator = /*#__PURE__*/ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Separator2, {
         ref: ref,
         "data-slot": "dropdown-menu-separator",
         className: cn_cn('my-[calc(var(--size-gap-base)/2)] h-px bg-border/60', className),
         ...props
     }));
-dropdown_menu_DropdownMenuSeparator.displayName = Separator2.displayName;
+dropdown_menu_DropdownMenuSeparator.displayName = dist_Separator2.displayName;
+var number_dist_defProp = Object.defineProperty;
+var number_dist_name = (target, value1)=>number_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 function dist_clamp(value1, [min, max]) {
     return Math.min(max, Math.max(min, value1));
 }
+number_dist_name(dist_clamp, "clamp");
 "use client";
+var react_scroll_area_dist_defProp = Object.defineProperty;
+var react_scroll_area_dist_name = (target, value1)=>react_scroll_area_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 function dist_useStateMachine(initialState, machine) {
     return __WEBPACK_EXTERNAL_MODULE_react__.useReducer((state, event)=>{
         const nextState = machine[state][event];
         return nextState ?? state;
     }, initialState);
 }
+react_scroll_area_dist_name(dist_useStateMachine, "useStateMachine");
 var SCROLL_AREA_NAME = "ScrollArea";
 var [createScrollAreaContext, createScrollAreaScope] = createContextScope(SCROLL_AREA_NAME);
 var [ScrollAreaProvider, useScrollAreaContext] = createScrollAreaContext(SCROLL_AREA_NAME);
-var ScrollArea = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var ScrollArea = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { __scopeScrollArea, type = "hover", dir, scrollHideDelay = 600, ...scrollAreaProps } = props;
     const [scrollArea, setScrollArea] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     const [viewport, setViewport] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
@@ -16344,7 +16684,7 @@ var ScrollArea = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedR
     const [cornerHeight, setCornerHeight] = __WEBPACK_EXTERNAL_MODULE_react__.useState(0);
     const [scrollbarXEnabled, setScrollbarXEnabled] = __WEBPACK_EXTERNAL_MODULE_react__.useState(false);
     const [scrollbarYEnabled, setScrollbarYEnabled] = __WEBPACK_EXTERNAL_MODULE_react__.useState(false);
-    const composedRefs = useComposedRefs(forwardedRef, setScrollArea);
+    const composedRefs = dist_useComposedRefs(forwardedRef, setScrollArea);
     const direction = useDirection(dir);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ScrollAreaProvider, {
         scope: __scopeScrollArea,
@@ -16366,7 +16706,7 @@ var ScrollArea = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedR
         onScrollbarYEnabledChange: setScrollbarYEnabled,
         onCornerWidthChange: setCornerWidth,
         onCornerHeightChange: setCornerHeight,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
             dir: direction,
             ...scrollAreaProps,
             ref: composedRefs,
@@ -16378,20 +16718,19 @@ var ScrollArea = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedR
             }
         })
     });
-});
-ScrollArea.displayName = SCROLL_AREA_NAME;
+}, "ScrollArea"));
 var VIEWPORT_NAME = "ScrollAreaViewport";
-var ScrollAreaViewport = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var ScrollAreaViewport = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { __scopeScrollArea, children, nonce, ...viewportProps } = props;
     const context = useScrollAreaContext(VIEWPORT_NAME, __scopeScrollArea);
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);
+    const composedRefs = dist_useComposedRefs(forwardedRef, ref, context.onViewportChange);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(__WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.Fragment, {
         children: [
             /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ScrollAreaViewportStyle, {
                 nonce
             }),
-            /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+            /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
                 "data-radix-scroll-area-viewport": "",
                 ...viewportProps,
                 ref: composedRefs,
@@ -16411,16 +16750,17 @@ var ScrollAreaViewport = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, fo
             })
         ]
     });
-});
-ScrollAreaViewport.displayName = VIEWPORT_NAME;
-var ScrollAreaViewportStyle = __WEBPACK_EXTERNAL_MODULE_react__.memo(({ nonce })=>/* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("style", {
+}, "ScrollAreaViewport"));
+var ScrollAreaViewportStyle = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.memo(/* @__PURE__ */ react_scroll_area_dist_name(function({ nonce }) {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("style", {
         dangerouslySetInnerHTML: {
             __html: "[data-radix-scroll-area-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-scroll-area-viewport]::-webkit-scrollbar{display:none}"
         },
         nonce
-    }), (prevProps, nextProps)=>prevProps.nonce === nextProps.nonce);
+    });
+}, "ScrollAreaViewportStyle"), (prevProps, nextProps)=>prevProps.nonce === nextProps.nonce);
 var SCROLLBAR_NAME = "ScrollAreaScrollbar";
-var ScrollAreaScrollbar = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var ScrollAreaScrollbar = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { forceMount, ...scrollbarProps } = props;
     const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
     const { onScrollbarXEnabledChange, onScrollbarYEnabledChange } = context;
@@ -16452,9 +16792,8 @@ var ScrollAreaScrollbar = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
         ref: forwardedRef,
         "data-state": "visible"
     }) : null;
-});
-ScrollAreaScrollbar.displayName = SCROLLBAR_NAME;
-var ScrollAreaScrollbarHover = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaScrollbar"));
+var ScrollAreaScrollbarHover = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { forceMount, ...scrollbarProps } = props;
     const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
     const [visible, setVisible] = __WEBPACK_EXTERNAL_MODULE_react__.useState(false);
@@ -16462,13 +16801,13 @@ var ScrollAreaScrollbarHover = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((pro
         const scrollArea = context.scrollArea;
         let hideTimer = 0;
         if (scrollArea) {
-            const handlePointerEnter = ()=>{
+            const handlePointerEnter = /* @__PURE__ */ react_scroll_area_dist_name(()=>{
                 window.clearTimeout(hideTimer);
                 setVisible(true);
-            };
-            const handlePointerLeave = ()=>{
+            }, "handlePointerEnter");
+            const handlePointerLeave = /* @__PURE__ */ react_scroll_area_dist_name(()=>{
                 hideTimer = window.setTimeout(()=>setVisible(false), context.scrollHideDelay);
-            };
+            }, "handlePointerLeave");
             scrollArea.addEventListener("pointerenter", handlePointerEnter);
             scrollArea.addEventListener("pointerleave", handlePointerLeave);
             return ()=>{
@@ -16481,7 +16820,7 @@ var ScrollAreaScrollbarHover = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((pro
         context.scrollArea,
         context.scrollHideDelay
     ]);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
         present: forceMount || visible,
         children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ScrollAreaScrollbarAuto, {
             "data-state": visible ? "visible" : "hidden",
@@ -16489,8 +16828,8 @@ var ScrollAreaScrollbarHover = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((pro
             ref: forwardedRef
         })
     });
-});
-var ScrollAreaScrollbarScroll = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaScrollbarHover"));
+var ScrollAreaScrollbarScroll = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { forceMount, ...scrollbarProps } = props;
     const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
     const isHorizontal = "horizontal" === props.orientation;
@@ -16528,7 +16867,7 @@ var ScrollAreaScrollbarScroll = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((pr
         const scrollDirection = isHorizontal ? "scrollLeft" : "scrollTop";
         if (viewport) {
             let prevScrollPos = viewport[scrollDirection];
-            const handleScroll = ()=>{
+            const handleScroll = /* @__PURE__ */ react_scroll_area_dist_name(()=>{
                 const scrollPos = viewport[scrollDirection];
                 const hasScrollInDirectionChanged = prevScrollPos !== scrollPos;
                 if (hasScrollInDirectionChanged) {
@@ -16536,7 +16875,7 @@ var ScrollAreaScrollbarScroll = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((pr
                     debounceScrollEnd();
                 }
                 prevScrollPos = scrollPos;
-            };
+            }, "handleScroll");
             viewport.addEventListener("scroll", handleScroll);
             return ()=>viewport.removeEventListener("scroll", handleScroll);
         }
@@ -16546,18 +16885,18 @@ var ScrollAreaScrollbarScroll = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((pr
         send,
         debounceScrollEnd
     ]);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
         present: forceMount || "hidden" !== state,
         children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ScrollAreaScrollbarVisible, {
             "data-state": "hidden" === state ? "hidden" : "visible",
             ...scrollbarProps,
             ref: forwardedRef,
-            onPointerEnter: composeEventHandlers(props.onPointerEnter, ()=>send("POINTER_ENTER")),
-            onPointerLeave: composeEventHandlers(props.onPointerLeave, ()=>send("POINTER_LEAVE"))
+            onPointerEnter: dist_composeEventHandlers(props.onPointerEnter, ()=>send("POINTER_ENTER")),
+            onPointerLeave: dist_composeEventHandlers(props.onPointerLeave, ()=>send("POINTER_LEAVE"))
         })
     });
-});
-var ScrollAreaScrollbarAuto = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaScrollbarScroll"));
+var ScrollAreaScrollbarAuto = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
     const { forceMount, ...scrollbarProps } = props;
     const [visible, setVisible] = __WEBPACK_EXTERNAL_MODULE_react__.useState(false);
@@ -16571,7 +16910,7 @@ var ScrollAreaScrollbarAuto = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
     }, 10);
     useResizeObserver(context.viewport, handleResize);
     useResizeObserver(context.content, handleResize);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
         present: forceMount || visible,
         children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ScrollAreaScrollbarVisible, {
             "data-state": visible ? "visible" : "hidden",
@@ -16579,8 +16918,8 @@ var ScrollAreaScrollbarAuto = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
             ref: forwardedRef
         })
     });
-});
-var ScrollAreaScrollbarVisible = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaScrollbarAuto"));
+var ScrollAreaScrollbarVisible = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { orientation = "vertical", ...scrollbarProps } = props;
     const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
     const thumbRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
@@ -16600,13 +16939,14 @@ var ScrollAreaScrollbarVisible = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((p
         sizes,
         onSizesChange: setSizes,
         hasThumb: Boolean(thumbRatio > 0 && thumbRatio < 1),
-        onThumbChange: (thumb)=>thumbRef.current = thumb,
-        onThumbPointerUp: ()=>pointerOffsetRef.current = 0,
-        onThumbPointerDown: (pointerPos)=>pointerOffsetRef.current = pointerPos
+        onThumbChange: /* @__PURE__ */ react_scroll_area_dist_name((thumb)=>thumbRef.current = thumb, "onThumbChange"),
+        onThumbPointerUp: /* @__PURE__ */ react_scroll_area_dist_name(()=>pointerOffsetRef.current = 0, "onThumbPointerUp"),
+        onThumbPointerDown: /* @__PURE__ */ react_scroll_area_dist_name((pointerPos)=>pointerOffsetRef.current = pointerPos, "onThumbPointerDown")
     };
     function getScrollPosition(pointerPos, dir) {
         return getScrollPositionFromPointer(pointerPos, pointerOffsetRef.current, sizes, dir);
     }
+    react_scroll_area_dist_name(getScrollPosition, "getScrollPosition");
     if ("horizontal" === orientation) return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ScrollAreaScrollbarX, {
         ...commonProps,
         ref: forwardedRef,
@@ -16642,13 +16982,13 @@ var ScrollAreaScrollbarVisible = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((p
         }
     });
     return null;
-});
-var ScrollAreaScrollbarX = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaScrollbarVisible"));
+var ScrollAreaScrollbarX = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { sizes, onSizesChange, ...scrollbarProps } = props;
     const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
     const [computedStyle, setComputedStyle] = __WEBPACK_EXTERNAL_MODULE_react__.useState();
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composeRefs = useComposedRefs(forwardedRef, ref, context.onScrollbarXChange);
+    const composeRefs = dist_useComposedRefs(forwardedRef, ref, context.onScrollbarXChange);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (ref.current) setComputedStyle(getComputedStyle(ref.current));
     }, [
@@ -16687,13 +17027,13 @@ var ScrollAreaScrollbarX = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
             });
         }
     });
-});
-var ScrollAreaScrollbarY = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaScrollbarX"));
+var ScrollAreaScrollbarY = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { sizes, onSizesChange, ...scrollbarProps } = props;
     const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
     const [computedStyle, setComputedStyle] = __WEBPACK_EXTERNAL_MODULE_react__.useState();
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composeRefs = useComposedRefs(forwardedRef, ref, context.onScrollbarYChange);
+    const composeRefs = dist_useComposedRefs(forwardedRef, ref, context.onScrollbarYChange);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (ref.current) setComputedStyle(getComputedStyle(ref.current));
     }, [
@@ -16733,19 +17073,19 @@ var ScrollAreaScrollbarY = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
             });
         }
     });
-});
+}, "ScrollAreaScrollbarY"));
 var [ScrollbarProvider, useScrollbarContext] = createScrollAreaContext(SCROLLBAR_NAME);
-var ScrollAreaScrollbarImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var ScrollAreaScrollbarImpl = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { __scopeScrollArea, sizes, hasThumb, onThumbChange, onThumbPointerUp, onThumbPointerDown, onThumbPositionChange, onDragScroll, onWheelScroll, onResize, ...scrollbarProps } = props;
     const context = useScrollAreaContext(SCROLLBAR_NAME, __scopeScrollArea);
     const [scrollbar, setScrollbar] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
-    const composeRefs = useComposedRefs(forwardedRef, setScrollbar);
+    const composeRefs = dist_useComposedRefs(forwardedRef, setScrollbar);
     const rectRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
     const prevWebkitUserSelectRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef("");
     const viewport = context.viewport;
     const maxScrollPos = sizes.content - sizes.viewport;
-    const handleWheelScroll = useCallbackRef(onWheelScroll);
-    const handleThumbPositionChange = useCallbackRef(onThumbPositionChange);
+    const handleWheelScroll = dist_useCallbackRef(onWheelScroll);
+    const handleThumbPositionChange = dist_useCallbackRef(onThumbPositionChange);
     const handleResize = useDebounceCallback(onResize, 10);
     function handleDragScroll(event) {
         if (rectRef.current) {
@@ -16757,12 +17097,13 @@ var ScrollAreaScrollbarImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
             });
         }
     }
+    react_scroll_area_dist_name(handleDragScroll, "handleDragScroll");
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
-        const handleWheel = (event)=>{
+        const handleWheel = /* @__PURE__ */ react_scroll_area_dist_name((event)=>{
             const element = event.target;
             const isScrollbarWheel = scrollbar?.contains(element);
             if (isScrollbarWheel) handleWheelScroll(event, maxScrollPos);
-        };
+        }, "handleWheel");
         document.addEventListener("wheel", handleWheel, {
             passive: false
         });
@@ -16785,18 +17126,18 @@ var ScrollAreaScrollbarImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
         scope: __scopeScrollArea,
         scrollbar,
         hasThumb,
-        onThumbChange: useCallbackRef(onThumbChange),
-        onThumbPointerUp: useCallbackRef(onThumbPointerUp),
+        onThumbChange: dist_useCallbackRef(onThumbChange),
+        onThumbPointerUp: dist_useCallbackRef(onThumbPointerUp),
         onThumbPositionChange: handleThumbPositionChange,
-        onThumbPointerDown: useCallbackRef(onThumbPointerDown),
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+        onThumbPointerDown: dist_useCallbackRef(onThumbPointerDown),
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
             ...scrollbarProps,
             ref: composeRefs,
             style: {
                 position: "absolute",
                 ...scrollbarProps.style
             },
-            onPointerDown: composeEventHandlers(props.onPointerDown, (event)=>{
+            onPointerDown: dist_composeEventHandlers(props.onPointerDown, (event)=>{
                 const mainPointer = 0;
                 if (event.button === mainPointer) {
                     const element = event.target;
@@ -16808,8 +17149,8 @@ var ScrollAreaScrollbarImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
                     handleDragScroll(event);
                 }
             }),
-            onPointerMove: composeEventHandlers(props.onPointerMove, handleDragScroll),
-            onPointerUp: composeEventHandlers(props.onPointerUp, (event)=>{
+            onPointerMove: dist_composeEventHandlers(props.onPointerMove, handleDragScroll),
+            onPointerUp: dist_composeEventHandlers(props.onPointerUp, (event)=>{
                 const element = event.target;
                 if (element.hasPointerCapture(event.pointerId)) element.releasePointerCapture(event.pointerId);
                 document.body.style.webkitUserSelect = prevWebkitUserSelectRef.current;
@@ -16818,25 +17159,25 @@ var ScrollAreaScrollbarImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
             })
         })
     });
-});
+}, "ScrollAreaScrollbarImpl"));
 var THUMB_NAME = "ScrollAreaThumb";
-var ScrollAreaThumb = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var ScrollAreaThumb = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { forceMount, ...thumbProps } = props;
     const scrollbarContext = useScrollbarContext(THUMB_NAME, props.__scopeScrollArea);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
         present: forceMount || scrollbarContext.hasThumb,
         children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ScrollAreaThumbImpl, {
             ref: forwardedRef,
             ...thumbProps
         })
     });
-});
-var ScrollAreaThumbImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaThumb"));
+var ScrollAreaThumbImpl = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { __scopeScrollArea, style, ...thumbProps } = props;
     const scrollAreaContext = useScrollAreaContext(THUMB_NAME, __scopeScrollArea);
     const scrollbarContext = useScrollbarContext(THUMB_NAME, __scopeScrollArea);
     const { onThumbPositionChange } = scrollbarContext;
-    const composedRef = useComposedRefs(forwardedRef, scrollbarContext.onThumbChange);
+    const composedRef = dist_useComposedRefs(forwardedRef, scrollbarContext.onThumbChange);
     const removeUnlinkedScrollListenerRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(void 0);
     const debounceScrollEnd = useDebounceCallback(()=>{
         if (removeUnlinkedScrollListenerRef.current) {
@@ -16847,14 +17188,14 @@ var ScrollAreaThumbImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         const viewport = scrollAreaContext.viewport;
         if (viewport) {
-            const handleScroll = ()=>{
+            const handleScroll = /* @__PURE__ */ react_scroll_area_dist_name(()=>{
                 debounceScrollEnd();
                 if (!removeUnlinkedScrollListenerRef.current) {
                     const listener = addUnlinkedScrollListener(viewport, onThumbPositionChange);
                     removeUnlinkedScrollListenerRef.current = listener;
                     onThumbPositionChange();
                 }
-            };
+            }, "handleScroll");
             onThumbPositionChange();
             viewport.addEventListener("scroll", handleScroll);
             return ()=>viewport.removeEventListener("scroll", handleScroll);
@@ -16864,7 +17205,7 @@ var ScrollAreaThumbImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
         debounceScrollEnd,
         onThumbPositionChange
     ]);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         "data-state": scrollbarContext.hasThumb ? "visible" : "hidden",
         ...thumbProps,
         ref: composedRef,
@@ -16873,7 +17214,7 @@ var ScrollAreaThumbImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
             height: "var(--radix-scroll-area-thumb-height)",
             ...style
         },
-        onPointerDownCapture: composeEventHandlers(props.onPointerDownCapture, (event)=>{
+        onPointerDownCapture: dist_composeEventHandlers(props.onPointerDownCapture, (event)=>{
             const thumb = event.target;
             const thumbRect = thumb.getBoundingClientRect();
             const x = event.clientX - thumbRect.left;
@@ -16883,12 +17224,11 @@ var ScrollAreaThumbImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, f
                 y
             });
         }),
-        onPointerUp: composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)
+        onPointerUp: dist_composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)
     });
-});
-ScrollAreaThumb.displayName = THUMB_NAME;
+}, "ScrollAreaThumbImpl"));
 var CORNER_NAME = "ScrollAreaCorner";
-var ScrollAreaCorner = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var ScrollAreaCorner = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const context = useScrollAreaContext(CORNER_NAME, props.__scopeScrollArea);
     const hasBothScrollbarsVisible = Boolean(context.scrollbarX && context.scrollbarY);
     const hasCorner = "scroll" !== context.type && hasBothScrollbarsVisible;
@@ -16896,9 +17236,8 @@ var ScrollAreaCorner = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forw
         ...props,
         ref: forwardedRef
     }) : null;
-});
-ScrollAreaCorner.displayName = CORNER_NAME;
-var ScrollAreaCornerImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "ScrollAreaCorner"));
+var ScrollAreaCornerImpl = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_scroll_area_dist_name(function(props, forwardedRef) {
     const { __scopeScrollArea, ...cornerProps } = props;
     const context = useScrollAreaContext(CORNER_NAME, __scopeScrollArea);
     const [width, setWidth] = __WEBPACK_EXTERNAL_MODULE_react__.useState(0);
@@ -16922,7 +17261,7 @@ var ScrollAreaCornerImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
         onCornerWidthChange,
         onCornerHeightChange
     ]);
-    return hasSize ? /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return hasSize ? /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         ...cornerProps,
         ref: forwardedRef,
         style: {
@@ -16935,20 +17274,23 @@ var ScrollAreaCornerImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props,
             ...props.style
         }
     }) : null;
-});
+}, "ScrollAreaCornerImpl"));
 function toInt(value1) {
     return value1 ? parseInt(value1, 10) : 0;
 }
+react_scroll_area_dist_name(toInt, "toInt");
 function getThumbRatio(viewportSize, contentSize) {
     const ratio = viewportSize / contentSize;
     return isNaN(ratio) ? 0 : ratio;
 }
+react_scroll_area_dist_name(getThumbRatio, "getThumbRatio");
 function getThumbSize(sizes) {
     const ratio = getThumbRatio(sizes.viewport, sizes.content);
     const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
     const thumbSize = (sizes.scrollbar.size - scrollbarPadding) * ratio;
     return Math.max(thumbSize, 18);
 }
+react_scroll_area_dist_name(getThumbSize, "getThumbSize");
 function getScrollPositionFromPointer(pointerPos, pointerOffset, sizes, dir = "ltr") {
     const thumbSizePx = getThumbSize(sizes);
     const thumbCenter = thumbSizePx / 2;
@@ -16970,6 +17312,7 @@ function getScrollPositionFromPointer(pointerPos, pointerOffset, sizes, dir = "l
     ], scrollRange);
     return interpolate(pointerPos);
 }
+react_scroll_area_dist_name(getScrollPositionFromPointer, "getScrollPositionFromPointer");
 function getThumbOffsetFromScroll(scrollPos, sizes, dir = "ltr") {
     const thumbSizePx = getThumbSize(sizes);
     const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
@@ -16993,6 +17336,7 @@ function getThumbOffsetFromScroll(scrollPos, sizes, dir = "ltr") {
     ]);
     return interpolate(scrollWithoutMomentum);
 }
+react_scroll_area_dist_name(getThumbOffsetFromScroll, "getThumbOffsetFromScroll");
 function linearScale(input, output) {
     return (value1)=>{
         if (input[0] === input[1] || output[0] === output[1]) return output[0];
@@ -17000,30 +17344,18 @@ function linearScale(input, output) {
         return output[0] + ratio * (value1 - input[0]);
     };
 }
+react_scroll_area_dist_name(linearScale, "linearScale");
 function isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos) {
     return scrollPos > 0 && scrollPos < maxScrollPos;
 }
-var addUnlinkedScrollListener = (node, handler = ()=>{})=>{
-    let prevPosition = {
-        left: node.scrollLeft,
-        top: node.scrollTop
-    };
+react_scroll_area_dist_name(isScrollingWithinScrollbarBounds, "isScrollingWithinScrollbarBounds");
+var addUnlinkedScrollListener = /* @__PURE__ */ react_scroll_area_dist_name((node, handler = ()=>{})=>{
+    node.scrollLeft, node.scrollTop;
     let rAF = 0;
-    (function loop() {
-        const position = {
-            left: node.scrollLeft,
-            top: node.scrollTop
-        };
-        const isHorizontalScroll = prevPosition.left !== position.left;
-        const isVerticalScroll = prevPosition.top !== position.top;
-        if (isHorizontalScroll || isVerticalScroll) handler();
-        prevPosition = position;
-        rAF = window.requestAnimationFrame(loop);
-    })();
     return ()=>window.cancelAnimationFrame(rAF);
-};
+}, "addUnlinkedScrollListener");
 function useDebounceCallback(callback, delay) {
-    const handleCallback = useCallbackRef(callback);
+    const handleCallback = dist_useCallbackRef(callback);
     const debounceTimerRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(0);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>()=>window.clearTimeout(debounceTimerRef.current), []);
     return __WEBPACK_EXTERNAL_MODULE_react__.useCallback(()=>{
@@ -17034,8 +17366,9 @@ function useDebounceCallback(callback, delay) {
         delay
     ]);
 }
+react_scroll_area_dist_name(useDebounceCallback, "useDebounceCallback");
 function useResizeObserver(element, onResize) {
-    const handleResize = useCallbackRef(onResize);
+    const handleResize = dist_useCallbackRef(onResize);
     useLayoutEffect2(()=>{
         let rAF = 0;
         if (element) {
@@ -17054,6 +17387,7 @@ function useResizeObserver(element, onResize) {
         handleResize
     ]);
 }
+react_scroll_area_dist_name(useResizeObserver, "useResizeObserver");
 var react_scroll_area_dist_Root = ScrollArea;
 var Viewport = ScrollAreaViewport;
 var Corner = ScrollAreaCorner;
@@ -17098,6 +17432,11 @@ const Mask = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.forwardRef)(({
         ]
     }));
 const components_Mask = /*#__PURE__*/ __WEBPACK_EXTERNAL_MODULE_react__["default"].memo(Mask);
+var react_visually_hidden_dist_defProp = Object.defineProperty;
+var react_visually_hidden_dist_name = (target, value1)=>react_visually_hidden_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var VISUALLY_HIDDEN_STYLES = Object.freeze({
     position: "absolute",
     border: 0,
@@ -17110,18 +17449,23 @@ var VISUALLY_HIDDEN_STYLES = Object.freeze({
     whiteSpace: "nowrap",
     wordWrap: "normal"
 });
-var dist_NAME = "VisuallyHidden";
-var VisuallyHidden = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>/* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.span, {
+var VisuallyHidden = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_visually_hidden_dist_name(function(props, forwardedRef) {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.span, {
         ...props,
         ref: forwardedRef,
         style: {
             ...VISUALLY_HIDDEN_STYLES,
             ...props.style
         }
-    }));
-VisuallyHidden.displayName = dist_NAME;
+    });
+}, "VisuallyHidden"));
 var react_visually_hidden_dist_Root = VisuallyHidden;
 "use client";
+var react_tooltip_dist_defProp = Object.defineProperty;
+var react_tooltip_dist_name = (target, value1)=>react_tooltip_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var [createTooltipContext, createTooltipScope] = createContextScope("Tooltip", [
     createPopperScope
 ]);
@@ -17130,7 +17474,7 @@ var dist_PROVIDER_NAME = "TooltipProvider";
 var DEFAULT_DELAY_DURATION = 700;
 var TOOLTIP_OPEN = "tooltip.open";
 var [TooltipProviderContextProvider, useTooltipProviderContext] = createTooltipContext(dist_PROVIDER_NAME);
-var TooltipProvider = (props)=>{
+var TooltipProvider = /* @__PURE__ */ react_tooltip_dist_name((props)=>{
     const { __scopeTooltip, delayDuration = DEFAULT_DELAY_DURATION, skipDelayDuration = 300, disableHoverableContent = false, children } = props;
     const isOpenDelayedRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(true);
     const isPointerInTransitRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
@@ -17164,16 +17508,16 @@ var TooltipProvider = (props)=>{
         disableHoverableContent,
         children
     });
-};
-TooltipProvider.displayName = dist_PROVIDER_NAME;
+}, "TooltipProvider");
 var TOOLTIP_NAME = "Tooltip";
 var [TooltipContextProvider, useTooltipContext] = createTooltipContext(TOOLTIP_NAME);
-var dist_Tooltip = (props)=>{
+var dist_Tooltip = /* @__PURE__ */ react_tooltip_dist_name((props)=>{
     const { __scopeTooltip, children, open: openProp, defaultOpen, onOpenChange, disableHoverableContent: disableHoverableContentProp, delayDuration: delayDurationProp } = props;
     const providerContext = useTooltipProviderContext(TOOLTIP_NAME, props.__scopeTooltip);
     const popperScope = dist_usePopperScope(__scopeTooltip);
     const [trigger, setTrigger] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
-    const contentId = useId();
+    const [contentIdState, setContentId] = __WEBPACK_EXTERNAL_MODULE_react__.useState(void 0);
+    const generatedContentId = dist_useId();
     const openTimerRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(0);
     const disableHoverableContent = disableHoverableContentProp ?? providerContext.disableHoverableContent;
     const delayDuration = delayDurationProp ?? providerContext.delayDuration;
@@ -17181,13 +17525,13 @@ var dist_Tooltip = (props)=>{
     const [open, setOpen] = dist_useControllableState({
         prop: openProp,
         defaultProp: defaultOpen ?? false,
-        onChange: (open2)=>{
+        onChange: /* @__PURE__ */ react_tooltip_dist_name((open2)=>{
             if (open2) {
                 providerContext.onOpen();
                 document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
             } else providerContext.onClose();
             onOpenChange?.(open2);
-        },
+        }, "onChange"),
         caller: TOOLTIP_NAME
     });
     const stateAttribute = __WEBPACK_EXTERNAL_MODULE_react__.useMemo(()=>open ? wasOpenDelayedRef.current ? "delayed-open" : "instant-open" : "closed", [
@@ -17225,11 +17569,13 @@ var dist_Tooltip = (props)=>{
                 openTimerRef.current = 0;
             }
         }, []);
+    const contentId = contentIdState ?? generatedContentId;
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Root2, {
         ...popperScope,
         children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(TooltipContextProvider, {
             scope: __scopeTooltip,
             contentId,
+            setContentId,
             open,
             stateAttribute,
             trigger,
@@ -17258,16 +17604,15 @@ var dist_Tooltip = (props)=>{
             children
         })
     });
-};
-dist_Tooltip.displayName = TOOLTIP_NAME;
+}, "Tooltip");
 var dist_TRIGGER_NAME = "TooltipTrigger";
-var TooltipTrigger = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var TooltipTrigger = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_tooltip_dist_name(function(props, forwardedRef) {
     const { __scopeTooltip, ...triggerProps } = props;
     const context = useTooltipContext(dist_TRIGGER_NAME, __scopeTooltip);
     const providerContext = useTooltipProviderContext(dist_TRIGGER_NAME, __scopeTooltip);
     const popperScope = dist_usePopperScope(__scopeTooltip);
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref, context.onTriggerChange);
+    const composedRefs = dist_useComposedRefs(forwardedRef, ref, context.onTriggerChange);
     const isPointerDownRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
     const hasPointerMoveOpenedRef = __WEBPACK_EXTERNAL_MODULE_react__.useRef(false);
     const handlePointerUp = __WEBPACK_EXTERNAL_MODULE_react__.useCallback(()=>isPointerDownRef.current = false, []);
@@ -17277,49 +17622,48 @@ var TooltipTrigger = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwar
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Anchor, {
         asChild: true,
         ...popperScope,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.button, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.button, {
             "aria-describedby": context.open ? context.contentId : void 0,
             "data-state": context.stateAttribute,
             ...triggerProps,
             ref: composedRefs,
-            onPointerMove: composeEventHandlers(props.onPointerMove, (event)=>{
+            onPointerMove: dist_composeEventHandlers(props.onPointerMove, (event)=>{
                 if ("touch" === event.pointerType) return;
                 if (!hasPointerMoveOpenedRef.current && !providerContext.isPointerInTransitRef.current) {
                     context.onTriggerEnter();
                     hasPointerMoveOpenedRef.current = true;
                 }
             }),
-            onPointerLeave: composeEventHandlers(props.onPointerLeave, ()=>{
+            onPointerLeave: dist_composeEventHandlers(props.onPointerLeave, ()=>{
                 context.onTriggerLeave();
                 hasPointerMoveOpenedRef.current = false;
             }),
-            onPointerDown: composeEventHandlers(props.onPointerDown, ()=>{
+            onPointerDown: dist_composeEventHandlers(props.onPointerDown, ()=>{
                 if (context.open) context.onClose();
                 isPointerDownRef.current = true;
                 document.addEventListener("pointerup", handlePointerUp, {
                     once: true
                 });
             }),
-            onFocus: composeEventHandlers(props.onFocus, ()=>{
+            onFocus: dist_composeEventHandlers(props.onFocus, ()=>{
                 if (!isPointerDownRef.current) context.onOpen();
             }),
-            onBlur: composeEventHandlers(props.onBlur, context.onClose),
-            onClick: composeEventHandlers(props.onClick, context.onClose)
+            onBlur: dist_composeEventHandlers(props.onBlur, context.onClose),
+            onClick: dist_composeEventHandlers(props.onClick, context.onClose)
         })
     });
-});
-TooltipTrigger.displayName = dist_TRIGGER_NAME;
-var react_tooltip_dist_PORTAL_NAME = "TooltipPortal";
-var [dist_PortalProvider, dist_usePortalContext] = createTooltipContext(react_tooltip_dist_PORTAL_NAME, {
+}, "TooltipTrigger"));
+var dist_PORTAL_NAME = "TooltipPortal";
+var [dist_PortalProvider, dist_usePortalContext] = createTooltipContext(dist_PORTAL_NAME, {
     forceMount: void 0
 });
-var TooltipPortal = (props)=>{
+var TooltipPortal = /* @__PURE__ */ react_tooltip_dist_name((props)=>{
     const { __scopeTooltip, forceMount, children, container } = props;
-    const context = useTooltipContext(react_tooltip_dist_PORTAL_NAME, __scopeTooltip);
+    const context = useTooltipContext(dist_PORTAL_NAME, __scopeTooltip);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_PortalProvider, {
         scope: __scopeTooltip,
         forceMount,
-        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+        children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
             present: forceMount || context.open,
             children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Portal, {
                 asChild: true,
@@ -17328,14 +17672,13 @@ var TooltipPortal = (props)=>{
             })
         })
     });
-};
-TooltipPortal.displayName = react_tooltip_dist_PORTAL_NAME;
+}, "TooltipPortal");
 var react_tooltip_dist_CONTENT_NAME = "TooltipContent";
-var TooltipContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var TooltipContent = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_tooltip_dist_name(function(props, forwardedRef) {
     const portalContext = dist_usePortalContext(react_tooltip_dist_CONTENT_NAME, props.__scopeTooltip);
     const { forceMount = portalContext.forceMount, side = "top", ...contentProps } = props;
     const context = useTooltipContext(react_tooltip_dist_CONTENT_NAME, props.__scopeTooltip);
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Presence, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Presence, {
         present: forceMount || context.open,
         children: context.disableHoverableContent ? /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(TooltipContentImpl, {
             side,
@@ -17347,12 +17690,12 @@ var TooltipContent = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwar
             ref: forwardedRef
         })
     });
-});
-var TooltipContentHoverable = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "TooltipContent"));
+var TooltipContentHoverable = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_tooltip_dist_name(function(props, forwardedRef) {
     const context = useTooltipContext(react_tooltip_dist_CONTENT_NAME, props.__scopeTooltip);
     const providerContext = useTooltipProviderContext(react_tooltip_dist_CONTENT_NAME, props.__scopeTooltip);
     const ref = __WEBPACK_EXTERNAL_MODULE_react__.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
+    const composedRefs = dist_useComposedRefs(forwardedRef, ref);
     const [pointerGraceArea, setPointerGraceArea] = __WEBPACK_EXTERNAL_MODULE_react__.useState(null);
     const { trigger, onClose } = context;
     const content = ref.current;
@@ -17386,8 +17729,8 @@ var TooltipContentHoverable = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
     ]);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (trigger && content) {
-            const handleTriggerLeave = (event)=>handleCreateGraceArea(event, content);
-            const handleContentLeave = (event)=>handleCreateGraceArea(event, trigger);
+            const handleTriggerLeave = /* @__PURE__ */ react_tooltip_dist_name((event)=>handleCreateGraceArea(event, content), "handleTriggerLeave");
+            const handleContentLeave = /* @__PURE__ */ react_tooltip_dist_name((event)=>handleCreateGraceArea(event, trigger), "handleContentLeave");
             trigger.addEventListener("pointerleave", handleTriggerLeave);
             content.addEventListener("pointerleave", handleContentLeave);
             return ()=>{
@@ -17403,7 +17746,7 @@ var TooltipContentHoverable = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
     ]);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (pointerGraceArea) {
-            const handleTrackPointerGrace = (event)=>{
+            const handleTrackPointerGrace = /* @__PURE__ */ react_tooltip_dist_name((event)=>{
                 const target = event.target;
                 const pointerPosition = {
                     x: event.clientX,
@@ -17416,7 +17759,7 @@ var TooltipContentHoverable = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
                     handleRemoveGraceArea();
                     onClose();
                 }
-            };
+            }, "handleTrackPointerGrace");
             document.addEventListener("pointermove", handleTrackPointerGrace);
             return ()=>document.removeEventListener("pointermove", handleTrackPointerGrace);
         }
@@ -17431,13 +17774,10 @@ var TooltipContentHoverable = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((prop
         ...props,
         ref: composedRefs
     });
-});
-var [VisuallyHiddenContentContextProvider, useVisuallyHiddenContentContext] = createTooltipContext(TOOLTIP_NAME, {
-    isInside: false
-});
+}, "TooltipContentHoverable"));
 var dist_Slottable = createSlottable("TooltipContent");
-var TooltipContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
-    const { __scopeTooltip, children, "aria-label": ariaLabel, onEscapeKeyDown, onPointerDownOutside, ...contentProps } = props;
+var TooltipContentImpl = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_tooltip_dist_name(function(props, forwardedRef) {
+    const { __scopeTooltip, children, "aria-label": ariaLabel, id: idProp, onEscapeKeyDown, onPointerDownOutside, ...contentProps } = props;
     const context = useTooltipContext(react_tooltip_dist_CONTENT_NAME, __scopeTooltip);
     const popperScope = dist_usePopperScope(__scopeTooltip);
     const { onClose } = context;
@@ -17449,9 +17789,9 @@ var TooltipContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, fo
     ]);
     __WEBPACK_EXTERNAL_MODULE_react__.useEffect(()=>{
         if (context.trigger) {
-            const handleScroll = (event)=>{
+            const handleScroll = /* @__PURE__ */ react_tooltip_dist_name((event)=>{
                 if (event.target instanceof Node && event.target.contains(context.trigger)) onClose();
-            };
+            }, "handleScroll");
             window.addEventListener("scroll", handleScroll, {
                 capture: true
             });
@@ -17463,6 +17803,16 @@ var TooltipContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, fo
         context.trigger,
         onClose
     ]);
+    const { setContentId } = context;
+    useLayoutEffect2(()=>{
+        setContentId(idProp);
+        return ()=>{
+            setContentId(void 0);
+        };
+    }, [
+        idProp,
+        setContentId
+    ]);
     return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(DismissableLayer, {
         asChild: true,
         disableOutsidePointerEvents: false,
@@ -17472,6 +17822,8 @@ var TooltipContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, fo
         onDismiss: onClose,
         children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(Content, {
             "data-state": context.stateAttribute,
+            role: ariaLabel ? void 0 : "tooltip",
+            id: ariaLabel ? void 0 : context.contentId,
             ...popperScope,
             ...contentProps,
             ref: forwardedRef,
@@ -17487,32 +17839,24 @@ var TooltipContentImpl = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, fo
                 /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Slottable, {
                     children
                 }),
-                /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(VisuallyHiddenContentContextProvider, {
-                    scope: __scopeTooltip,
-                    isInside: true,
-                    children: /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(react_visually_hidden_dist_Root, {
-                        id: context.contentId,
-                        role: "tooltip",
-                        children: ariaLabel || children
-                    })
-                })
+                ariaLabel ? /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(react_visually_hidden_dist_Root, {
+                    id: context.contentId,
+                    role: "tooltip",
+                    children: ariaLabel
+                }) : null
             ]
         })
     });
-});
-TooltipContent.displayName = react_tooltip_dist_CONTENT_NAME;
-var react_tooltip_dist_ARROW_NAME = "TooltipArrow";
-var TooltipArrow = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+}, "TooltipContentImpl"));
+var TooltipArrow = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_tooltip_dist_name(function(props, forwardedRef) {
     const { __scopeTooltip, ...arrowProps } = props;
     const popperScope = dist_usePopperScope(__scopeTooltip);
-    const visuallyHiddenContentContext = useVisuallyHiddenContentContext(react_tooltip_dist_ARROW_NAME, __scopeTooltip);
-    return visuallyHiddenContentContext.isInside ? null : /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Arrow, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Arrow, {
         ...popperScope,
         ...arrowProps,
         ref: forwardedRef
     });
-});
-TooltipArrow.displayName = react_tooltip_dist_ARROW_NAME;
+}, "TooltipArrow"));
 function getExitSideFromRect(point, rect) {
     const top = Math.abs(rect.top - point.y);
     const bottom = Math.abs(rect.bottom - point.y);
@@ -17531,6 +17875,7 @@ function getExitSideFromRect(point, rect) {
             throw new Error("unreachable");
     }
 }
+react_tooltip_dist_name(getExitSideFromRect, "getExitSideFromRect");
 function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
     const paddedExitPoints = [];
     switch(exitSide){
@@ -17573,6 +17918,7 @@ function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
     }
     return paddedExitPoints;
 }
+react_tooltip_dist_name(getPaddedExitPoints, "getPaddedExitPoints");
 function getPointsFromRect(rect) {
     const { top, right, bottom, left } = rect;
     return [
@@ -17594,6 +17940,7 @@ function getPointsFromRect(rect) {
         }
     ];
 }
+react_tooltip_dist_name(getPointsFromRect, "getPointsFromRect");
 function dist_isPointInPolygon(point, polygon) {
     const { x, y } = point;
     let inside = false;
@@ -17609,6 +17956,7 @@ function dist_isPointInPolygon(point, polygon) {
     }
     return inside;
 }
+react_tooltip_dist_name(dist_isPointInPolygon, "isPointInPolygon");
 function getHull(points) {
     const newPoints = points.slice();
     newPoints.sort((a, b)=>{
@@ -17620,6 +17968,7 @@ function getHull(points) {
     });
     return getHullPresorted(newPoints);
 }
+react_tooltip_dist_name(getHull, "getHull");
 function getHullPresorted(points) {
     if (points.length <= 1) return points.slice();
     const upperHull = [];
@@ -17649,6 +17998,7 @@ function getHullPresorted(points) {
     if (1 === upperHull.length && 1 === lowerHull.length && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) return upperHull;
     return upperHull.concat(lowerHull);
 }
+react_tooltip_dist_name(getHullPresorted, "getHullPresorted");
 var react_tooltip_dist_Provider = TooltipProvider;
 var dist_Root3 = dist_Tooltip;
 var dist_Trigger = TooltipTrigger;
@@ -17764,7 +18114,7 @@ const Tooltip_Tooltip = ({ children, content, delay = 200, duration = 3000, offs
     });
 };
 const Overlay_Tooltip = Tooltip_Tooltip;
-const Dropdown = ({ value: value1, options, onChange, placeholder = "\u8BF7\u9009\u62E9", triggerContent, triggerTitle, closeOnSelect = true, triggerVariant = 'default', showChevron = true, triggerClassName, contentClassName })=>{
+const Dropdown_Dropdown = ({ value: value1, options, onChange, placeholder = "\u8BF7\u9009\u62E9", triggerContent, triggerTitle, closeOnSelect = true, triggerVariant = 'default', showChevron = true, triggerClassName, contentClassName })=>{
     const [open, setOpen] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(false);
     const handleSelect = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((option)=>{
         const nextValue = option.value ?? null;
@@ -17839,7 +18189,7 @@ const Dropdown = ({ value: value1, options, onChange, placeholder = "\u8BF7\u900
         ]
     });
 };
-const Overlay_Dropdown = Dropdown;
+const Dropdown = Dropdown_Dropdown;
 const DEFAULT_SAMPLE_INTERVAL_MS = 80;
 const DEFAULT_SAMPLE_IDLE_DELAY_MS = 80;
 const toCursorEventSnapshot = (snapshot)=>({
@@ -18297,13 +18647,17 @@ const ToolbarGlyph_ToolbarGlyph = ({ children, className, opticalOffsetX = 0, op
     });
 };
 const ToolbarGlyph = ToolbarGlyph_ToolbarGlyph;
-var react_separator_dist_NAME = "Separator";
+var react_separator_dist_defProp = Object.defineProperty;
+var react_separator_dist_name = (target, value1)=>react_separator_dist_defProp(target, "name", {
+        value: value1,
+        configurable: true
+    });
 var DEFAULT_ORIENTATION = "horizontal";
 var ORIENTATIONS = [
     "horizontal",
     "vertical"
 ];
-var dist_Separator = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwardedRef)=>{
+var dist_Separator = /* @__PURE__ */ __WEBPACK_EXTERNAL_MODULE_react__.forwardRef(/* @__PURE__ */ react_separator_dist_name(function(props, forwardedRef) {
     const { decorative, orientation: orientationProp = DEFAULT_ORIENTATION, ...domProps } = props;
     const orientation = isValidOrientation(orientationProp) ? orientationProp : DEFAULT_ORIENTATION;
     const ariaOrientation = "vertical" === orientation ? orientation : void 0;
@@ -18313,17 +18667,17 @@ var dist_Separator = __WEBPACK_EXTERNAL_MODULE_react__.forwardRef((props, forwar
         "aria-orientation": ariaOrientation,
         role: "separator"
     };
-    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Primitive.div, {
+    return /* @__PURE__ */ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(dist_Primitive.div, {
         "data-orientation": orientation,
         ...semanticProps,
         ...domProps,
         ref: forwardedRef
     });
-});
-dist_Separator.displayName = react_separator_dist_NAME;
+}, "Separator"));
 function isValidOrientation(orientation) {
     return ORIENTATIONS.includes(orientation);
 }
+react_separator_dist_name(isValidOrientation, "isValidOrientation");
 var react_separator_dist_Root = dist_Separator;
 function separator_Separator({ className, orientation = 'horizontal', decorative = true, ...props }) {
     return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(react_separator_dist_Root, {
@@ -18343,7 +18697,7 @@ const ToolbarGroupSeparator = ({ className })=>/*#__PURE__*/ (0, __WEBPACK_EXTER
         className: cn_cn(TOOLBAR_GROUP_SEPARATOR_CLASS_NAME, className),
         orientation: "vertical"
     });
-const ToolbarDropdown = (props)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Overlay_Dropdown, {
+const ToolbarDropdown = (props)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Dropdown, {
         ...props,
         triggerVariant: "default",
         contentClassName: cn_cn(TOOLBAR_DROPDOWN_CONTENT_CLASS_NAME, props.contentClassName)
@@ -18355,7 +18709,7 @@ const ToolbarIconDropdown = ({ icon, title, triggerClassName, ...props })=>{
             children: icon
         })
     });
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Overlay_Dropdown, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Dropdown, {
         ...props,
         triggerVariant: "default",
         triggerTitle: title,
@@ -18367,7 +18721,7 @@ const ToolbarIconDropdown = ({ icon, title, triggerClassName, ...props })=>{
 const ToolbarDropdownGroup = ({ leading, triggerClassName, ...props })=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(ToolbarGroup, {
         children: [
             leading,
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Overlay_Dropdown, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Dropdown, {
                 ...props,
                 triggerVariant: "plain",
                 contentClassName: cn_cn(TOOLBAR_DROPDOWN_CONTENT_CLASS_NAME, props.contentClassName),
@@ -19567,20 +19921,52 @@ class SpectrumAnalyzer {
         });
         this.setPendingFlag("occupancy", false);
     }
-    setExtraData(data, mode = types_ExtraDataMode.MERGE) {
-        if (mode === types_ExtraDataMode.CLEAR || mode === types_ExtraDataMode.REPLACE) {
+    setExtraData(data, mode = types_ExtraDataMode.MERGE, options) {
+        if (mode === types_ExtraDataMode.CLEAR) {
             this.extraData = {};
             this.extraOutputData = {};
             this.setPendingFlag("extra", false);
+            return;
         }
-        if (mode === types_ExtraDataMode.CLEAR) return;
-        if (!data) return;
-        for (const [key, value1] of Object.entries(data)){
-            if (!value1 || 0 === value1.length) {
+        if (!data) {
+            if (mode === types_ExtraDataMode.REPLACE) {
+                this.extraData = {};
+                this.extraOutputData = {};
+                this.setPendingFlag("extra", false);
+            }
+            return;
+        }
+        const entries = Object.entries(data).map(([key, value1])=>[
+                key,
+                value1?.length ? new Float32Array(value1) : null
+            ]);
+        const index = options ? this.resolveGlobalIndex(options.segmentOffset ?? 0, options.offset ?? 0) : 0;
+        if (options) {
+            for (const [, value1] of entries)if (value1) this.validateInput(value1, index);
+        }
+        if (mode === types_ExtraDataMode.REPLACE) {
+            this.extraData = {};
+            this.extraOutputData = {};
+            this.setPendingFlag("extra", false);
+        }
+        for (const [key, value1] of entries){
+            if (!value1) {
                 delete this.extraData[key];
                 continue;
             }
-            this.extraData[key] = new Float32Array(value1);
+            if (!options) {
+                this.extraData[key] = value1;
+                continue;
+            }
+            let target = this.extraData[key];
+            if (target?.length !== this.config.maxPoints) {
+                const next = new Float32Array(this.config.maxPoints);
+                next.fill(SPECTRUM.INITIAL_VALUE);
+                if (target?.length) next.set(target.subarray(0, this.config.maxPoints));
+                target = next;
+                this.extraData[key] = target;
+            }
+            target.set(value1, index);
         }
         if (!this.hasProcessedData || this.isProcessing) return void this.setPendingFlag("extra", true);
         this.extraOutputData = resampleExtraData(this.extraData, this.antennaFactorData, this.antennaFactorSwitch, this.srcIndexCache, this.getOutputData.bind(this));
@@ -20523,7 +20909,7 @@ const RulerTicks_RulerTicks = ({ length = 10, tickColor = 'var(--chart-grid-stro
     });
 };
 const components_RulerTicks = RulerTicks_RulerTicks;
-const ZoomViewportLayer_ZoomViewportLayer = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.forwardRef)(({ children, className, style: customStyle }, ref)=>{
+const ZoomViewportLayer = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.forwardRef)(({ children, className, style: customStyle }, ref)=>{
     const { state: { zoom: { style: zoomStyle } } } = useStore_useStore();
     return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
         ref: ref,
@@ -20536,7 +20922,7 @@ const ZoomViewportLayer_ZoomViewportLayer = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL
         })
     });
 });
-const ZoomViewportLayer = ZoomViewportLayer_ZoomViewportLayer;
+const Zoom_ZoomViewportLayer = ZoomViewportLayer;
 const AXIS_X_TICKS_LAYER_CLASS_NAME = 'absolute right-0 top-0 flex h-full w-full items-center justify-between text-xs opacity-50';
 const AXIS_X_TICKS_SHELL_CLASS_NAME = 'relative h-6 w-full select-none overflow-hidden text-xs leading-6';
 const MSCAN_SEGMENT_CLASS_NAME = 'flex flex-1 items-center justify-center';
@@ -20683,13 +21069,13 @@ const AxisXTicks = ({ type })=>{
         className: AXIS_X_TICKS_SHELL_CLASS_NAME,
         children: type === constants_ChartType.Scan || type === constants_ChartType.ScanDF360 || type === constants_ChartType.Heatmap ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(DataNFixedTicks, {
             type: type
-        }) : type === constants_ChartType.MScan ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+        }) : type === constants_ChartType.MScan ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
             children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(MScanTicks, {})
         }) : /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ThreeFixedTicks, {})
     });
 };
 const Ticks = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.memo)(AxisXTicks);
-const AxisX = ({ type })=>{
+const AxisX_AxisX = ({ type })=>{
     const { state: { axisX } } = useStore_useStore();
     const { children, unit, ticks } = axisX;
     const { width, pluginBoxWidth } = useAxisYWidth_useAxisYWidth();
@@ -20727,7 +21113,7 @@ const AxisX = ({ type })=>{
         })
     });
 };
-const components_AxisX = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.memo)(AxisX);
+const AxisX = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.memo)(AxisX_AxisX);
 const FlexBox = (props)=>{
     const { children, className, style } = props;
     return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
@@ -23244,7 +23630,7 @@ const Cursor = ({ id, type })=>{
         type
     ]);
     if (!show || !isEnabled || !active) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(Zoom_ZoomViewportLayer, {
         className: "z-[6]",
         children: [
             /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
@@ -23470,7 +23856,7 @@ const EventBus_EventBus = ({ id })=>{
     }, [
         handleMouseLeave
     ]);
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         className: "z-[5] pointer-events-auto",
         children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("button", {
             ref: containerRef,
@@ -23494,14 +23880,14 @@ const EventBus_EventBus = ({ id })=>{
     });
 };
 const EventBus = EventBus_EventBus;
-const Boundary_Boundary = ()=>{
+const Boundary = ()=>{
     const { state: { gridLines } } = useStore_useStore();
     return gridLines && /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
         className: "pointer-events-none absolute right-0 top-0 z-[1] flex h-full w-full select-none flex-col border [border-color:var(--chart-grid)] bg-transparent"
     });
 };
-const Boundary = Boundary_Boundary;
-const PluginBox_PluginBox = (props)=>{
+const GridLines_Boundary = Boundary;
+const PluginBox = (props)=>{
     const { children, onWheelCapture } = props;
     const { pluginBoxWidth } = useAxisYWidth_useAxisYWidth();
     return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
@@ -23513,7 +23899,7 @@ const PluginBox_PluginBox = (props)=>{
         children: children
     });
 };
-const PluginBox = /*#__PURE__*/ __WEBPACK_EXTERNAL_MODULE_react__["default"].memo(PluginBox_PluginBox);
+const components_PluginBox = /*#__PURE__*/ __WEBPACK_EXTERNAL_MODULE_react__["default"].memo(PluginBox);
 const PRECISION = 1e4;
 const defaultAreaInfoResult = {
     startIndex: 0,
@@ -23711,7 +24097,7 @@ const Area_Area = (props)=>{
                     })
                 })
             }),
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
                 children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
                     style: {
                         left: `${areaStyle?.left}%`,
@@ -24692,7 +25078,7 @@ const DragSelectBox = ({ enabled, defaultRect, minSize = 0, minWidth, minHeight,
         handleMouseDown(event, type, startRect);
     };
     if (!enabled) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(Zoom_ZoomViewportLayer, {
         className: cn_cn('left-0 top-0 h-full w-full overflow-hidden', className),
         ref: containerRef,
         style: {
@@ -25454,10 +25840,10 @@ const Heatmap_Heatmap = (props)=>{
                 id: id,
                 chart: chart
             }),
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(PluginBox, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(components_PluginBox, {
                 onWheelCapture: xyZoom ? handleXYWheelCapture : void 0,
                 children: [
-                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Boundary, {}),
+                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(GridLines_Boundary, {}),
                     /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Chart, {}),
                     /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(EventBus, {
                         id: id
@@ -26142,7 +26528,7 @@ const Heatmap_Chart_Chart = ({ publish, heatmapDefaultData })=>{
                     xyZoom: xyZoomEnabled
                 })
             }),
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_AxisX, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(AxisX, {
                 type: constants_ChartType.Heatmap
             })
         ]
@@ -26641,7 +27027,7 @@ const IQChart = (props)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_r
 const IQ_IQ = withChartPublisher(IQChart, 'IQ');
 const IQ = IQ_IQ;
 const Reset_modes = Object.values(constants_ModuleType);
-const Reset_Reset = ()=>{
+const Reset = ()=>{
     const { state: { globalID, publish } } = useStore_useStore();
     const handleReset = ()=>{
         publish?.({
@@ -26668,7 +27054,7 @@ const Reset_Reset = ()=>{
         })
     });
 };
-const Reset = Reset_Reset;
+const controls_Reset = Reset;
 const SegmentsDisplayControl_SegmentsDisplayControl = ()=>{
     const { state: { segments, globalID } } = useStore_useStore();
     const [display, setDisplay] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)([]);
@@ -27896,7 +28282,7 @@ const TOOLBAR_ITEM_CONFIGS = [
         ]
     },
     {
-        component: Reset,
+        component: controls_Reset,
         toolType: constants_ToolbarItemType.Reset,
         supportedCharts: [],
         excludedCharts: [
@@ -28956,7 +29342,7 @@ const DragFrame = ({ id })=>{
         id
     ]);
     if (!zoom.show) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         className: "z-[3]",
         children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
             className: "absolute left-[-100%] top-0 h-full w-0 box-border border-2 border-dashed border-chart-grid-strong bg-chart-surface opacity-40",
@@ -30106,7 +30492,7 @@ const FrequencyTagLine_FrequencyTagLine = (props)=>{
         show
     ]);
     if (!show || !display) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         className: "z-[3]",
         children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
             className: "relative flex h-full w-px border-l border-dashed border-chart-highlight/80 opacity-80",
@@ -30337,7 +30723,7 @@ const Limit_Limit = ({ id })=>{
         system.height
     ]);
     if (!show) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         className: "z-[2]",
         children: segments?.map((i, index)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
                 style: {
@@ -31723,7 +32109,7 @@ const Markers = ({ id })=>{
         resetMarkers
     ]);
     if (!show) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         className: "z-[5]",
         children: markers.map((marker)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Markers_MarkerItem, {
                 marker: marker
@@ -31779,7 +32165,7 @@ function useScope_useScope() {
 const Scope = ()=>{
     const { state: { scope: { show, left, width } } } = useStore_useStore();
     if (!show) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
             className: "relative flex h-full w-0 box-border border-y border-dashed border-chart-grid bg-chart-surface opacity-50",
             style: {
@@ -32072,7 +32458,7 @@ const Stripe_Stripe = ({ id })=>{
         change
     ]);
     if (!show || left - right === 0 || !display) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         className: "z-[3]",
         children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
             className: "relative flex h-full w-px box-border border-x-2 border-dashed border-y-0 border-chart-grid-strong bg-chart-surface opacity-40",
@@ -32138,7 +32524,7 @@ const BandLayer_BandLayer = ()=>{
         segments
     ]);
     if (!positions.length) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         children: positions.map((position)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
                 "data-testid": "spectrum-band",
                 "data-band-kind": band.kind,
@@ -32210,7 +32596,7 @@ const Spectrum_Spectrum = (props)=>{
             /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(AxisYCanvas, {
                 chart: chart
             }),
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(PluginBox, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(components_PluginBox, {
                 children: [
                     /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_GridLines, {}),
                     /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Chart, {}),
@@ -32286,7 +32672,7 @@ const LevelStream_Chart_Chart = (props)=>{
             }),
             /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_FlexBox, {
                 children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(modules_Spectrum, {
-                    children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(PluginBox, {
+                    children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_PluginBox, {
                         children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Level, {
                             opacity: 0.5
                         })
@@ -32364,7 +32750,7 @@ const occupancy = AxisYOccupancy;
 const OccupancyDashed_Dashed = ()=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
         className: "h-0 w-full flex-1 border-t [border-color:var(--chart-grid)] first:border-t-0"
     });
-const OccupancyDashed = ()=>{
+const OccupancyDashed_OccupancyDashed = ()=>{
     const { state: { gridLines } } = useStore_useStore();
     return gridLines && /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)("div", {
         className: "pointer-events-none absolute right-0 top-0 z-[1] flex h-full w-full select-none flex-col border [border-color:var(--chart-grid)] bg-transparent",
@@ -32376,7 +32762,7 @@ const OccupancyDashed = ()=>{
         ]
     });
 };
-const GridLines_OccupancyDashed = OccupancyDashed;
+const OccupancyDashed = OccupancyDashed_OccupancyDashed;
 const TOTAL_LINE_HIDDEN_OFFSET = -200;
 const getOccupancyTotalLineRuntimeId = (id)=>`occupancy-total-line-${id}`;
 const applyOccupancyTotalLineValue = (lineElement, valueElement, value1 = 0)=>{
@@ -32470,9 +32856,9 @@ const Occupancy_Occupancy = (props)=>{
             /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(occupancy, {
                 disabled: occupancyAxisYDisabled
             }),
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(PluginBox, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(components_PluginBox, {
                 children: [
-                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(GridLines_OccupancyDashed, {}),
+                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(OccupancyDashed, {}),
                     /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Chart, {}),
                     /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(EventBus, {
                         id: id
@@ -32518,7 +32904,7 @@ const Occupancy_Chart_Chart = (props)=>{
             /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_FlexBox, {
                 children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(modules_Occupancy, {})
             }),
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_AxisX, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(AxisX, {
                 type: constants_ChartType.Scan
             })
         ]
@@ -32690,7 +33076,7 @@ const HeatmapPortal_Chart = (props)=>{
                     type: constants_ChartType.Heatmap
                 }),
                 /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(modules_Heatmap, {}),
-                /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_AxisX, {
+                /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(AxisX, {
                     type: type
                 })
             ]
@@ -32713,7 +33099,7 @@ const OccupancyPortal_Chart = (props)=>{
                             type: constants_ChartType.Occupancy
                         }),
                         /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(modules_Occupancy, {}),
-                        /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_AxisX, {
+                        /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(AxisX, {
                             type: type
                         })
                     ]
@@ -32752,7 +33138,7 @@ const Blaze = ()=>{
         globalID
     ]);
     if (!show) return null;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)("div", {
             className: "absolute left-[-100%] top-0 flex h-full w-0 opacity-50",
             style: {
@@ -32787,7 +33173,7 @@ const Spectrum_Legend = Legend;
 const SegmentsZebra = ()=>{
     const { state: { segments } } = useStore_useStore();
     const totalPoints = segments.totalPoints ?? 0;
-    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(ZoomViewportLayer, {
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom_ZoomViewportLayer, {
         className: "z-[0]",
         children: segments.map((i, key)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
                 className: "h-full border-x",
@@ -33017,7 +33403,10 @@ function useSpectrumAnalyzer(props) {
                 if (e.avgData) analyzer.current.setAvgData(e.avgData);
                 if (e.templateData) analyzer.current.setTemplateData(e.templateData, e.templateTolerance);
                 if (e.backgroundNoiseData) analyzer.current.setBackgroundNoiseData(e.backgroundNoiseData);
-                if (e.extraData) analyzer.current?.setExtraData(e.extraData);
+                if (e.extraData) analyzer.current.setExtraData(e.extraData, types_ExtraDataMode.MERGE, e.segmentedExtraData ? {
+                    segmentOffset: e.segmentOffset,
+                    offset: e.offset
+                } : void 0);
                 break;
             case constants_PSType.Fluorescence:
                 if (e.data && analyzer.current) analyzer.current.setFluorescenceData(e.data.fluorescenceData, e.data.fluorescenceMaxCount);
@@ -33146,7 +33535,7 @@ const Spectrum_Chart_Chart = (props)=>{
                         occupancyElementID: occupancyElementID,
                         occupancyAxisYElementID: occupancyAxisYElementID
                     }),
-                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(PluginBox, {
+                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(components_PluginBox, {
                         children: [
                             /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Zoom, {}),
                             type === constants_ChartType.Scan && /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(__WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.Fragment, {
@@ -33160,7 +33549,7 @@ const Spectrum_Chart_Chart = (props)=>{
                     })
                 ]
             }),
-            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(components_AxisX, {
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(AxisX, {
                 type: type
             })
         ]