@1771technologies/lytenyte-pro 0.0.39

package/dist/MenuRoot-9n64jNWP.js

@@ -0,0 +1,724 @@
+import * as React from "react";
+import { F as FloatingPortal, P as PropTypes, H as HTMLElementType, r as refType, p as useFloatingTree, q as useFloatingNodeId, t as useFloatingParentNodeId, k as useForkRef, v as useComponentRenderer, w as popupStateMapping, I as InternalBackdrop, x as FloatingNode, j as useEventCallback, y as useOpenChangeComplete, z as useFloatingRootContext, A as useHover, B as safePolygon, C as useClick, D as useDismiss, E as useRole, G as useListNavigation, J as useTypeahead, K as useInteractions, L as FloatingTree } from "./InternalBackdrop-Dm9czgoC.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { u as useAnchorPositioning, a as useDirection } from "./useAnchorPositioning-Cm44rb7y.js";
+import { C as CompositeList, a as useControlled, b as useTransitionStatus, c as useScrollLock } from "./useScrollLock-D6h5lZYs.js";
+import * as ReactDOM from "react-dom";
+const MenuPositionerContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") {
+  MenuPositionerContext.displayName = "MenuPositionerContext";
+}
+function useMenuPositionerContext() {
+  const context = React.useContext(MenuPositionerContext);
+  if (context === void 0) {
+    throw new Error("Base UI: MenuPositionerContext is missing. MenuPositioner parts must be placed within <Menu.Positioner>.");
+  }
+  return context;
+}
+const MenuRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") {
+  MenuRootContext.displayName = "MenuRootContext";
+}
+function useMenuRootContext(optional) {
+  const context = React.useContext(MenuRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error("Base UI: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>.");
+  }
+  return context;
+}
+const MenuPortalContext = /* @__PURE__ */ React.createContext(void 0);
+function useMenuPortalContext() {
+  const value = React.useContext(MenuPortalContext);
+  if (value === void 0) {
+    throw new Error("Base UI: <Menu.Portal> is missing.");
+  }
+  return value;
+}
+function MenuPortal(props) {
+  const {
+    children,
+    keepMounted = false,
+    container
+  } = props;
+  const {
+    mounted
+  } = useMenuRootContext();
+  const shouldRender = mounted || keepMounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(MenuPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ jsx(FloatingPortal, {
+      root: container,
+      children
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? MenuPortal.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: PropTypes.node,
+  /**
+   * A parent element to render the portal element into.
+   */
+  container: PropTypes.oneOfType([HTMLElementType, refType]),
+  /**
+   * Whether to keep the portal mounted in the DOM while the popup is hidden.
+   * @default false
+   */
+  keepMounted: PropTypes.bool
+} : void 0;
+function useMenuPositioner(params) {
+  const {
+    nodeId,
+    parentNodeId
+  } = params;
+  const {
+    open,
+    setOpen,
+    mounted,
+    setHoverEnabled
+  } = useMenuRootContext();
+  const positioning = useAnchorPositioning(params);
+  const {
+    events: menuEvents
+  } = useFloatingTree();
+  const positionerProps = React.useMemo(() => {
+    const hiddenStyles = {};
+    if (!open) {
+      hiddenStyles.pointerEvents = "none";
+    }
+    return {
+      role: "presentation",
+      hidden: !mounted,
+      style: {
+        ...positioning.positionerStyles,
+        ...hiddenStyles
+      }
+    };
+  }, [open, mounted, positioning.positionerStyles]);
+  React.useEffect(() => {
+    function onMenuOpenChange(event) {
+      if (event.open) {
+        if (event.parentNodeId === nodeId) {
+          setHoverEnabled(false);
+        }
+        if (event.nodeId !== nodeId && event.parentNodeId === parentNodeId) {
+          setOpen(false, void 0);
+        }
+      } else if (event.parentNodeId === nodeId) {
+        setHoverEnabled(true);
+      }
+    }
+    menuEvents.on("openchange", onMenuOpenChange);
+    return () => {
+      menuEvents.off("openchange", onMenuOpenChange);
+    };
+  }, [menuEvents, nodeId, parentNodeId, setOpen, setHoverEnabled]);
+  React.useEffect(() => {
+    menuEvents.emit("openchange", {
+      open,
+      nodeId,
+      parentNodeId
+    });
+  }, [menuEvents, open, nodeId, parentNodeId]);
+  return React.useMemo(() => ({
+    ...positioning,
+    positionerProps
+  }), [positioning, positionerProps]);
+}
+const MenuPositioner = /* @__PURE__ */ React.forwardRef(function MenuPositioner2(props, forwardedRef) {
+  const {
+    anchor,
+    positionMethod = "absolute",
+    className,
+    render,
+    side,
+    align,
+    sideOffset = 0,
+    alignOffset = 0,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding = 5,
+    arrowPadding = 5,
+    sticky = false,
+    trackAnchor = true,
+    ...otherProps
+  } = props;
+  const {
+    open,
+    floatingRootContext,
+    setPositionerElement,
+    itemDomElements,
+    itemLabels,
+    mounted,
+    nested,
+    modal,
+    openReason
+  } = useMenuRootContext();
+  const keepMounted = useMenuPortalContext();
+  const nodeId = useFloatingNodeId();
+  const parentNodeId = useFloatingParentNodeId();
+  let computedSide = side;
+  let computedAlign = align;
+  if (!side) {
+    computedSide = nested ? "inline-end" : "bottom";
+  }
+  if (!align) {
+    computedAlign = nested ? "start" : "center";
+  }
+  const positioner = useMenuPositioner({
+    anchor,
+    floatingRootContext,
+    positionMethod,
+    open,
+    mounted,
+    side: computedSide,
+    sideOffset,
+    align: computedAlign,
+    alignOffset,
+    arrowPadding,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    nodeId,
+    parentNodeId,
+    keepMounted,
+    trackAnchor
+  });
+  const state = React.useMemo(() => ({
+    open,
+    side: positioner.side,
+    align: positioner.align,
+    anchorHidden: positioner.anchorHidden,
+    nested
+  }), [open, positioner.side, positioner.align, positioner.anchorHidden, nested]);
+  const contextValue = React.useMemo(() => ({
+    side: positioner.side,
+    align: positioner.align,
+    arrowRef: positioner.arrowRef,
+    arrowUncentered: positioner.arrowUncentered,
+    arrowStyles: positioner.arrowStyles,
+    floatingContext: positioner.context
+  }), [positioner.side, positioner.align, positioner.arrowRef, positioner.arrowUncentered, positioner.arrowStyles, positioner.context]);
+  const mergedRef = useForkRef(forwardedRef, setPositionerElement);
+  const {
+    renderElement
+  } = useComponentRenderer({
+    render: render ?? "div",
+    className,
+    state,
+    customStyleHookMapping: popupStateMapping,
+    ref: mergedRef,
+    extraProps: {
+      ...positioner.positionerProps,
+      ...otherProps
+    }
+  });
+  return /* @__PURE__ */ jsxs(MenuPositionerContext.Provider, {
+    value: contextValue,
+    children: [mounted && modal && openReason !== "hover" && parentNodeId === null && /* @__PURE__ */ jsx(InternalBackdrop, {
+      inert: !open
+    }), /* @__PURE__ */ jsx(FloatingNode, {
+      id: nodeId,
+      children: /* @__PURE__ */ jsx(CompositeList, {
+        elementsRef: itemDomElements,
+        labelsRef: itemLabels,
+        children: renderElement()
+      })
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" ? MenuPositioner.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * How to align the popup relative to the specified side.
+   * @default 'center'
+   */
+  align: PropTypes.oneOf(["center", "end", "start"]),
+  /**
+   * Additional offset along the alignment axis in pixels.
+   * Also accepts a function that returns the offset to read the dimensions of the anchor
+   * and positioner elements, along with its side and alignment.
+   *
+   * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
+   * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
+   * - `data.side`: which side of the anchor element the positioner is aligned against.
+   * - `data.align`: how the positioner is aligned relative to the specified side.
+   * @default 0
+   */
+  alignOffset: PropTypes.oneOfType([PropTypes.func, PropTypes.number]),
+  /**
+   * An element to position the popup against.
+   * By default, the popup will be positioned against the trigger.
+   */
+  anchor: PropTypes.oneOfType([HTMLElementType, refType, PropTypes.object, PropTypes.func]),
+  /**
+   * Minimum distance to maintain between the arrow and the edges of the popup.
+   *
+   * Use it to prevent the arrow element from hanging out of the rounded corners of a popup.
+   * @default 5
+   */
+  arrowPadding: PropTypes.number,
+  /**
+   * @ignore
+   */
+  children: PropTypes.node,
+  /**
+   * CSS class applied to the element, or a function that
+   * returns a class based on the component’s state.
+   */
+  className: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
+  /**
+   * An element or a rectangle that delimits the area that the popup is confined to.
+   * @default 'clipping-ancestors'
+   */
+  collisionBoundary: PropTypes.oneOfType([HTMLElementType, PropTypes.arrayOf(HTMLElementType), PropTypes.string, PropTypes.shape({
+    height: PropTypes.number,
+    width: PropTypes.number,
+    x: PropTypes.number,
+    y: PropTypes.number
+  })]),
+  /**
+   * Additional space to maintain from the edge of the collision boundary.
+   * @default 5
+   */
+  collisionPadding: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
+    bottom: PropTypes.number,
+    left: PropTypes.number,
+    right: PropTypes.number,
+    top: PropTypes.number
+  })]),
+  /**
+   * Determines which CSS `position` property to use.
+   * @default 'absolute'
+   */
+  positionMethod: PropTypes.oneOf(["absolute", "fixed"]),
+  /**
+   * Allows you to replace the component’s HTML element
+   * with a different tag, or compose it with another component.
+   *
+   * Accepts a `ReactElement` or a function that returns the element to render.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
+  /**
+   * Which side of the anchor element to align the popup against.
+   * May automatically change to avoid collisions.
+   * @default 'bottom'
+   */
+  side: PropTypes.oneOf(["bottom", "inline-end", "inline-start", "left", "right", "top"]),
+  /**
+   * Distance between the anchor and the popup in pixels.
+   * Also accepts a function that returns the distance to read the dimensions of the anchor
+   * and positioner elements, along with its side and alignment.
+   *
+   * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
+   * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
+   * - `data.side`: which side of the anchor element the positioner is aligned against.
+   * - `data.align`: how the positioner is aligned relative to the specified side.
+   * @default 0
+   */
+  sideOffset: PropTypes.oneOfType([PropTypes.func, PropTypes.number]),
+  /**
+   * Whether to maintain the popup in the viewport after
+   * the anchor element was scrolled out of view.
+   * @default false
+   */
+  sticky: PropTypes.bool,
+  /**
+   * Whether the popup tracks any layout shift of its positioning anchor.
+   * @default true
+   */
+  trackAnchor: PropTypes.bool
+} : void 0;
+const TYPEAHEAD_RESET_MS = 500;
+const PATIENT_CLICK_THRESHOLD = 500;
+function translateOpenChangeReason(nativeReason) {
+  if (!nativeReason) {
+    return void 0;
+  }
+  return {
+    // Identical mappings
+    click: "click",
+    hover: "hover",
+    focus: "focus",
+    "focus-out": "focus-out",
+    "escape-key": "escape-key",
+    "outside-press": "outside-press",
+    // New mappings
+    "reference-press": "trigger-press",
+    "safe-polygon": "hover",
+    "ancestor-scroll": void 0,
+    // Not supported
+    "list-navigation": void 0
+    // Unnecessary to expose currently
+  }[nativeReason];
+}
+const EMPTY_ARRAY = [];
+function useMenuRoot(parameters) {
+  const {
+    open: openParam,
+    defaultOpen,
+    onOpenChange,
+    onOpenChangeComplete,
+    orientation,
+    direction,
+    disabled,
+    nested,
+    closeParentOnEsc,
+    loop,
+    delay,
+    openOnHover,
+    onTypingChange,
+    modal
+  } = parameters;
+  const [triggerElement, setTriggerElement] = React.useState(null);
+  const [positionerElement, setPositionerElementUnwrapped] = React.useState(null);
+  const [instantType, setInstantType] = React.useState();
+  const [hoverEnabled, setHoverEnabled] = React.useState(true);
+  const [activeIndex, setActiveIndex] = React.useState(null);
+  const [openReason, setOpenReason] = React.useState(null);
+  const [stickIfOpen, setStickIfOpen] = React.useState(true);
+  const popupRef = React.useRef(null);
+  const positionerRef = React.useRef(null);
+  const stickIfOpenTimeoutRef = React.useRef(-1);
+  const [open, setOpenUnwrapped] = useControlled({
+    controlled: openParam,
+    default: defaultOpen,
+    name: "useMenuRoot",
+    state: "open"
+  });
+  const setPositionerElement = React.useCallback((value) => {
+    positionerRef.current = value;
+    setPositionerElementUnwrapped(value);
+  }, []);
+  const allowMouseUpTriggerRef = React.useRef(false);
+  const {
+    mounted,
+    setMounted,
+    transitionStatus
+  } = useTransitionStatus(open);
+  useScrollLock(open && modal && openReason !== "hover", triggerElement);
+  const setOpen = useEventCallback((nextOpen, event, reason) => {
+    onOpenChange?.(nextOpen, event);
+    setOpenUnwrapped(nextOpen);
+    if (nextOpen) {
+      setOpenReason(reason ?? null);
+    }
+  });
+  if (!open && !hoverEnabled) {
+    setHoverEnabled(true);
+  }
+  const handleUnmount = useEventCallback(() => {
+    setMounted(false);
+    setOpenReason(null);
+    setStickIfOpen(true);
+    onOpenChangeComplete?.(false);
+  });
+  useOpenChangeComplete({
+    enabled: !parameters.actionsRef,
+    open,
+    ref: popupRef,
+    onComplete() {
+      if (!open) {
+        handleUnmount();
+      }
+    }
+  });
+  React.useImperativeHandle(parameters.actionsRef, () => ({
+    unmount: handleUnmount
+  }), [handleUnmount]);
+  const clearStickIfOpenTimeout = useEventCallback(() => {
+    clearTimeout(stickIfOpenTimeoutRef.current);
+  });
+  React.useEffect(() => {
+    if (!open) {
+      clearStickIfOpenTimeout();
+    }
+  }, [clearStickIfOpenTimeout, open]);
+  React.useEffect(() => {
+    return clearStickIfOpenTimeout;
+  }, [clearStickIfOpenTimeout]);
+  const floatingRootContext = useFloatingRootContext({
+    elements: {
+      reference: triggerElement,
+      floating: positionerElement
+    },
+    open,
+    onOpenChange(openValue, eventValue, reasonValue) {
+      const isHover = reasonValue === "hover" || reasonValue === "safe-polygon";
+      const isKeyboardClick = reasonValue === "click" && eventValue.detail === 0;
+      const isDismissClose = !openValue && (reasonValue === "escape-key" || reasonValue == null);
+      function changeState() {
+        setOpen(openValue, eventValue, translateOpenChangeReason(reasonValue));
+      }
+      if (isHover) {
+        clearStickIfOpenTimeout();
+        setStickIfOpen(true);
+        stickIfOpenTimeoutRef.current = window.setTimeout(() => {
+          setStickIfOpen(false);
+        }, PATIENT_CLICK_THRESHOLD);
+        ReactDOM.flushSync(changeState);
+      } else {
+        changeState();
+      }
+      if (isKeyboardClick || isDismissClose) {
+        setInstantType(isKeyboardClick ? "click" : "dismiss");
+      } else {
+        setInstantType(void 0);
+      }
+    }
+  });
+  const hover = useHover(floatingRootContext, {
+    enabled: hoverEnabled && openOnHover && !disabled && openReason !== "click",
+    handleClose: safePolygon({
+      blockPointerEvents: true
+    }),
+    mouseOnly: true,
+    move: false,
+    delay: {
+      open: delay
+    }
+  });
+  const click = useClick(floatingRootContext, {
+    enabled: !disabled,
+    event: "mousedown",
+    toggle: !openOnHover || !nested,
+    ignoreMouse: openOnHover && nested,
+    stickIfOpen
+  });
+  const dismiss = useDismiss(floatingRootContext, {
+    bubbles: closeParentOnEsc && nested,
+    outsidePressEvent: "mousedown"
+  });
+  const role = useRole(floatingRootContext, {
+    role: "menu"
+  });
+  const itemDomElements = React.useRef([]);
+  const itemLabels = React.useRef([]);
+  const listNavigation = useListNavigation(floatingRootContext, {
+    enabled: !disabled,
+    listRef: itemDomElements,
+    activeIndex,
+    nested,
+    loop,
+    orientation,
+    rtl: direction === "rtl",
+    disabledIndices: EMPTY_ARRAY,
+    onNavigate: setActiveIndex
+  });
+  const typeahead = useTypeahead(floatingRootContext, {
+    listRef: itemLabels,
+    activeIndex,
+    resetMs: TYPEAHEAD_RESET_MS,
+    onMatch: (index) => {
+      if (open && index !== activeIndex) {
+        setActiveIndex(index);
+      }
+    },
+    onTypingChange
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getItemProps
+  } = useInteractions([hover, click, dismiss, role, listNavigation, typeahead]);
+  const triggerProps = React.useMemo(() => getReferenceProps({
+    onMouseEnter() {
+      setHoverEnabled(true);
+    }
+  }), [getReferenceProps]);
+  const popupProps = React.useMemo(() => getFloatingProps({
+    onMouseEnter() {
+      if (!openOnHover || nested) {
+        setHoverEnabled(false);
+      }
+    },
+    onClick() {
+      if (openOnHover) {
+        setHoverEnabled(false);
+      }
+    }
+  }), [getFloatingProps, openOnHover, nested]);
+  const itemProps = React.useMemo(() => getItemProps(), [getItemProps]);
+  return React.useMemo(() => ({
+    activeIndex,
+    allowMouseUpTriggerRef,
+    floatingRootContext,
+    itemProps,
+    popupProps,
+    triggerProps,
+    itemDomElements,
+    itemLabels,
+    mounted,
+    open,
+    popupRef,
+    positionerRef,
+    setOpen,
+    setPositionerElement,
+    setTriggerElement,
+    transitionStatus,
+    openReason,
+    instantType,
+    onOpenChangeComplete,
+    setHoverEnabled
+  }), [activeIndex, floatingRootContext, itemProps, popupProps, triggerProps, itemDomElements, itemLabels, mounted, open, positionerRef, setOpen, transitionStatus, setPositionerElement, openReason, instantType, onOpenChangeComplete]);
+}
+const MenuRoot = function MenuRoot2(props) {
+  const {
+    children,
+    defaultOpen = false,
+    disabled = false,
+    closeParentOnEsc = true,
+    loop = true,
+    modal = true,
+    onOpenChange,
+    open,
+    orientation = "vertical",
+    delay = 100,
+    openOnHover: openOnHoverProp,
+    actionsRef,
+    onOpenChangeComplete
+  } = props;
+  const direction = useDirection();
+  const parentContext = useMenuRootContext(true);
+  const nested = parentContext != null;
+  const openOnHover = openOnHoverProp ?? nested;
+  const typingRef = React.useRef(false);
+  const onTypingChange = React.useCallback((nextTyping) => {
+    typingRef.current = nextTyping;
+  }, []);
+  const menuRoot = useMenuRoot({
+    direction,
+    disabled,
+    closeParentOnEsc,
+    onOpenChange,
+    loop,
+    defaultOpen,
+    open,
+    orientation,
+    nested,
+    openOnHover,
+    delay,
+    onTypingChange,
+    modal,
+    actionsRef,
+    onOpenChangeComplete
+  });
+  const context = React.useMemo(() => ({
+    ...menuRoot,
+    nested,
+    parentContext,
+    disabled,
+    allowMouseUpTriggerRef: parentContext?.allowMouseUpTriggerRef ?? menuRoot.allowMouseUpTriggerRef,
+    typingRef,
+    modal
+  }), [menuRoot, nested, parentContext, disabled, modal]);
+  if (!nested) {
+    return /* @__PURE__ */ jsx(FloatingTree, {
+      children: /* @__PURE__ */ jsx(MenuRootContext.Provider, {
+        value: context,
+        children
+      })
+    });
+  }
+  return /* @__PURE__ */ jsx(MenuRootContext.Provider, {
+    value: context,
+    children
+  });
+};
+process.env.NODE_ENV !== "production" ? MenuRoot.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A ref to imperative actions.
+   */
+  actionsRef: PropTypes.shape({
+    current: PropTypes.shape({
+      unmount: PropTypes.func.isRequired
+    }).isRequired
+  }),
+  /**
+   * @ignore
+   */
+  children: PropTypes.node,
+  /**
+   * When in a submenu, determines whether pressing the Escape key
+   * closes the entire menu, or only the current child menu.
+   * @default true
+   */
+  closeParentOnEsc: PropTypes.bool,
+  /**
+   * Whether the menu is initially open.
+   *
+   * To render a controlled menu, use the `open` prop instead.
+   * @default false
+   */
+  defaultOpen: PropTypes.bool,
+  /**
+   * How long to wait before the menu may be opened on hover. Specified in milliseconds.
+   *
+   * Requires the `openOnHover` prop.
+   * @default 100
+   */
+  delay: PropTypes.number,
+  /**
+   * Whether the component should ignore user interaction.
+   * @default false
+   */
+  disabled: PropTypes.bool,
+  /**
+   * Whether to loop keyboard focus back to the first item
+   * when the end of the list is reached while using the arrow keys.
+   * @default true
+   */
+  loop: PropTypes.bool,
+  /**
+   * Whether the menu should prevent outside clicks and lock page scroll when open.
+   * @default true
+   */
+  modal: PropTypes.bool,
+  /**
+   * Event handler called when the menu is opened or closed.
+   */
+  onOpenChange: PropTypes.func,
+  /**
+   * Event handler called after any animations complete when the menu is closed.
+   */
+  onOpenChangeComplete: PropTypes.func,
+  /**
+   * Whether the menu is currently open.
+   */
+  open: PropTypes.bool,
+  /**
+   * Whether the menu should also open when the trigger is hovered.
+   *
+   * Defaults to `true` for nested menus.
+   */
+  openOnHover: PropTypes.bool,
+  /**
+   * The visual orientation of the menu.
+   * Controls whether roving focus uses up/down or left/right arrow keys.
+   * @default 'vertical'
+   */
+  orientation: PropTypes.oneOf(["horizontal", "vertical"])
+} : void 0;
+export {
+  MenuRoot as M,
+  PATIENT_CLICK_THRESHOLD as P,
+  MenuPortal as a,
+  MenuPositioner as b,
+  useMenuPositionerContext as c,
+  translateOpenChangeReason as t,
+  useMenuRootContext as u
+};