ivt/dist/chunks/menubar-JE1m8rYJ.mjs

Ivt Components Library

import * as React from 'react';
import { createCollection } from '@radix-ui/react-collection';
import { u as useDirection } from './index-CGLjQEjG.mjs';
import { c as composeEventHandlers } from './index-Bl-WJHvp.mjs';
import { u as useComposedRefs } from './index-1tQVI0Jh.mjs';
import { c as createContextScope } from './index-DT8WgpCS.mjs';
import { u as useId } from './index-tkRL9Tft.mjs';
import { c as createMenuScope, P as Portal, R as Root3$1, A as Anchor2, C as Content2$1, G as Group, S as Separator, L as Label, I as Item2, a as CheckboxItem, b as ItemIndicator, h as RadioGroup, d as RadioItem, e as Sub, g as SubTrigger, f as SubContent, i as Arrow2, j as Circle } from './index-DWmrjIYv.mjs';
import { c as createRovingFocusGroupScope, R as Root, I as Item } from './index-BsG_UW8k.mjs';
import { P as Primitive } from './index-DgKlJYZP.mjs';
import { u as useControllableState } from './index-D4FMFHi9.mjs';
import { jsx } from 'react/jsx-runtime';
import { c as cn } from './utils-05LlW3Cl.mjs';
import { C as Check } from './check-BBGTedl-.mjs';
import { C as ChevronRight } from './chevron-right-mC6NR8jW.mjs';

