@serendie/ui 3.2.0 → 3.2.1-dev.202604210459

package/dist/node_modules/@zag-js/menu/dist/menu.machine.js

@@ -0,0 +1,855 @@
+import { setInteractionModality as S, trackFocusVisible as v, getInteractionModality as V } from "../../focus-visible/dist/index.js";
+import { getPlacement as T } from "../../popper/dist/get-placement.js";
+import { getPlacementSide as N } from "../../popper/dist/placement.js";
+import { getItemValue as h, isTriggerItem as f, getContentEl as c, getElemByKey as y, getActiveTriggerEl as E, getItemEl as M, dispatchSelectionEvent as A, getPrevEl as H, getNextEl as D, getLastEl as _, getFirstEl as G, getTriggerId as b, getTriggerEl as F, getTriggerEls as U, getContextTriggerEl as w, getContextTriggerEls as I, getPositionerEl as P, isTargetWithinMenuTree as W } from "./menu.dom.js";
+import { unlockParentOnSubmenuClose as B, closeRootMenu as R, unlockParentAfterChildClose as x, setParentRoutingLock as m, isWithinPolygon as Y, resolveItemId as q } from "./menu.utils.js";
+import { createMachine as K, createGuards as X } from "../../core/dist/create-machine.js";
+import { isPointInPolygon as $, getElementPolygon as j } from "../../rect-utils/dist/polygon.js";
+import { raf as p } from "../../dom-query/dist/raf.js";
+import { getInitialFocus as z } from "../../dom-query/dist/initial-focus.js";
+import { contains as C, isAnchorElement as J, isEditableElement as Q } from "../../dom-query/dist/node.js";
+import { isEqual as Z } from "../../utils/dist/equal.js";
+import { observeAttributes as ee } from "../../dom-query/dist/mutation-observer.js";
+import { addDomEvent as te, getEventTarget as L } from "../../dom-query/dist/event.js";
+import { trackDismissableElement as ne } from "../../dismissable/dist/dismissable-layer.js";
+import { getByTypeahead as ie } from "../../dom-query/dist/typeahead.js";
+import { clickIfLink as oe } from "../../dom-query/dist/navigate.js";
+import { scrollIntoView as re } from "../../dom-query/dist/overflow.js";
+var { not: a, and: O, or: se } = X(), Le = K({
+  props({ props: e }) {
+    return {
+      closeOnSelect: !0,
+      typeahead: !0,
+      composite: !0,
+      loopFocus: !1,
+      navigate(t) {
+        oe(t.node);
+      },
+      ...e,
+      positioning: {
+        placement: "bottom-start",
+        gutter: 8,
+        ...e.positioning
+      }
+    };
+  },
+  initialState({ prop: e }) {
+    return e("open") || e("defaultOpen") ? "open" : "idle";
+  },
+  context({ bindable: e, prop: t, scope: n }) {
+    return {
+      highlightedValue: e(() => ({
+        defaultValue: t("defaultHighlightedValue") || null,
+        value: t("highlightedValue"),
+        onChange(i) {
+          var o;
+          (o = t("onHighlightChange")) == null || o({ highlightedValue: i });
+        }
+      })),
+      lastHighlightedValue: e(() => ({
+        defaultValue: null
+      })),
+      currentPlacement: e(() => ({
+        defaultValue: void 0
+      })),
+      intentPolygon: e(() => ({
+        defaultValue: null
+      })),
+      anchorPoint: e(() => ({
+        defaultValue: null,
+        hash(i) {
+          return `x: ${i == null ? void 0 : i.x}, y: ${i == null ? void 0 : i.y}`;
+        }
+      })),
+      isSubmenu: e(() => ({
+        defaultValue: !1
+      })),
+      triggerValue: e(() => ({
+        defaultValue: t("defaultTriggerValue") ?? null,
+        value: t("triggerValue"),
+        onChange(i) {
+          const o = t("onTriggerValueChange");
+          if (!o) return;
+          const r = E(n, i);
+          o({ value: i, triggerElement: r });
+        }
+      })),
+      pointerRoutingMode: e(() => ({
+        defaultValue: "interactive"
+      }))
+    };
+  },
+  refs() {
+    return {
+      parent: null,
+      children: {},
+      pointerRoutingLocked: !1,
+      typeaheadState: { ...ie.defaultOptions },
+      positioningOverride: {}
+    };
+  },
+  computed: {
+    isRtl: ({ prop: e }) => e("dir") === "rtl",
+    isTypingAhead: ({ refs: e }) => e.get("typeaheadState").keysSoFar !== "",
+    highlightedId: ({ context: e, scope: t, refs: n }) => q(n.get("children"), e.get("highlightedValue"), t)
+  },
+  watch({ track: e, action: t, context: n, prop: i }) {
+    e([() => n.get("isSubmenu")], () => {
+      t(["setSubmenuPlacement"]);
+    }), e([() => n.hash("anchorPoint")], () => {
+      n.get("anchorPoint") && t(["reposition"]);
+    }), e([() => i("open")], () => {
+      t(["toggleVisibility"]);
+    });
+  },
+  on: {
+    "TRIGGER_VALUE.SET": {
+      actions: ["setTriggerValue", "setAnchorPoint", "reposition", "focusMenu"]
+    },
+    "PARENT.SET": {
+      actions: ["setParentMenu"]
+    },
+    "CHILD.SET": {
+      actions: ["setChildMenu"]
+    },
+    OPEN: [
+      {
+        guard: "isOpenControlled",
+        actions: ["setTriggerValue", "invokeOnOpen"]
+      },
+      {
+        target: "open",
+        actions: ["setTriggerValue", "invokeOnOpen"]
+      }
+    ],
+    OPEN_AUTOFOCUS: [
+      {
+        guard: "isOpenControlled",
+        actions: ["setTriggerValue", "invokeOnOpen"]
+      },
+      {
+        // internal: true,
+        target: "open",
+        actions: ["setTriggerValue", "highlightFirstItem", "invokeOnOpen"]
+      }
+    ],
+    CLOSE: [
+      {
+        guard: "isOpenControlled",
+        actions: ["invokeOnClose", "releaseParentRoutingLock"]
+      },
+      {
+        target: "closed",
+        actions: ["invokeOnClose", "releaseParentRoutingLock", "focusTrigger"]
+      }
+    ],
+    "HIGHLIGHTED.RESTORE": {
+      actions: ["restoreHighlightedItem"]
+    },
+    "HIGHLIGHTED.SET": {
+      actions: ["setHighlightedItem"]
+    },
+    "HIGHLIGHTED.SUGGEST": {
+      actions: ["suggestHighlightedItem"]
+    }
+  },
+  states: {
+    idle: {
+      tags: ["closed"],
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open"
+        },
+        "CONTROLLED.CLOSE": {
+          target: "closed"
+        },
+        CONTEXT_MENU_START: {
+          target: "opening:contextmenu",
+          actions: ["setAnchorPoint", "setTriggerValue"]
+        },
+        CONTEXT_MENU: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setAnchorPoint", "setTriggerValue", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setAnchorPoint", "setTriggerValue", "invokeOnOpen"]
+          }
+        ],
+        TRIGGER_CLICK: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen", "setTriggerValue"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen", "setTriggerValue"]
+          }
+        ],
+        TRIGGER_FOCUS: {
+          guard: a("isSubmenu"),
+          target: "closed"
+        },
+        TRIGGER_POINTERMOVE: {
+          guard: "isSubmenu",
+          target: "opening"
+        }
+      }
+    },
+    "opening:contextmenu": {
+      tags: ["closed"],
+      effects: ["waitForLongPress"],
+      on: {
+        "CONTROLLED.OPEN": { target: "open" },
+        "CONTROLLED.CLOSE": { target: "closed", actions: ["focusTrigger"] },
+        CONTEXT_MENU_CANCEL: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose", "releaseParentRoutingLock", "focusTrigger"]
+          }
+        ],
+        "LONG_PRESS.OPEN": [
+          {
+            guard: "isOpenControlled",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    opening: {
+      tags: ["closed"],
+      effects: ["waitForOpenDelay"],
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open"
+        },
+        "CONTROLLED.CLOSE": {
+          target: "closed",
+          actions: ["focusTrigger"]
+        },
+        BLUR: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose", "releaseParentRoutingLock", "focusTrigger"]
+          }
+        ],
+        TRIGGER_POINTERLEAVE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose", "releaseParentRoutingLock", "focusTrigger"]
+          }
+        ],
+        "DELAY.OPEN": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    closing: {
+      tags: ["open"],
+      effects: ["trackPointerMove", "trackInteractOutside", "waitForCloseDelay"],
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open"
+        },
+        "CONTROLLED.CLOSE": {
+          target: "closed",
+          actions: ["focusParentMenu", "restoreParentHighlightedItem"]
+        },
+        // don't invoke on open here since the menu is still open (we're only keeping it open)
+        MENU_POINTERENTER: {
+          target: "open",
+          actions: ["clearIntentPolygon"]
+        },
+        POINTER_MOVED_AWAY_FROM_SUBMENU: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            target: "closed",
+            actions: ["focusParentMenu", "restoreParentHighlightedItem"]
+          }
+        ],
+        "DELAY.CLOSE": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            target: "closed",
+            actions: ["focusParentMenu", "restoreParentHighlightedItem", "invokeOnClose", "releaseParentRoutingLock"]
+          }
+        ]
+      }
+    },
+    closed: {
+      tags: ["closed"],
+      entry: ["clearHighlightedItem", "unlockParentOnClose", "clearAnchorPoint"],
+      on: {
+        "CONTROLLED.OPEN": [
+          {
+            guard: se("isOpenAutoFocusEvent", "isArrowDownEvent"),
+            target: "open",
+            actions: ["highlightFirstItem"]
+          },
+          {
+            guard: "isArrowUpEvent",
+            target: "open",
+            actions: ["highlightLastItem"]
+          },
+          {
+            target: "open"
+          }
+        ],
+        CONTEXT_MENU_START: {
+          target: "opening:contextmenu",
+          actions: ["setAnchorPoint", "setTriggerValue"]
+        },
+        CONTEXT_MENU: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setAnchorPoint", "setTriggerValue", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setAnchorPoint", "setTriggerValue", "invokeOnOpen"]
+          }
+        ],
+        TRIGGER_CLICK: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen", "setTriggerValue"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen", "setTriggerValue"]
+          }
+        ],
+        TRIGGER_POINTERMOVE: {
+          guard: "isTriggerItem",
+          target: "opening"
+        },
+        TRIGGER_BLUR: { target: "idle" },
+        ARROW_DOWN: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setTriggerValue", "highlightFirstItem", "invokeOnOpen"]
+          }
+        ],
+        ARROW_UP: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setTriggerValue", "highlightLastItem", "invokeOnOpen"]
+          }
+        ]
+      }
+    },
+    open: {
+      tags: ["open"],
+      effects: ["trackInteractOutside", "trackFocusVisible", "trackPositioning", "scrollToHighlightedItem"],
+      entry: ["focusMenu", "unlockParentOnOpen"],
+      on: {
+        "CONTROLLED.CLOSE": [
+          {
+            target: "closed",
+            guard: "isArrowLeftEvent",
+            actions: ["focusParentMenu"]
+          },
+          {
+            target: "closed",
+            actions: ["focusTrigger"]
+          }
+        ],
+        TRIGGER_CLICK: [
+          {
+            guard: O(a("isTriggerItem"), "isOpenControlled"),
+            actions: ["invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            guard: a("isTriggerItem"),
+            target: "closed",
+            actions: ["invokeOnClose", "releaseParentRoutingLock", "focusTrigger"]
+          }
+        ],
+        CONTEXT_MENU: {
+          actions: ["setAnchorPoint", "setTriggerValue", "focusMenu"]
+        },
+        ARROW_UP: {
+          actions: ["highlightPrevItem", "focusMenu"]
+        },
+        ARROW_DOWN: {
+          actions: ["highlightNextItem", "focusMenu"]
+        },
+        ARROW_LEFT: [
+          {
+            guard: O("isSubmenu", "isOpenControlled"),
+            actions: ["invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            guard: "isSubmenu",
+            target: "closed",
+            actions: ["focusParentMenu", "invokeOnClose", "releaseParentRoutingLock"]
+          }
+        ],
+        HOME: {
+          actions: ["highlightFirstItem", "focusMenu"]
+        },
+        END: {
+          actions: ["highlightLastItem", "focusMenu"]
+        },
+        ARROW_RIGHT: {
+          guard: "isTriggerItemHighlighted",
+          actions: ["openSubmenu"]
+        },
+        ENTER: [
+          {
+            guard: "isTriggerItemHighlighted",
+            actions: ["openSubmenu"]
+          },
+          {
+            actions: ["clickHighlightedItem"]
+          }
+        ],
+        ITEM_POINTERMOVE: [
+          {
+            guard: a("isPointerRoutingLocked"),
+            actions: ["setHighlightedItem", "focusMenu", "closeSiblingMenus"]
+          },
+          {
+            actions: ["setLastHighlightedItem", "closeSiblingMenus"]
+          }
+        ],
+        ITEM_POINTERLEAVE: {
+          guard: O(a("isPointerRoutingLocked"), a("isTriggerItem")),
+          actions: ["clearHighlightedItem"]
+        },
+        ITEM_CLICK: [
+          // == grouped ==
+          {
+            guard: O(
+              a("isTriggerItemHighlighted"),
+              a("isHighlightedItemEditable"),
+              "closeOnSelect",
+              "isOpenControlled"
+            ),
+            actions: ["invokeOnSelect", "setOptionState", "closeRootMenu", "invokeOnClose", "releaseParentRoutingLock"]
+          },
+          {
+            guard: O(a("isTriggerItemHighlighted"), a("isHighlightedItemEditable"), "closeOnSelect"),
+            target: "closed",
+            actions: [
+              "invokeOnSelect",
+              "setOptionState",
+              "closeRootMenu",
+              "invokeOnClose",
+              "releaseParentRoutingLock",
+              "focusTrigger"
+            ]
+          },
+          //
+          {
+            guard: O(a("isTriggerItemHighlighted"), a("isHighlightedItemEditable")),
+            actions: ["invokeOnSelect", "setOptionState"]
+          },
+          { actions: ["setHighlightedItem"] }
+        ],
+        TRIGGER_POINTERMOVE: {
+          guard: "isTriggerItem",
+          actions: ["setIntentPolygon"]
+        },
+        TRIGGER_POINTERLEAVE: {
+          target: "closing",
+          actions: ["setIntentPolygon"]
+        },
+        ITEM_POINTERDOWN: {
+          actions: ["setHighlightedItem"]
+        },
+        TYPEAHEAD: {
+          actions: ["highlightMatchedItem"]
+        },
+        FOCUS_MENU: {
+          actions: ["focusMenu"]
+        },
+        "POSITIONING.SET": {
+          actions: ["reposition"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      closeOnSelect: ({ prop: e, event: t }) => !!((t == null ? void 0 : t.closeOnSelect) ?? e("closeOnSelect")),
+      // whether the trigger is also a menu item
+      isTriggerItem: ({ event: e }) => f(e.target),
+      // whether the trigger item is the active item
+      isTriggerItemHighlighted: ({ event: e, scope: t, computed: n }) => {
+        const i = e.target ?? t.getById(n("highlightedId"));
+        return !!(i != null && i.hasAttribute("data-controls"));
+      },
+      isSubmenu: ({ context: e }) => e.get("isSubmenu"),
+      isPointerRoutingLocked: ({ refs: e }) => e.get("pointerRoutingLocked"),
+      isHighlightedItemEditable: ({ scope: e, computed: t }) => Q(e.getById(t("highlightedId"))),
+      // guard assertions (for controlled mode)
+      isOpenControlled: ({ prop: e }) => e("open") !== void 0,
+      isArrowLeftEvent: ({ event: e }) => {
+        var t;
+        return ((t = e.previousEvent) == null ? void 0 : t.type) === "ARROW_LEFT";
+      },
+      isArrowUpEvent: ({ event: e }) => {
+        var t;
+        return ((t = e.previousEvent) == null ? void 0 : t.type) === "ARROW_UP";
+      },
+      isArrowDownEvent: ({ event: e }) => {
+        var t;
+        return ((t = e.previousEvent) == null ? void 0 : t.type) === "ARROW_DOWN";
+      },
+      isOpenAutoFocusEvent: ({ event: e }) => {
+        var t;
+        return ((t = e.previousEvent) == null ? void 0 : t.type) === "OPEN_AUTOFOCUS";
+      }
+    },
+    effects: {
+      waitForOpenDelay({ send: e }) {
+        const t = setTimeout(() => {
+          e({ type: "DELAY.OPEN" });
+        }, 200);
+        return () => clearTimeout(t);
+      },
+      waitForCloseDelay({ send: e }) {
+        const t = setTimeout(() => {
+          e({ type: "DELAY.CLOSE" });
+        }, 100);
+        return () => clearTimeout(t);
+      },
+      waitForLongPress({ send: e }) {
+        const t = setTimeout(() => {
+          e({ type: "LONG_PRESS.OPEN" });
+        }, 700);
+        return () => clearTimeout(t);
+      },
+      trackFocusVisible({ scope: e }) {
+        var t;
+        return v({ root: (t = e.getRootNode) == null ? void 0 : t.call(e) });
+      },
+      trackPositioning({ context: e, prop: t, scope: n, refs: i }) {
+        if (w(n) || I(n).length > 0) return;
+        const r = {
+          ...t("positioning"),
+          ...i.get("positioningOverride")
+        };
+        return e.set("currentPlacement", r.placement), T(() => E(n, e.get("triggerValue")), () => P(n), {
+          ...r,
+          defer: !0,
+          onComplete(g) {
+            e.set("currentPlacement", g.placement);
+          }
+        });
+      },
+      trackInteractOutside({ refs: e, scope: t, prop: n, context: i, send: o }) {
+        const r = () => c(t);
+        let s = !0;
+        const u = (g) => I(t).some((l) => C(l, g));
+        return ne(r, {
+          type: "menu",
+          defer: !0,
+          exclude: [F(t), ...U(t)].filter(Boolean),
+          onInteractOutside: n("onInteractOutside"),
+          onRequestDismiss: n("onRequestDismiss"),
+          onFocusOutside(g) {
+            var d;
+            (d = n("onFocusOutside")) == null || d(g);
+            const l = L(g.detail.originalEvent);
+            if (u(l)) {
+              g.preventDefault();
+              return;
+            }
+            if (W(l, e.get("children"))) {
+              g.preventDefault();
+              return;
+            }
+          },
+          onEscapeKeyDown(g) {
+            var l;
+            (l = n("onEscapeKeyDown")) == null || l(g), i.get("isSubmenu") && g.preventDefault(), R({ parent: e.get("parent") });
+          },
+          onPointerDownOutside(g) {
+            var d;
+            (d = n("onPointerDownOutside")) == null || d(g);
+            const l = L(g.detail.originalEvent);
+            if (u(l) && g.detail.contextmenu) {
+              g.preventDefault();
+              return;
+            }
+            s = !g.detail.focusable;
+          },
+          onDismiss() {
+            o({ type: "CLOSE", src: "interact-outside", restoreFocus: s });
+          }
+        });
+      },
+      trackPointerMove({ context: e, scope: t, send: n, refs: i }) {
+        const o = i.get("parent");
+        if (!o) return;
+        m(o, !0);
+        const r = t.getDoc();
+        return te(r, "pointermove", (s) => {
+          Y(e.get("intentPolygon"), {
+            x: s.clientX,
+            y: s.clientY
+          }) || (n({ type: "POINTER_MOVED_AWAY_FROM_SUBMENU" }), m(o, !1));
+        });
+      },
+      scrollToHighlightedItem({ scope: e, computed: t }) {
+        const n = () => {
+          if (V() === "pointer") return;
+          const r = e.getById(t("highlightedId")), s = c(e);
+          re(r, { rootEl: s, block: "nearest" });
+        };
+        return p(() => {
+          S("virtual"), n();
+        }), ee(() => c(e), {
+          defer: !0,
+          attributes: ["aria-activedescendant"],
+          callback: n
+        });
+      }
+    },
+    actions: {
+      setAnchorPoint({ context: e, event: t }) {
+        e.set("anchorPoint", (n) => Z(n, t.point) ? n : t.point);
+      },
+      setSubmenuPlacement({ context: e, computed: t, refs: n }) {
+        if (!e.get("isSubmenu")) return;
+        const i = t("isRtl") ? "left-start" : "right-start";
+        n.set("positioningOverride", { placement: i, gutter: 0 });
+      },
+      reposition({ context: e, scope: t, prop: n, event: i, refs: o }) {
+        const r = () => P(t), s = i.point ?? e.get("anchorPoint"), u = s ? () => ({ width: 0, height: 0, ...s }) : void 0, g = {
+          ...n("positioning"),
+          ...o.get("positioningOverride")
+        }, l = i.value ?? e.get("triggerValue");
+        T(() => E(t, l), r, {
+          ...g,
+          defer: !0,
+          getAnchorRect: u,
+          ...i.options ?? {},
+          listeners: !1,
+          onComplete(k) {
+            e.set("currentPlacement", k.placement);
+          }
+        });
+      },
+      setOptionState({ event: e }) {
+        if (!e.option) return;
+        const { checked: t, onCheckedChange: n, type: i } = e.option;
+        i === "radio" ? n == null || n(!0) : i === "checkbox" && (n == null || n(!t));
+      },
+      clickHighlightedItem({ scope: e, computed: t, prop: n, context: i }) {
+        var s;
+        const o = e.getById(t("highlightedId"));
+        if (!o || o.dataset.disabled) return;
+        const r = i.get("highlightedValue");
+        J(o) ? (s = n("navigate")) == null || s({ value: r, node: o, href: o.href }) : queueMicrotask(() => o.click());
+      },
+      setIntentPolygon({ context: e, scope: t, event: n }) {
+        const i = c(t), o = e.get("currentPlacement");
+        if (!i || !o) return;
+        const r = i.getBoundingClientRect(), s = j(r, o);
+        if (!s) return;
+        const g = N(o) === "right" ? -5 : 5;
+        e.set("intentPolygon", [{ ...n.point, x: n.point.x + g }, ...s]);
+      },
+      clearIntentPolygon({ context: e }) {
+        e.set("intentPolygon", null);
+      },
+      clearAnchorPoint({ context: e }) {
+        e.set("anchorPoint", null);
+      },
+      unlockParentOnOpen({ refs: e, context: t, scope: n }) {
+        const i = e.get("parent");
+        if (t.get("isSubmenu")) {
+          const o = b(n);
+          i == null || i.send({ type: "HIGHLIGHTED.SUGGEST", value: o });
+        }
+        m(i, !1);
+      },
+      unlockParentOnClose({ refs: e, context: t }) {
+        x(e.get("parent"), t.get("isSubmenu"));
+      },
+      setHighlightedItem({ context: e, event: t }) {
+        const n = t.value || h(t.target);
+        e.set("highlightedValue", n);
+      },
+      clearHighlightedItem({ context: e }) {
+        e.set("highlightedValue", null);
+      },
+      focusMenu({ scope: e }) {
+        p(() => {
+          const t = c(e), n = z({
+            root: t,
+            enabled: !C(t, e.getActiveElement()),
+            filter(i) {
+              var o;
+              return !((o = i.role) != null && o.startsWith("menuitem"));
+            }
+          });
+          n == null || n.focus({ preventScroll: !0 });
+        });
+      },
+      highlightFirstItem({ context: e, scope: t }) {
+        (c(t) ? queueMicrotask : p)(() => {
+          const i = G(t);
+          i && e.set("highlightedValue", h(i));
+        });
+      },
+      highlightLastItem({ context: e, scope: t }) {
+        (c(t) ? queueMicrotask : p)(() => {
+          const i = _(t);
+          i && e.set("highlightedValue", h(i));
+        });
+      },
+      highlightNextItem({ context: e, scope: t, event: n, prop: i }) {
+        const o = D(t, {
+          loop: n.loop,
+          value: e.get("highlightedValue"),
+          loopFocus: i("loopFocus")
+        });
+        e.set("highlightedValue", h(o));
+      },
+      highlightPrevItem({ context: e, scope: t, event: n, prop: i }) {
+        const o = H(t, {
+          loop: n.loop,
+          value: e.get("highlightedValue"),
+          loopFocus: i("loopFocus")
+        });
+        e.set("highlightedValue", h(o));
+      },
+      invokeOnSelect({ context: e, prop: t, scope: n }) {
+        var r;
+        const i = e.get("highlightedValue");
+        if (i == null) return;
+        const o = M(n, i);
+        A(o, i), (r = t("onSelect")) == null || r({ value: i });
+      },
+      focusTrigger({ scope: e, context: t, event: n }) {
+        t.get("isSubmenu") || t.get("anchorPoint") || n.restoreFocus === !1 || queueMicrotask(() => {
+          const i = E(e, t.get("triggerValue"));
+          i == null || i.focus({ preventScroll: !0 });
+        });
+      },
+      highlightMatchedItem({ scope: e, context: t, event: n, refs: i }) {
+        const o = y(e, {
+          key: n.key,
+          value: t.get("highlightedValue"),
+          typeaheadState: i.get("typeaheadState")
+        });
+        o && t.set("highlightedValue", h(o));
+      },
+      setParentMenu({ refs: e, event: t, context: n }) {
+        e.set("parent", t.value), n.set("isSubmenu", !0);
+      },
+      setChildMenu({ refs: e, event: t }) {
+        const n = e.get("children");
+        n[t.id] = t.value, e.set("children", n);
+      },
+      closeSiblingMenus({ refs: e, event: t, scope: n }) {
+        var s;
+        const i = t.target;
+        if (!f(i)) return;
+        const o = i == null ? void 0 : i.getAttribute("data-uid"), r = e.get("children");
+        for (const u in r) {
+          if (u === o) continue;
+          const g = r[u], l = g.context.get("intentPolygon");
+          l && t.point && $(l, t.point) || ((s = c(n)) == null || s.focus({ preventScroll: !0 }), g.send({ type: "CLOSE" }));
+        }
+      },
+      closeRootMenu({ refs: e }) {
+        R({ parent: e.get("parent") });
+      },
+      openSubmenu({ refs: e, scope: t, computed: n }) {
+        const i = t.getById(n("highlightedId")), o = i == null ? void 0 : i.getAttribute("data-uid"), r = e.get("children"), s = o ? r[o] : null;
+        s == null || s.send({ type: "OPEN_AUTOFOCUS" });
+      },
+      focusParentMenu({ refs: e }) {
+        var t;
+        (t = e.get("parent")) == null || t.send({ type: "FOCUS_MENU" });
+      },
+      setLastHighlightedItem({ context: e, event: t }) {
+        e.set("lastHighlightedValue", h(t.target));
+      },
+      suggestHighlightedItem({ context: e, event: t }) {
+        const n = t.value;
+        if (n) {
+          if (e.get("highlightedValue") != null) {
+            e.set("lastHighlightedValue", n);
+            return;
+          }
+          e.set("highlightedValue", n);
+        }
+      },
+      restoreHighlightedItem({ context: e }) {
+        const t = e.get("lastHighlightedValue");
+        e.set("lastHighlightedValue", null), t && e.set("highlightedValue", t);
+      },
+      restoreParentHighlightedItem({ refs: e }) {
+        var t;
+        (t = e.get("parent")) == null || t.send({ type: "HIGHLIGHTED.RESTORE" });
+      },
+      invokeOnOpen({ prop: e }) {
+        var t;
+        (t = e("onOpenChange")) == null || t({ open: !0 });
+      },
+      invokeOnClose({ prop: e }) {
+        var t;
+        (t = e("onOpenChange")) == null || t({ open: !1 });
+      },
+      releaseParentRoutingLock({ refs: e, context: t }) {
+        t.get("isSubmenu") && B(e.get("parent"));
+      },
+      toggleVisibility({ prop: e, event: t, send: n }) {
+        n({
+          type: e("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
+          previousEvent: t
+        });
+      },
+      setTriggerValue({ context: e, event: t }) {
+        t.value !== void 0 && e.set("triggerValue", t.value);
+      }
+    }
+  }
+});
+export {
+  Le as machine
+};