@gxp-dev/app-ui 0.1.0

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Listbox/utils.js

@@ -0,0 +1,11 @@
+import { i as t } from "../../../../../ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.js";
+function d(i, f, s) {
+  return i === void 0 ? !1 : Array.isArray(i) ? i.some((o) => n(o, f, s)) : n(i, f, s);
+}
+function n(i, f, s) {
+  return i === void 0 || f === void 0 ? !1 : typeof i == "string" ? i === f : typeof s == "function" ? s(i, f) : typeof s == "string" ? (i == null ? void 0 : i[s]) === (f == null ? void 0 : f[s]) : t(i, f);
+}
+export {
+  n as compare,
+  d as valueComparator
+};

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuAnchor.js

@@ -0,0 +1,29 @@
+import { PopperAnchor_default as o } from "../Popper/PopperAnchor.js";
+import { defineComponent as n, openBlock as u, createBlock as a, unref as l, normalizeProps as p, guardReactiveProps as s, withCtx as _, renderSlot as c } from "vue";
+var f = /* @__PURE__ */ n({
+  __name: "MenuAnchor",
+  props: {
+    reference: {
+      type: null,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(e) {
+    const r = e;
+    return (t, d) => (u(), a(l(o), p(s(r)), {
+      default: _(() => [c(t.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), m = f;
+export {
+  m as MenuAnchor_default
+};

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuCheckboxItem.js

@@ -0,0 +1,50 @@
+import { useForwardProps as p } from "../shared/useForwardProps.js";
+import { isIndeterminate as l, getCheckedState as c } from "./utils.js";
+import { MenuItem_default as f } from "./MenuItem.js";
+import { provideMenuItemIndicatorContext as _ } from "./MenuItemIndicator.js";
+import { defineComponent as k, openBlock as x, createBlock as h, mergeProps as v, unref as e, withCtx as C, renderSlot as V } from "vue";
+import { useVModel as y } from "../../../../../@vueuse_core@14.3.0_vue@3.5.35_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import { reactiveOmit as I } from "../../../../../@vueuse_shared@14.3.0_vue@3.5.35_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+var g = /* @__PURE__ */ k({
+  __name: "MenuCheckboxItem",
+  props: {
+    modelValue: {
+      type: [Boolean, String],
+      required: !1,
+      default: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["select", "update:modelValue"],
+  setup(u, { emit: d }) {
+    const r = u, o = d, m = I(r, ["modelValue"]), s = p(m), t = y(r, "modelValue", o);
+    return _({ modelValue: t }), (i, a) => (x(), h(f, v({ role: "menuitemcheckbox" }, e(s), {
+      "aria-checked": e(l)(e(t)) ? "mixed" : e(t),
+      "data-state": e(c)(e(t)),
+      onSelect: a[0] || (a[0] = async (n) => {
+        o("select", n), e(l)(e(t)) ? t.value = !0 : t.value = !e(t);
+      })
+    }), {
+      default: C(() => [V(i.$slots, "default", { modelValue: e(t) })]),
+      _: 3
+    }, 16, ["aria-checked", "data-state"]));
+  }
+}), F = g;
+export {
+  F as MenuCheckboxItem_default
+};

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuContent.js

@@ -0,0 +1,130 @@
+import { useForwardPropsEmits as y } from "../shared/useForwardPropsEmits.js";
+import { Presence_default as m } from "../Presence/Presence.js";
+import { injectMenuContext as c, injectMenuRootContext as q } from "./MenuRoot.js";
+import { MenuRootContentModal_default as _ } from "./MenuRootContentModal.js";
+import { MenuRootContentNonModal_default as B } from "./MenuRootContentNonModal.js";
+import { defineComponent as C, openBlock as o, createBlock as r, unref as t, withCtx as n, normalizeProps as l, mergeProps as a, renderSlot as s } from "vue";
+var g = /* @__PURE__ */ C({
+  __name: "MenuContent",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: !1
+    },
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    sideFlip: {
+      type: Boolean,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    alignFlip: {
+      type: Boolean,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: !1
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: !1
+    },
+    reference: {
+      type: null,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "entryFocus",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(u, { emit: d }) {
+    const i = y(u, d), p = c(), f = q();
+    return (e, P) => (o(), r(t(m), { present: e.forceMount || t(p).open.value }, {
+      default: n(() => [t(f).modal.value ? (o(), r(_, l(a({ key: 0 }, {
+        ...e.$attrs,
+        ...t(i)
+      })), {
+        default: n(() => [s(e.$slots, "default")]),
+        _: 3
+      }, 16)) : (o(), r(B, l(a({ key: 1 }, {
+        ...e.$attrs,
+        ...t(i)
+      })), {
+        default: n(() => [s(e.$slots, "default")]),
+        _: 3
+      }, 16))]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), k = g;
+export {
+  k as MenuContent_default
+};

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuContentImpl.js

@@ -0,0 +1,306 @@
+import { createContext as Q } from "../shared/createContext.js";
+import { getActiveElement as F } from "../shared/getActiveElement.js";
+import { useArrowNavigation as B } from "../shared/useArrowNavigation.js";
+import { useBodyScrollLock as Z } from "../shared/useBodyScrollLock.js";
+import { useFocusGuards as x } from "../shared/useFocusGuards.js";
+import { useForwardExpose as _ } from "../shared/useForwardExpose.js";
+import { useTypeahead as ee } from "../shared/useTypeahead.js";
+import { DismissableLayer_default as te } from "../DismissableLayer/DismissableLayer.js";
+import { FocusScope_default as oe } from "../FocusScope/FocusScope.js";
+import { getOpenState as ie, isPointerInGraceArea as re, isMouseEvent as E, FIRST_LAST_KEYS as ne, LAST_KEYS as ae, focusFirst as se } from "./utils.js";
+import { PopperContent_default as ue, PopperContentPropsDefaultValue as le } from "../Popper/PopperContent.js";
+import { RovingFocusGroup_default as de } from "../RovingFocus/RovingFocusGroup.js";
+import { injectMenuContext as fe, injectMenuRootContext as pe } from "./MenuRoot.js";
+import { defineComponent as ce, toRefs as me, ref as r, watch as K, onUnmounted as ye, openBlock as ge, createBlock as ve, unref as i, withCtx as c, createVNode as b, renderSlot as we, mergeDefaults as he } from "vue";
+const [Re, Fe] = /* @__PURE__ */ Q("MenuContent");
+var be = /* @__PURE__ */ ce({
+  __name: "MenuContentImpl",
+  props: /* @__PURE__ */ he({
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: !1
+    },
+    disableOutsideScroll: {
+      type: Boolean,
+      required: !1
+    },
+    trapFocus: {
+      type: Boolean,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    sideFlip: {
+      type: Boolean,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    alignFlip: {
+      type: Boolean,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: !1
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: !1
+    },
+    reference: {
+      type: null,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  }, { ...le }),
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "entryFocus",
+    "openAutoFocus",
+    "closeAutoFocus",
+    "dismiss"
+  ],
+  setup(M, { emit: A }) {
+    const R = M, s = A, C = fe(), a = pe(), { trapFocus: N, disableOutsidePointerEvents: P, loop: m } = me(R);
+    x(), Z(P.value);
+    const S = r(""), q = r(0), G = r(0), y = r(null), O = r("right"), g = r(0), v = r(null), D = r(), { forwardRef: L, currentElement: u } = _(), { handleTypeaheadSearch: U } = ee(), l = r();
+    function X(e) {
+      const t = B(e, l.value || F(), u.value, {
+        loop: m.value,
+        arrowKeyOptions: "vertical",
+        dir: a == null ? void 0 : a.dir.value,
+        focus: !1,
+        attributeName: "[data-reka-collection-item]:not([data-disabled])"
+      });
+      t && (l.value = t, t.scrollIntoView({ block: "nearest" }));
+    }
+    function j() {
+      l.value && l.value.click();
+    }
+    const f = r(), d = r();
+    K(l, (e) => {
+      d.value && (e === void 0 || e !== d.value.trigger.value) && (d.value.onOpenChange(!1), d.value = void 0);
+    }), K(u, (e) => {
+      C.onContentChange(e);
+    }), ye(() => {
+      window.clearTimeout(q.value);
+    });
+    function w(e) {
+      var o, n;
+      return O.value === ((o = y.value) == null ? void 0 : o.side) && re(e, (n = y.value) == null ? void 0 : n.area);
+    }
+    async function z(e) {
+      var t;
+      s("openAutoFocus", e), !e.defaultPrevented && (e.preventDefault(), (t = u.value) == null || t.focus({ preventScroll: !0 }));
+    }
+    function V(e) {
+      var k;
+      if (e.defaultPrevented) return;
+      const t = e.target, o = t.closest("[data-reka-menu-content]") === e.currentTarget, n = ["input", "textarea"].includes(t.tagName.toLowerCase()), h = e.ctrlKey || e.altKey || e.metaKey, H = e.key.length === 1, p = B(e, F(), u.value, {
+        loop: m.value,
+        arrowKeyOptions: "vertical",
+        dir: a == null ? void 0 : a.dir.value,
+        focus: !0,
+        attributeName: "[data-reka-collection-item]:not([data-disabled])"
+      });
+      if (p) return p == null ? void 0 : p.focus();
+      if (e.code === "Space") return;
+      const I = ((k = D.value) == null ? void 0 : k.getItems()) ?? [];
+      if (o && (e.key === "Tab" && e.preventDefault(), !h && H && !n && U(e.key, I)), e.target !== u.value || !ne.includes(e.key)) return;
+      e.preventDefault();
+      const T = [...I.map((J) => J.ref)];
+      ae.includes(e.key) && T.reverse(), se(T);
+    }
+    function W(e) {
+      var t, o;
+      (o = (t = e == null ? void 0 : e.currentTarget) == null ? void 0 : t.contains) != null && o.call(t, e.target) || (window.clearTimeout(q.value), S.value = "");
+    }
+    function Y(e) {
+      var n;
+      if (!E(e)) return;
+      const t = e.target, o = g.value !== e.clientX;
+      if ((n = e == null ? void 0 : e.currentTarget) != null && n.contains(t) && o) {
+        const h = e.clientX > g.value ? "right" : "left";
+        O.value = h, g.value = e.clientX;
+      }
+    }
+    function $(e) {
+      E(e) && f.value && f.value.focus();
+    }
+    return Fe({
+      onItemEnter: (e) => !!w(e),
+      onItemLeave: (e) => {
+        var o, n;
+        return w(e) ? !0 : (["INPUT", "TEXTAREA"].includes(((o = F()) == null ? void 0 : o.tagName) || "") || (n = u.value) == null || n.focus(), v.value = null, !1);
+      },
+      onTriggerLeave: (e) => !!w(e),
+      searchRef: S,
+      highlightedElement: l,
+      onKeydownNavigation: X,
+      onKeydownEnter: j,
+      filterElement: f,
+      onFilterElementChange: (e) => {
+        f.value = e;
+      },
+      activeSubmenuContext: d,
+      pointerGraceTimerRef: G,
+      onPointerGraceIntentChange: (e) => {
+        y.value = e;
+      }
+    }), (e, t) => (ge(), ve(i(oe), {
+      "as-child": "",
+      trapped: i(N),
+      onMountAutoFocus: z,
+      onUnmountAutoFocus: t[7] || (t[7] = (o) => s("closeAutoFocus", o))
+    }, {
+      default: c(() => [b(i(te), {
+        "as-child": "",
+        "disable-outside-pointer-events": i(P),
+        onEscapeKeyDown: t[2] || (t[2] = (o) => s("escapeKeyDown", o)),
+        onPointerDownOutside: t[3] || (t[3] = (o) => s("pointerDownOutside", o)),
+        onFocusOutside: t[4] || (t[4] = (o) => s("focusOutside", o)),
+        onInteractOutside: t[5] || (t[5] = (o) => s("interactOutside", o)),
+        onDismiss: t[6] || (t[6] = (o) => s("dismiss"))
+      }, {
+        default: c(() => [b(i(de), {
+          ref_key: "rovingFocusGroupRef",
+          ref: D,
+          "current-tab-stop-id": v.value,
+          "onUpdate:currentTabStopId": t[0] || (t[0] = (o) => v.value = o),
+          "as-child": "",
+          orientation: "vertical",
+          dir: i(a).dir.value,
+          loop: i(m),
+          onEntryFocus: t[1] || (t[1] = (o) => {
+            s("entryFocus", o), i(a).isUsingKeyboardRef.value || o.preventDefault();
+          })
+        }, {
+          default: c(() => [b(i(ue), {
+            ref: i(L),
+            role: "menu",
+            as: e.as,
+            "as-child": e.asChild,
+            "aria-orientation": "vertical",
+            "data-reka-menu-content": "",
+            "data-state": i(ie)(i(C).open.value),
+            dir: i(a).dir.value,
+            side: e.side,
+            "side-offset": e.sideOffset,
+            align: e.align,
+            "align-offset": e.alignOffset,
+            "avoid-collisions": e.avoidCollisions,
+            "collision-boundary": e.collisionBoundary,
+            "collision-padding": e.collisionPadding,
+            "arrow-padding": e.arrowPadding,
+            "prioritize-position": e.prioritizePosition,
+            "position-strategy": e.positionStrategy,
+            "update-position-strategy": e.updatePositionStrategy,
+            sticky: e.sticky,
+            "hide-when-detached": e.hideWhenDetached,
+            reference: e.reference,
+            onKeydown: V,
+            onBlur: W,
+            onPointermove: Y,
+            onPointerenter: $
+          }, {
+            default: c(() => [we(e.$slots, "default")]),
+            _: 3
+          }, 8, [
+            "as",
+            "as-child",
+            "data-state",
+            "dir",
+            "side",
+            "side-offset",
+            "align",
+            "align-offset",
+            "avoid-collisions",
+            "collision-boundary",
+            "collision-padding",
+            "arrow-padding",
+            "prioritize-position",
+            "position-strategy",
+            "update-position-strategy",
+            "sticky",
+            "hide-when-detached",
+            "reference"
+          ])]),
+          _: 3
+        }, 8, [
+          "current-tab-stop-id",
+          "dir",
+          "loop"
+        ])]),
+        _: 3
+      }, 8, ["disable-outside-pointer-events"])]),
+      _: 3
+    }, 8, ["trapped"]));
+  }
+}), Ne = be;
+export {
+  Ne as MenuContentImpl_default,
+  Re as injectMenuContentContext
+};

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuGroup.js

@@ -0,0 +1,29 @@
+import { createContext as p } from "../shared/createContext.js";
+import { useId as n } from "../shared/useId.js";
+import { Primitive as a } from "../Primitive/Primitive.js";
+import { defineComponent as l, openBlock as i, createBlock as s, unref as r, mergeProps as d, withCtx as m, renderSlot as _ } from "vue";
+const [y, f] = /* @__PURE__ */ p("MenuGroup");
+var c = /* @__PURE__ */ l({
+  __name: "MenuGroup",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(o) {
+    const t = o, e = n(void 0, "reka-menu-group");
+    return f({ id: e }), (u, v) => (i(), s(r(a), d({ role: "group" }, t, { "aria-labelledby": r(e) }), {
+      default: m(() => [_(u.$slots, "default")]),
+      _: 3
+    }, 16, ["aria-labelledby"]));
+  }
+}), b = c;
+export {
+  b as MenuGroup_default,
+  y as injectMenuGroupContext
+};

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuItem.js

@@ -0,0 +1,63 @@
+import { useForwardExpose as v } from "../shared/useForwardExpose.js";
+import { SELECTION_KEYS as E, ITEM_SELECT as w } from "./utils.js";
+import { injectMenuRootContext as _ } from "./MenuRoot.js";
+import { injectMenuContentContext as k } from "./MenuContentImpl.js";
+import { MenuItemImpl_default as x } from "./MenuItemImpl.js";
+import { defineComponent as I, ref as b, openBlock as M, createBlock as S, mergeProps as T, unref as l, nextTick as i, withCtx as g, renderSlot as P } from "vue";
+var q = /* @__PURE__ */ I({
+  __name: "MenuItem",
+  props: {
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["select"],
+  setup(a, { emit: f }) {
+    const u = a, d = f, { forwardRef: m, currentElement: p } = v(), c = _(), C = k(), o = b(!1);
+    async function y() {
+      const n = p.value;
+      if (!u.disabled && n) {
+        const e = new CustomEvent(w, {
+          bubbles: !0,
+          cancelable: !0
+        });
+        d("select", e), await i(), e.defaultPrevented ? o.value = !1 : c.onClose();
+      }
+    }
+    return (n, e) => (M(), S(x, T(u, {
+      ref: l(m),
+      onClick: y,
+      onPointerdown: e[0] || (e[0] = () => {
+        o.value = !0;
+      }),
+      onPointerup: e[1] || (e[1] = async (t) => {
+        var r;
+        await i(), !t.defaultPrevented && (o.value || (r = t.currentTarget) == null || r.click());
+      }),
+      onKeydown: e[2] || (e[2] = async (t) => {
+        var s;
+        const r = l(C).searchRef.value !== "";
+        n.disabled || r && t.key === " " || l(E).includes(t.key) && ((s = t.currentTarget) == null || s.click(), t.preventDefault());
+      })
+    }), {
+      default: g(() => [P(n.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), A = q;
+export {
+  A as MenuItem_default
+};

package/dist/node_modules/.pnpm/reka-ui@2.9.8_vue@3.5.35_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuItemImpl.js

@@ -0,0 +1,80 @@
+import { getActiveElement as E } from "../shared/getActiveElement.js";
+import { useForwardExpose as I } from "../shared/useForwardExpose.js";
+import { Primitive as P } from "../Primitive/Primitive.js";
+import { isMouseEvent as d } from "./utils.js";
+import { useCollection as b } from "../Collection/Collection.js";
+import { injectMenuContentContext as y } from "./MenuContentImpl.js";
+import { defineComponent as C, ref as M, computed as T, openBlock as w, createBlock as B, unref as r, withCtx as s, createVNode as F, mergeProps as S, nextTick as o, renderSlot as q } from "vue";
+var A = /* @__PURE__ */ C({
+  inheritAttrs: !1,
+  __name: "MenuItemImpl",
+  props: {
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(f) {
+    const m = f, t = y(), { forwardRef: v, currentElement: l } = I(), { CollectionItem: h } = b(), n = M(!1), p = T(() => n.value || l.value != null && t.highlightedElement.value === l.value);
+    async function c(e) {
+      var a;
+      if (!(e.defaultPrevented || !d(e))) {
+        if (m.disabled) t.onItemLeave(e);
+        else if (!t.onItemEnter(e)) {
+          const u = e.currentTarget;
+          t.highlightedElement.value = u, ["INPUT", "TEXTAREA"].includes(((a = E()) == null ? void 0 : a.tagName) || "") || u.focus({ preventScroll: !0 });
+        }
+      }
+    }
+    async function g(e) {
+      if (await o(), e.defaultPrevented || !d(e) || t.highlightedElement.value !== l.value) return;
+      !t.onItemLeave(e) && t.highlightedElement.value === l.value && (t.highlightedElement.value = void 0);
+    }
+    return (e, a) => (w(), B(r(h), { value: { textValue: e.textValue } }, {
+      default: s(() => [F(r(P), S({
+        ref: r(v),
+        role: "menuitem",
+        tabindex: "-1"
+      }, e.$attrs, {
+        as: e.as,
+        "as-child": e.asChild,
+        "aria-disabled": e.disabled || void 0,
+        "data-disabled": e.disabled ? "" : void 0,
+        "data-highlighted": p.value ? "" : void 0,
+        onPointermove: c,
+        onPointerleave: g,
+        onFocus: a[0] || (a[0] = async (i) => {
+          await o(), !(i.defaultPrevented || e.disabled) && (n.value = !0, r(t).highlightedElement.value = i.currentTarget);
+        }),
+        onBlur: a[1] || (a[1] = async (i) => {
+          await o(), !i.defaultPrevented && (n.value = !1);
+        })
+      }), {
+        default: s(() => [q(e.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "as",
+        "as-child",
+        "aria-disabled",
+        "data-disabled",
+        "data-highlighted"
+      ])]),
+      _: 3
+    }, 8, ["value"]));
+  }
+}), j = A;
+export {
+  j as MenuItemImpl_default
+};