var MENUBAR_NAME = "Menubar";
var [Collection, useCollection, createCollectionScope] = createCollection(MENUBAR_NAME);
var [createMenubarContext] = createContextScope(MENUBAR_NAME, [
    createCollectionScope,
    createRovingFocusGroupScope
]);
var useMenuScope = createMenuScope();
var useRovingFocusGroupScope = createRovingFocusGroupScope();
var [MenubarContextProvider, useMenubarContext] = createMenubarContext(MENUBAR_NAME);
var Menubar$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, value: valueProp, onValueChange, defaultValue, loop = true, dir, ...menubarProps } = props;
    const direction = useDirection(dir);
    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenubar);
    const [value, setValue] = useControllableState({
        prop: valueProp,
        onChange: onValueChange,
        defaultProp: defaultValue ?? "",
        caller: MENUBAR_NAME
    });
    const [currentTabStopId, setCurrentTabStopId] = React.useState(null);
    return /* @__PURE__ */ jsx(MenubarContextProvider, {
        scope: __scopeMenubar,
        value,
        onMenuOpen: React.useCallback((value2)=>{
            setValue(value2);
            setCurrentTabStopId(value2);
        }, [
            setValue
        ]),
        onMenuClose: React.useCallback(()=>setValue(""), [
            setValue
        ]),
        onMenuToggle: React.useCallback((value2)=>{
            setValue((prevValue)=>prevValue ? "" : value2);
            setCurrentTabStopId(value2);
        }, [
            setValue
        ]),
        dir: direction,
        loop,
        children: /* @__PURE__ */ jsx(Collection.Provider, {
            scope: __scopeMenubar,
            children: /* @__PURE__ */ jsx(Collection.Slot, {
                scope: __scopeMenubar,
                children: /* @__PURE__ */ jsx(Root, {
                    asChild: true,
                    ...rovingFocusGroupScope,
                    orientation: "horizontal",
                    loop,
                    dir: direction,
                    currentTabStopId,
                    onCurrentTabStopIdChange: setCurrentTabStopId,
                    children: /* @__PURE__ */ jsx(Primitive.div, {
                        role: "menubar",
                        ...menubarProps,
                        ref: forwardedRef
                    })
                })
            })
        })
    });
});
Menubar$1.displayName = MENUBAR_NAME;
var MENU_NAME = "MenubarMenu";
var [MenubarMenuProvider, useMenubarMenuContext] = createMenubarContext(MENU_NAME);
var MenubarMenu$1 = (props)=>{
    const { __scopeMenubar, value: valueProp, ...menuProps } = props;
    const autoValue = useId();
    const value = valueProp || autoValue || "LEGACY_REACT_AUTO_VALUE";
    const context = useMenubarContext(MENU_NAME, __scopeMenubar);
    const menuScope = useMenuScope(__scopeMenubar);
    const triggerRef = React.useRef(null);
    const wasKeyboardTriggerOpenRef = React.useRef(false);
    const open = context.value === value;
    React.useEffect(()=>{
        if (!open) wasKeyboardTriggerOpenRef.current = false;
    }, [
        open
    ]);
    return /* @__PURE__ */ jsx(MenubarMenuProvider, {
        scope: __scopeMenubar,
        value,
        triggerId: useId(),
        triggerRef,
        contentId: useId(),
        wasKeyboardTriggerOpenRef,
        children: /* @__PURE__ */ jsx(Root3$1, {
            ...menuScope,
            open,
            onOpenChange: (open2)=>{
                if (!open2) context.onMenuClose();
            },
            modal: false,
            dir: context.dir,
            ...menuProps
        })
    });
};
MenubarMenu$1.displayName = MENU_NAME;
var TRIGGER_NAME = "MenubarTrigger";
var MenubarTrigger$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, disabled = false, ...triggerProps } = props;
    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenubar);
    const menuScope = useMenuScope(__scopeMenubar);
    const context = useMenubarContext(TRIGGER_NAME, __scopeMenubar);
    const menuContext = useMenubarMenuContext(TRIGGER_NAME, __scopeMenubar);
    const ref = React.useRef(null);
    const composedRefs = useComposedRefs(forwardedRef, ref, menuContext.triggerRef);
    const [isFocused, setIsFocused] = React.useState(false);
    const open = context.value === menuContext.value;
    return /* @__PURE__ */ jsx(Collection.ItemSlot, {
        scope: __scopeMenubar,
        value: menuContext.value,
        disabled,
        children: /* @__PURE__ */ jsx(Item, {
            asChild: true,
            ...rovingFocusGroupScope,
            focusable: !disabled,
            tabStopId: menuContext.value,
            children: /* @__PURE__ */ jsx(Anchor2, {
                asChild: true,
                ...menuScope,
                children: /* @__PURE__ */ jsx(Primitive.button, {
                    type: "button",
                    role: "menuitem",
                    id: menuContext.triggerId,
                    "aria-haspopup": "menu",
                    "aria-expanded": open,
                    "aria-controls": open ? menuContext.contentId : void 0,
                    "data-highlighted": isFocused ? "" : void 0,
                    "data-state": open ? "open" : "closed",
                    "data-disabled": disabled ? "" : void 0,
                    disabled,
                    ...triggerProps,
                    ref: composedRefs,
                    onPointerDown: composeEventHandlers(props.onPointerDown, (event)=>{
                        if (!disabled && event.button === 0 && event.ctrlKey === false) {
                            context.onMenuOpen(menuContext.value);
                            if (!open) event.preventDefault();
                        }
                    }),
                    onPointerEnter: composeEventHandlers(props.onPointerEnter, ()=>{
                        const menubarOpen = Boolean(context.value);
                        if (menubarOpen && !open) {
                            context.onMenuOpen(menuContext.value);
                            ref.current?.focus();
                        }
                    }),
                    onKeyDown: composeEventHandlers(props.onKeyDown, (event)=>{
                        if (disabled) return;
                        if ([
                            "Enter",
                            " "
                        ].includes(event.key)) context.onMenuToggle(menuContext.value);
                        if (event.key === "ArrowDown") context.onMenuOpen(menuContext.value);
                        if ([
                            "Enter",
                            " ",
                            "ArrowDown"
                        ].includes(event.key)) {
                            menuContext.wasKeyboardTriggerOpenRef.current = true;
                            event.preventDefault();
                        }
                    }),
                    onFocus: composeEventHandlers(props.onFocus, ()=>setIsFocused(true)),
                    onBlur: composeEventHandlers(props.onBlur, ()=>setIsFocused(false))
                })
            })
        })
    });
});
MenubarTrigger$1.displayName = TRIGGER_NAME;
var PORTAL_NAME = "MenubarPortal";
var MenubarPortal$1 = (props)=>{
    const { __scopeMenubar, ...portalProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(Portal, {
        ...menuScope,
        ...portalProps
    });
};
MenubarPortal$1.displayName = PORTAL_NAME;
var CONTENT_NAME = "MenubarContent";
var MenubarContent$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, align = "start", ...contentProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    const context = useMenubarContext(CONTENT_NAME, __scopeMenubar);
    const menuContext = useMenubarMenuContext(CONTENT_NAME, __scopeMenubar);
    const getItems = useCollection(__scopeMenubar);
    const hasInteractedOutsideRef = React.useRef(false);
    return /* @__PURE__ */ jsx(Content2$1, {
        id: menuContext.contentId,
        "aria-labelledby": menuContext.triggerId,
        "data-radix-menubar-content": "",
        ...menuScope,
        ...contentProps,
        ref: forwardedRef,
        align,
        onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event)=>{
            const menubarOpen = Boolean(context.value);
            if (!menubarOpen && !hasInteractedOutsideRef.current) {
                menuContext.triggerRef.current?.focus();
            }
            hasInteractedOutsideRef.current = false;
            event.preventDefault();
        }),
        onFocusOutside: composeEventHandlers(props.onFocusOutside, (event)=>{
            const target = event.target;
            const isMenubarTrigger = getItems().some((item)=>item.ref.current?.contains(target));
            if (isMenubarTrigger) event.preventDefault();
        }),
        onInteractOutside: composeEventHandlers(props.onInteractOutside, ()=>{
            hasInteractedOutsideRef.current = true;
        }),
        onEntryFocus: (event)=>{
            if (!menuContext.wasKeyboardTriggerOpenRef.current) event.preventDefault();
        },
        onKeyDown: composeEventHandlers(props.onKeyDown, (event)=>{
            if ([
                "ArrowRight",
                "ArrowLeft"
            ].includes(event.key)) {
                const target = event.target;
                const targetIsSubTrigger = target.hasAttribute("data-radix-menubar-subtrigger");
                const isKeyDownInsideSubMenu = target.closest("[data-radix-menubar-content]") !== event.currentTarget;
                const prevMenuKey = context.dir === "rtl" ? "ArrowRight" : "ArrowLeft";
                const isPrevKey = prevMenuKey === event.key;
                const isNextKey = !isPrevKey;
                if (isNextKey && targetIsSubTrigger) return;
                if (isKeyDownInsideSubMenu && isPrevKey) return;
                const items = getItems().filter((item)=>!item.disabled);
                let candidateValues = items.map((item)=>item.value);
                if (isPrevKey) candidateValues.reverse();
                const currentIndex = candidateValues.indexOf(menuContext.value);
                candidateValues = context.loop ? wrapArray(candidateValues, currentIndex + 1) : candidateValues.slice(currentIndex + 1);
                const [nextValue] = candidateValues;
                if (nextValue) context.onMenuOpen(nextValue);
            }
        }, {
            checkForDefaultPrevented: false
        }),
        style: {
            ...props.style,
            // re-namespace exposed content custom properties
            ...{
                "--radix-menubar-content-transform-origin": "var(--radix-popper-transform-origin)",
                "--radix-menubar-content-available-width": "var(--radix-popper-available-width)",
                "--radix-menubar-content-available-height": "var(--radix-popper-available-height)",
                "--radix-menubar-trigger-width": "var(--radix-popper-anchor-width)",
                "--radix-menubar-trigger-height": "var(--radix-popper-anchor-height)"
            }
        }
    });
});
MenubarContent$1.displayName = CONTENT_NAME;
var GROUP_NAME = "MenubarGroup";
var MenubarGroup$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...groupProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(Group, {
        ...menuScope,
        ...groupProps,
        ref: forwardedRef
    });
});
MenubarGroup$1.displayName = GROUP_NAME;
var LABEL_NAME = "MenubarLabel";
var MenubarLabel$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...labelProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(Label, {
        ...menuScope,
        ...labelProps,
        ref: forwardedRef
    });
});
MenubarLabel$1.displayName = LABEL_NAME;
var ITEM_NAME = "MenubarItem";
var MenubarItem$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...itemProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(Item2, {
        ...menuScope,
        ...itemProps,
        ref: forwardedRef
    });
});
MenubarItem$1.displayName = ITEM_NAME;
var CHECKBOX_ITEM_NAME = "MenubarCheckboxItem";
var MenubarCheckboxItem$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...checkboxItemProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(CheckboxItem, {
        ...menuScope,
        ...checkboxItemProps,
        ref: forwardedRef
    });
});
MenubarCheckboxItem$1.displayName = CHECKBOX_ITEM_NAME;
var RADIO_GROUP_NAME = "MenubarRadioGroup";
var MenubarRadioGroup$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...radioGroupProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(RadioGroup, {
        ...menuScope,
        ...radioGroupProps,
        ref: forwardedRef
    });
});
MenubarRadioGroup$1.displayName = RADIO_GROUP_NAME;
var RADIO_ITEM_NAME = "MenubarRadioItem";
var MenubarRadioItem$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...radioItemProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(RadioItem, {
        ...menuScope,
        ...radioItemProps,
        ref: forwardedRef
    });
});
MenubarRadioItem$1.displayName = RADIO_ITEM_NAME;
var INDICATOR_NAME = "MenubarItemIndicator";
var MenubarItemIndicator = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...itemIndicatorProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(ItemIndicator, {
        ...menuScope,
        ...itemIndicatorProps,
        ref: forwardedRef
    });
});
MenubarItemIndicator.displayName = INDICATOR_NAME;
var SEPARATOR_NAME = "MenubarSeparator";
var MenubarSeparator$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...separatorProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(Separator, {
        ...menuScope,
        ...separatorProps,
        ref: forwardedRef
    });
});
MenubarSeparator$1.displayName = SEPARATOR_NAME;
var ARROW_NAME = "MenubarArrow";
var MenubarArrow = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...arrowProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(Arrow2, {
        ...menuScope,
        ...arrowProps,
        ref: forwardedRef
    });
});
MenubarArrow.displayName = ARROW_NAME;
var SUB_NAME = "MenubarSub";
var MenubarSub$1 = (props)=>{
    const { __scopeMenubar, children, open: openProp, onOpenChange, defaultOpen } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    const [open, setOpen] = useControllableState({
        prop: openProp,
        defaultProp: defaultOpen ?? false,
        onChange: onOpenChange,
        caller: SUB_NAME
    });
    return /* @__PURE__ */ jsx(Sub, {
        ...menuScope,
        open,
        onOpenChange: setOpen,
        children
    });
};
MenubarSub$1.displayName = SUB_NAME;
var SUB_TRIGGER_NAME = "MenubarSubTrigger";
var MenubarSubTrigger$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...subTriggerProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(SubTrigger, {
        "data-radix-menubar-subtrigger": "",
        ...menuScope,
        ...subTriggerProps,
        ref: forwardedRef
    });
});
MenubarSubTrigger$1.displayName = SUB_TRIGGER_NAME;
var SUB_CONTENT_NAME = "MenubarSubContent";
var MenubarSubContent$1 = React.forwardRef((props, forwardedRef)=>{
    const { __scopeMenubar, ...subContentProps } = props;
    const menuScope = useMenuScope(__scopeMenubar);
    return /* @__PURE__ */ jsx(SubContent, {
        ...menuScope,
        "data-radix-menubar-content": "",
        ...subContentProps,
        ref: forwardedRef,
        style: {
            ...props.style,
            // re-namespace exposed content custom properties
            ...{
                "--radix-menubar-content-transform-origin": "var(--radix-popper-transform-origin)",
                "--radix-menubar-content-available-width": "var(--radix-popper-available-width)",
                "--radix-menubar-content-available-height": "var(--radix-popper-available-height)",
                "--radix-menubar-trigger-width": "var(--radix-popper-anchor-width)",
                "--radix-menubar-trigger-height": "var(--radix-popper-anchor-height)"
            }
        }
    });
});
MenubarSubContent$1.displayName = SUB_CONTENT_NAME;
function wrapArray(array, startIndex) {
    return array.map((_, index)=>array[(startIndex + index) % array.length]);
}
var Root3 = Menubar$1;
var Menu = MenubarMenu$1;
var Trigger = MenubarTrigger$1;
var Portal2 = MenubarPortal$1;
var Content2 = MenubarContent$1;
var Group2 = MenubarGroup$1;
var Label2 = MenubarLabel$1;
var Item3 = MenubarItem$1;
var CheckboxItem2 = MenubarCheckboxItem$1;
var RadioGroup2 = MenubarRadioGroup$1;
var RadioItem2 = MenubarRadioItem$1;
var ItemIndicator2 = MenubarItemIndicator;
var Separator2 = MenubarSeparator$1;
var Sub2 = MenubarSub$1;
var SubTrigger2 = MenubarSubTrigger$1;
var SubContent2 = MenubarSubContent$1;

