palettecn 0.1.0

package/dist/web/server/_libs/radix-ui__react-menubar.mjs

@@ -0,0 +1,400 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { u as require_react } from "./@ai-sdk/react+[...].mjs";
+import { s as require_jsx_runtime } from "./@lobehub/icons+[...].mjs";
+import { c as useComposedRefs, n as Primitive } from "./@radix-ui/react-arrow+[...].mjs";
+import { i as useId, l as createContextScope, o as useControllableState } from "./@radix-ui/react-collapsible+[...].mjs";
+import { t as createCollection } from "./radix-ui__react-collection.mjs";
+import { t as composeEventHandlers } from "./radix-ui__primitive.mjs";
+import { t as useDirection } from "./radix-ui__react-direction.mjs";
+import { _ as createMenuScope, a as Group, b as createRovingFocusGroupScope, c as Label, d as RadioItem, f as Root3$1, g as SubTrigger, h as SubContent, i as Content2$1, l as Portal, m as Sub, n as Arrow2, o as Item2, p as Separator, r as CheckboxItem, s as ItemIndicator, t as Anchor2, u as RadioGroup, v as Item, y as Root } from "./@radix-ui/react-menu+[...].mjs";
+//#region ../../node_modules/.pnpm/@radix-ui+react-menubar@1.1.16_@types+react-dom@19.2.3_@types+react@19.2.14__@types+rea_2538d85c615acf13b2f2294bd07156f9/node_modules/@radix-ui/react-menubar/dist/index.mjs
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var import_jsx_runtime = require_jsx_runtime();
+var MENUBAR_NAME = "Menubar";
+var [Collection, useCollection, createCollectionScope] = createCollection(MENUBAR_NAME);
+var [createMenubarContext, createMenubarScope] = createContextScope(MENUBAR_NAME, [createCollectionScope, createRovingFocusGroupScope]);
+var useMenuScope = createMenuScope();
+var useRovingFocusGroupScope = createRovingFocusGroupScope();
+var [MenubarContextProvider, useMenubarContext] = createMenubarContext(MENUBAR_NAME);
+var Menubar = import_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] = import_react.useState(null);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenubarContextProvider, {
+		scope: __scopeMenubar,
+		value,
+		onMenuOpen: import_react.useCallback((value2) => {
+			setValue(value2);
+			setCurrentTabStopId(value2);
+		}, [setValue]),
+		onMenuClose: import_react.useCallback(() => setValue(""), [setValue]),
+		onMenuToggle: import_react.useCallback((value2) => {
+			setValue((prevValue) => prevValue ? "" : value2);
+			setCurrentTabStopId(value2);
+		}, [setValue]),
+		dir: direction,
+		loop,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Collection.Provider, {
+			scope: __scopeMenubar,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Collection.Slot, {
+				scope: __scopeMenubar,
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Root, {
+					asChild: true,
+					...rovingFocusGroupScope,
+					orientation: "horizontal",
+					loop,
+					dir: direction,
+					currentTabStopId,
+					onCurrentTabStopIdChange: setCurrentTabStopId,
+					children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.div, {
+						role: "menubar",
+						...menubarProps,
+						ref: forwardedRef
+					})
+				})
+			})
+		})
+	});
+});
+Menubar.displayName = MENUBAR_NAME;
+var MENU_NAME = "MenubarMenu";
+var [MenubarMenuProvider, useMenubarMenuContext] = createMenubarContext(MENU_NAME);
+var MenubarMenu = (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 = import_react.useRef(null);
+	const wasKeyboardTriggerOpenRef = import_react.useRef(false);
+	const open = context.value === value;
+	import_react.useEffect(() => {
+		if (!open) wasKeyboardTriggerOpenRef.current = false;
+	}, [open]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MenubarMenuProvider, {
+		scope: __scopeMenubar,
+		value,
+		triggerId: useId(),
+		triggerRef,
+		contentId: useId(),
+		wasKeyboardTriggerOpenRef,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Root3$1, {
+			...menuScope,
+			open,
+			onOpenChange: (open2) => {
+				if (!open2) context.onMenuClose();
+			},
+			modal: false,
+			dir: context.dir,
+			...menuProps
+		})
+	});
+};
+MenubarMenu.displayName = MENU_NAME;
+var TRIGGER_NAME = "MenubarTrigger";
+var MenubarTrigger = import_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 = import_react.useRef(null);
+	const composedRefs = useComposedRefs(forwardedRef, ref, menuContext.triggerRef);
+	const [isFocused, setIsFocused] = import_react.useState(false);
+	const open = context.value === menuContext.value;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Collection.ItemSlot, {
+		scope: __scopeMenubar,
+		value: menuContext.value,
+		disabled,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Item, {
+			asChild: true,
+			...rovingFocusGroupScope,
+			focusable: !disabled,
+			tabStopId: menuContext.value,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Anchor2, {
+				asChild: true,
+				...menuScope,
+				children: /* @__PURE__ */ (0, import_jsx_runtime.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, () => {
+						if (Boolean(context.value) && !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.displayName = TRIGGER_NAME;
+var PORTAL_NAME = "MenubarPortal";
+var MenubarPortal = (props) => {
+	const { __scopeMenubar, ...portalProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Portal, {
+		...menuScope,
+		...portalProps
+	});
+};
+MenubarPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "MenubarContent";
+var MenubarContent = import_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 = import_react.useRef(false);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Content2$1, {
+		id: menuContext.contentId,
+		"aria-labelledby": menuContext.triggerId,
+		"data-radix-menubar-content": "",
+		...menuScope,
+		...contentProps,
+		ref: forwardedRef,
+		align,
+		onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
+			if (!Boolean(context.value) && !hasInteractedOutsideRef.current) menuContext.triggerRef.current?.focus();
+			hasInteractedOutsideRef.current = false;
+			event.preventDefault();
+		}),
+		onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => {
+			const target = event.target;
+			if (getItems().some((item) => item.ref.current?.contains(target))) 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 isPrevKey = (context.dir === "rtl" ? "ArrowRight" : "ArrowLeft") === event.key;
+				if (!isPrevKey && targetIsSubTrigger) return;
+				if (isKeyDownInsideSubMenu && isPrevKey) return;
+				let candidateValues = getItems().filter((item) => !item.disabled).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,
+			"--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.displayName = CONTENT_NAME;
+var GROUP_NAME = "MenubarGroup";
+var MenubarGroup = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...groupProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Group, {
+		...menuScope,
+		...groupProps,
+		ref: forwardedRef
+	});
+});
+MenubarGroup.displayName = GROUP_NAME;
+var LABEL_NAME = "MenubarLabel";
+var MenubarLabel = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...labelProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Label, {
+		...menuScope,
+		...labelProps,
+		ref: forwardedRef
+	});
+});
+MenubarLabel.displayName = LABEL_NAME;
+var ITEM_NAME = "MenubarItem";
+var MenubarItem = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...itemProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Item2, {
+		...menuScope,
+		...itemProps,
+		ref: forwardedRef
+	});
+});
+MenubarItem.displayName = ITEM_NAME;
+var CHECKBOX_ITEM_NAME = "MenubarCheckboxItem";
+var MenubarCheckboxItem = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...checkboxItemProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CheckboxItem, {
+		...menuScope,
+		...checkboxItemProps,
+		ref: forwardedRef
+	});
+});
+MenubarCheckboxItem.displayName = CHECKBOX_ITEM_NAME;
+var RADIO_GROUP_NAME = "MenubarRadioGroup";
+var MenubarRadioGroup = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...radioGroupProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RadioGroup, {
+		...menuScope,
+		...radioGroupProps,
+		ref: forwardedRef
+	});
+});
+MenubarRadioGroup.displayName = RADIO_GROUP_NAME;
+var RADIO_ITEM_NAME = "MenubarRadioItem";
+var MenubarRadioItem = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...radioItemProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RadioItem, {
+		...menuScope,
+		...radioItemProps,
+		ref: forwardedRef
+	});
+});
+MenubarRadioItem.displayName = RADIO_ITEM_NAME;
+var INDICATOR_NAME = "MenubarItemIndicator";
+var MenubarItemIndicator = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...itemIndicatorProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ItemIndicator, {
+		...menuScope,
+		...itemIndicatorProps,
+		ref: forwardedRef
+	});
+});
+MenubarItemIndicator.displayName = INDICATOR_NAME;
+var SEPARATOR_NAME = "MenubarSeparator";
+var MenubarSeparator = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...separatorProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Separator, {
+		...menuScope,
+		...separatorProps,
+		ref: forwardedRef
+	});
+});
+MenubarSeparator.displayName = SEPARATOR_NAME;
+var ARROW_NAME = "MenubarArrow";
+var MenubarArrow = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...arrowProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Arrow2, {
+		...menuScope,
+		...arrowProps,
+		ref: forwardedRef
+	});
+});
+MenubarArrow.displayName = ARROW_NAME;
+var SUB_NAME = "MenubarSub";
+var MenubarSub = (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__ */ (0, import_jsx_runtime.jsx)(Sub, {
+		...menuScope,
+		open,
+		onOpenChange: setOpen,
+		children
+	});
+};
+MenubarSub.displayName = SUB_NAME;
+var SUB_TRIGGER_NAME = "MenubarSubTrigger";
+var MenubarSubTrigger = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...subTriggerProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SubTrigger, {
+		"data-radix-menubar-subtrigger": "",
+		...menuScope,
+		...subTriggerProps,
+		ref: forwardedRef
+	});
+});
+MenubarSubTrigger.displayName = SUB_TRIGGER_NAME;
+var SUB_CONTENT_NAME = "MenubarSubContent";
+var MenubarSubContent = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopeMenubar, ...subContentProps } = props;
+	const menuScope = useMenuScope(__scopeMenubar);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SubContent, {
+		...menuScope,
+		"data-radix-menubar-content": "",
+		...subContentProps,
+		ref: forwardedRef,
+		style: {
+			...props.style,
+			"--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.displayName = SUB_CONTENT_NAME;
+function wrapArray(array, startIndex) {
+	return array.map((_, index) => array[(startIndex + index) % array.length]);
+}
+var Root3 = Menubar;
+var Menu = MenubarMenu;
+var Trigger = MenubarTrigger;
+var Portal2 = MenubarPortal;
+var Content2 = MenubarContent;
+var Item3 = MenubarItem;
+var Sub2 = MenubarSub;
+var SubTrigger2 = MenubarSubTrigger;
+var SubContent2 = MenubarSubContent;
+//#endregion
+export { Root3 as a, SubTrigger2 as c, Portal2 as i, Trigger as l, Item3 as n, Sub2 as o, Menu as r, SubContent2 as s, Content2 as t };

package/dist/web/server/_libs/radix-ui__react-popover.mjs

@@ -0,0 +1,251 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { u as require_react } from "./@ai-sdk/react+[...].mjs";
+import { s as require_jsx_runtime } from "./@lobehub/icons+[...].mjs";
+import { a as createSlot, c as useComposedRefs, n as Primitive } from "./@radix-ui/react-arrow+[...].mjs";
+import { a as Presence, i as useId, l as createContextScope, o as useControllableState } from "./@radix-ui/react-collapsible+[...].mjs";
+import { t as composeEventHandlers } from "./radix-ui__primitive.mjs";
+import { d as useFocusGuards, f as Portal$1, l as hideOthers, m as DismissableLayer, p as FocusScope, u as ReactRemoveScroll } from "./@radix-ui/react-dialog+[...].mjs";
+import { C as Content, S as Arrow, T as createPopperScope, w as Root2$1, x as Anchor } from "./@radix-ui/react-menu+[...].mjs";
+//#region ../../node_modules/.pnpm/@radix-ui+react-popover@1.1.15_@types+react-dom@19.2.3_@types+react@19.2.14__@types+rea_8b5332f8e883134e9d9ab2856fc4395d/node_modules/@radix-ui/react-popover/dist/index.mjs
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var import_jsx_runtime = require_jsx_runtime();
+var POPOVER_NAME = "Popover";
+var [createPopoverContext, createPopoverScope] = createContextScope(POPOVER_NAME, [createPopperScope]);
+var usePopperScope = createPopperScope();
+var [PopoverProvider, usePopoverContext] = createPopoverContext(POPOVER_NAME);
+var Popover = (props) => {
+	const { __scopePopover, children, open: openProp, defaultOpen, onOpenChange, modal = false } = props;
+	const popperScope = usePopperScope(__scopePopover);
+	const triggerRef = import_react.useRef(null);
+	const [hasCustomAnchor, setHasCustomAnchor] = import_react.useState(false);
+	const [open, setOpen] = useControllableState({
+		prop: openProp,
+		defaultProp: defaultOpen ?? false,
+		onChange: onOpenChange,
+		caller: POPOVER_NAME
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Root2$1, {
+		...popperScope,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverProvider, {
+			scope: __scopePopover,
+			contentId: useId(),
+			triggerRef,
+			open,
+			onOpenChange: setOpen,
+			onOpenToggle: import_react.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
+			hasCustomAnchor,
+			onCustomAnchorAdd: import_react.useCallback(() => setHasCustomAnchor(true), []),
+			onCustomAnchorRemove: import_react.useCallback(() => setHasCustomAnchor(false), []),
+			modal,
+			children
+		})
+	});
+};
+Popover.displayName = POPOVER_NAME;
+var ANCHOR_NAME = "PopoverAnchor";
+var PopoverAnchor = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopePopover, ...anchorProps } = props;
+	const context = usePopoverContext(ANCHOR_NAME, __scopePopover);
+	const popperScope = usePopperScope(__scopePopover);
+	const { onCustomAnchorAdd, onCustomAnchorRemove } = context;
+	import_react.useEffect(() => {
+		onCustomAnchorAdd();
+		return () => onCustomAnchorRemove();
+	}, [onCustomAnchorAdd, onCustomAnchorRemove]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Anchor, {
+		...popperScope,
+		...anchorProps,
+		ref: forwardedRef
+	});
+});
+PopoverAnchor.displayName = ANCHOR_NAME;
+var TRIGGER_NAME = "PopoverTrigger";
+var PopoverTrigger = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopePopover, ...triggerProps } = props;
+	const context = usePopoverContext(TRIGGER_NAME, __scopePopover);
+	const popperScope = usePopperScope(__scopePopover);
+	const composedTriggerRef = useComposedRefs(forwardedRef, context.triggerRef);
+	const trigger = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.button, {
+		type: "button",
+		"aria-haspopup": "dialog",
+		"aria-expanded": context.open,
+		"aria-controls": context.contentId,
+		"data-state": getState(context.open),
+		...triggerProps,
+		ref: composedTriggerRef,
+		onClick: composeEventHandlers(props.onClick, context.onOpenToggle)
+	});
+	return context.hasCustomAnchor ? trigger : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Anchor, {
+		asChild: true,
+		...popperScope,
+		children: trigger
+	});
+});
+PopoverTrigger.displayName = TRIGGER_NAME;
+var PORTAL_NAME = "PopoverPortal";
+var [PortalProvider, usePortalContext] = createPopoverContext(PORTAL_NAME, { forceMount: void 0 });
+var PopoverPortal = (props) => {
+	const { __scopePopover, forceMount, children, container } = props;
+	const context = usePopoverContext(PORTAL_NAME, __scopePopover);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PortalProvider, {
+		scope: __scopePopover,
+		forceMount,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Presence, {
+			present: forceMount || context.open,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Portal$1, {
+				asChild: true,
+				container,
+				children
+			})
+		})
+	});
+};
+PopoverPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "PopoverContent";
+var PopoverContent = import_react.forwardRef((props, forwardedRef) => {
+	const portalContext = usePortalContext(CONTENT_NAME, props.__scopePopover);
+	const { forceMount = portalContext.forceMount, ...contentProps } = props;
+	const context = usePopoverContext(CONTENT_NAME, props.__scopePopover);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Presence, {
+		present: forceMount || context.open,
+		children: context.modal ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContentModal, {
+			...contentProps,
+			ref: forwardedRef
+		}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContentNonModal, {
+			...contentProps,
+			ref: forwardedRef
+		})
+	});
+});
+PopoverContent.displayName = CONTENT_NAME;
+var Slot = createSlot("PopoverContent.RemoveScroll");
+var PopoverContentModal = import_react.forwardRef((props, forwardedRef) => {
+	const context = usePopoverContext(CONTENT_NAME, props.__scopePopover);
+	const contentRef = import_react.useRef(null);
+	const composedRefs = useComposedRefs(forwardedRef, contentRef);
+	const isRightClickOutsideRef = import_react.useRef(false);
+	import_react.useEffect(() => {
+		const content = contentRef.current;
+		if (content) return hideOthers(content);
+	}, []);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ReactRemoveScroll, {
+		as: Slot,
+		allowPinchZoom: true,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContentImpl, {
+			...props,
+			ref: composedRefs,
+			trapFocus: context.open,
+			disableOutsidePointerEvents: true,
+			onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
+				event.preventDefault();
+				if (!isRightClickOutsideRef.current) context.triggerRef.current?.focus();
+			}),
+			onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => {
+				const originalEvent = event.detail.originalEvent;
+				const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
+				isRightClickOutsideRef.current = originalEvent.button === 2 || ctrlLeftClick;
+			}, { checkForDefaultPrevented: false }),
+			onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => event.preventDefault(), { checkForDefaultPrevented: false })
+		})
+	});
+});
+var PopoverContentNonModal = import_react.forwardRef((props, forwardedRef) => {
+	const context = usePopoverContext(CONTENT_NAME, props.__scopePopover);
+	const hasInteractedOutsideRef = import_react.useRef(false);
+	const hasPointerDownOutsideRef = import_react.useRef(false);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PopoverContentImpl, {
+		...props,
+		ref: forwardedRef,
+		trapFocus: false,
+		disableOutsidePointerEvents: false,
+		onCloseAutoFocus: (event) => {
+			props.onCloseAutoFocus?.(event);
+			if (!event.defaultPrevented) {
+				if (!hasInteractedOutsideRef.current) context.triggerRef.current?.focus();
+				event.preventDefault();
+			}
+			hasInteractedOutsideRef.current = false;
+			hasPointerDownOutsideRef.current = false;
+		},
+		onInteractOutside: (event) => {
+			props.onInteractOutside?.(event);
+			if (!event.defaultPrevented) {
+				hasInteractedOutsideRef.current = true;
+				if (event.detail.originalEvent.type === "pointerdown") hasPointerDownOutsideRef.current = true;
+			}
+			const target = event.target;
+			if (context.triggerRef.current?.contains(target)) event.preventDefault();
+			if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) event.preventDefault();
+		}
+	});
+});
+var PopoverContentImpl = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopePopover, trapFocus, onOpenAutoFocus, onCloseAutoFocus, disableOutsidePointerEvents, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, ...contentProps } = props;
+	const context = usePopoverContext(CONTENT_NAME, __scopePopover);
+	const popperScope = usePopperScope(__scopePopover);
+	useFocusGuards();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FocusScope, {
+		asChild: true,
+		loop: true,
+		trapped: trapFocus,
+		onMountAutoFocus: onOpenAutoFocus,
+		onUnmountAutoFocus: onCloseAutoFocus,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DismissableLayer, {
+			asChild: true,
+			disableOutsidePointerEvents,
+			onInteractOutside,
+			onEscapeKeyDown,
+			onPointerDownOutside,
+			onFocusOutside,
+			onDismiss: () => context.onOpenChange(false),
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Content, {
+				"data-state": getState(context.open),
+				role: "dialog",
+				id: context.contentId,
+				...popperScope,
+				...contentProps,
+				ref: forwardedRef,
+				style: {
+					...contentProps.style,
+					"--radix-popover-content-transform-origin": "var(--radix-popper-transform-origin)",
+					"--radix-popover-content-available-width": "var(--radix-popper-available-width)",
+					"--radix-popover-content-available-height": "var(--radix-popper-available-height)",
+					"--radix-popover-trigger-width": "var(--radix-popper-anchor-width)",
+					"--radix-popover-trigger-height": "var(--radix-popper-anchor-height)"
+				}
+			})
+		})
+	});
+});
+var CLOSE_NAME = "PopoverClose";
+var PopoverClose = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopePopover, ...closeProps } = props;
+	const context = usePopoverContext(CLOSE_NAME, __scopePopover);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Primitive.button, {
+		type: "button",
+		...closeProps,
+		ref: forwardedRef,
+		onClick: composeEventHandlers(props.onClick, () => context.onOpenChange(false))
+	});
+});
+PopoverClose.displayName = CLOSE_NAME;
+var ARROW_NAME = "PopoverArrow";
+var PopoverArrow = import_react.forwardRef((props, forwardedRef) => {
+	const { __scopePopover, ...arrowProps } = props;
+	const popperScope = usePopperScope(__scopePopover);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Arrow, {
+		...popperScope,
+		...arrowProps,
+		ref: forwardedRef
+	});
+});
+PopoverArrow.displayName = ARROW_NAME;
+function getState(open) {
+	return open ? "open" : "closed";
+}
+var Root2 = Popover;
+var Trigger = PopoverTrigger;
+var Portal = PopoverPortal;
+var Content2 = PopoverContent;
+//#endregion
+export { Trigger as a, Root2 as i, PopoverClose as n, Portal as r, Content2 as t };