function Menubar({ className, ...props }) {
    return /*#__PURE__*/ React.createElement(Root3, {
        "data-slot": "menubar",
        className: cn("bg-background *:font-lato flex h-9 w-fit items-center gap-1 rounded-md border p-1 shadow-xs", className),
        ...props
    });
}
function MenubarMenu({ ...props }) {
    return /*#__PURE__*/ React.createElement(Menu, {
        "data-slot": "menubar-menu",
        ...props
    });
}
function MenubarGroup({ ...props }) {
    return /*#__PURE__*/ React.createElement(Group2, {
        "data-slot": "menubar-group",
        ...props
    });
}
function MenubarPortal({ ...props }) {
    return /*#__PURE__*/ React.createElement(Portal2, {
        "data-slot": "menubar-portal",
        ...props
    });
}
function MenubarRadioGroup({ ...props }) {
    return /*#__PURE__*/ React.createElement(RadioGroup2, {
        "data-slot": "menubar-radio-group",
        ...props
    });
}
function MenubarTrigger({ className, ...props }) {
    return /*#__PURE__*/ React.createElement(Trigger, {
        "data-slot": "menubar-trigger",
        className: cn("focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground *:font-lato flex items-center rounded-sm px-2 py-1 text-sm font-medium outline-hidden select-none", className),
        ...props
    });
}
function MenubarContent({ className, align = "start", alignOffset = -4, sideOffset = 8, ...props }) {
    return /*#__PURE__*/ React.createElement(MenubarPortal, null, /*#__PURE__*/ React.createElement(Content2, {
        "data-slot": "menubar-content",
        align: align,
        alignOffset: alignOffset,
        sideOffset: sideOffset,
        className: cn("bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 *:font-lato z-50 min-w-[12rem] origin-(--radix-menubar-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-md", className),
        ...props
    }));
}
function MenubarItem({ className, inset, variant = "default", ...props }) {
    return /*#__PURE__*/ React.createElement(Item3, {
        "data-slot": "menubar-item",
        "data-inset": inset,
        "data-variant": variant,
        className: cn("focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:!text-destructive [&_svg:not([class*='text-'])]:text-muted-foreground *:font-lato relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
        ...props
    });
}
function MenubarCheckboxItem({ className, children, checked, ...props }) {
    return /*#__PURE__*/ React.createElement(CheckboxItem2, {
        "data-slot": "menubar-checkbox-item",
        className: cn("focus:bg-accent focus:text-accent-foreground *:font-lato relative flex cursor-default items-center gap-2 rounded-xs py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
        checked: checked,
        ...props
    }, /*#__PURE__*/ React.createElement("span", {
        className: "pointer-events-none absolute left-2 flex size-3.5 items-center justify-center"
    }, /*#__PURE__*/ React.createElement(ItemIndicator2, null, /*#__PURE__*/ React.createElement(Check, {
        className: "size-4"
    }))), children);
}
function MenubarRadioItem({ className, children, ...props }) {
    return /*#__PURE__*/ React.createElement(RadioItem2, {
        "data-slot": "menubar-radio-item",
        className: cn("focus:bg-accent focus:text-accent-foreground *:font-lato relative flex cursor-default items-center gap-2 rounded-xs py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
        ...props
    }, /*#__PURE__*/ React.createElement("span", {
        className: "pointer-events-none absolute left-2 flex size-3.5 items-center justify-center"
    }, /*#__PURE__*/ React.createElement(ItemIndicator2, null, /*#__PURE__*/ React.createElement(Circle, {
        className: "size-2 fill-current"
    }))), children);
}
function MenubarLabel({ className, inset, ...props }) {
    return /*#__PURE__*/ React.createElement(Label2, {
        "data-slot": "menubar-label",
        "data-inset": inset,
        className: cn("*:font-lato px-2 py-1.5 text-sm font-medium data-[inset]:pl-8", className),
        ...props
    });
}
function MenubarSeparator({ className, ...props }) {
    return /*#__PURE__*/ React.createElement(Separator2, {
        "data-slot": "menubar-separator",
        className: cn("bg-border *:font-lato -mx-1 my-1 h-px", className),
        ...props
    });
}
function MenubarShortcut({ className, ...props }) {
    return /*#__PURE__*/ React.createElement("span", {
        "data-slot": "menubar-shortcut",
        className: cn("text-muted-foreground *:font-lato ml-auto text-xs tracking-widest", className),
        ...props
    });
}
function MenubarSub({ ...props }) {
    return /*#__PURE__*/ React.createElement(Sub2, {
        "data-slot": "menubar-sub",
        ...props
    });
}
function MenubarSubTrigger({ className, inset, children, ...props }) {
    return /*#__PURE__*/ React.createElement(SubTrigger2, {
        "data-slot": "menubar-sub-trigger",
        "data-inset": inset,
        className: cn("focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground *:font-lato flex cursor-default items-center rounded-sm px-2 py-1.5 text-sm outline-none select-none data-[inset]:pl-8", className),
        ...props
    }, children, /*#__PURE__*/ React.createElement(ChevronRight, {
        className: "ml-auto h-4 w-4"
    }));
}
function MenubarSubContent({ className, ...props }) {
    return /*#__PURE__*/ React.createElement(SubContent2, {
        "data-slot": "menubar-sub-content",
        className: cn("bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 *:font-lato z-50 min-w-[8rem] origin-(--radix-menubar-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-lg", className),
        ...props
    });
}

export { Menubar as M, MenubarPortal as a, MenubarMenu as b, MenubarTrigger as c, MenubarContent as d, MenubarGroup as e, MenubarSeparator as f, MenubarLabel as g, MenubarItem as h, MenubarShortcut as i, MenubarCheckboxItem as j, MenubarRadioGroup as k, MenubarRadioItem as l, MenubarSub as m, MenubarSubTrigger as n, MenubarSubContent as o };
//# sourceMappingURL=menubar-JE1m8rYJ.mjs.map