@serendie/ui 3.2.0 → 3.2.1-dev.202604251106

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

@@ -0,0 +1,936 @@
+import { deriveSelectionState as f, resolveSelectedItems as P, createSelectedItemMap as A } from "../../collection/dist/selection-map.js";
+import { setInteractionModality as M, trackFocusVisible as U, getInteractionModality as x } from "../../focus-visible/dist/index.js";
+import { createLiveRegion as D } from "../../live-region/dist/index.js";
+import { getPlacement as T } from "../../popper/dist/get-placement.js";
+import { collection as _ } from "./combobox.collection.js";
+import { getInputEl as C, getContentEl as I, getItemEl as V, getTriggerEl as E, focusInputEl as S, focusTriggerEl as G, getPositionerEl as F, getControlEl as N, getClearTriggerEl as B } from "./combobox.dom.js";
+import { isApple as w } from "../../dom-query/dist/platform.js";
+import { match as h } from "../../utils/dist/functions.js";
+import { raf as g, nextTick as b } from "../../dom-query/dist/raf.js";
+import { setCaretToEnd as W } from "../../dom-query/dist/caret.js";
+import { remove as K, addOrRemove as H } from "../../utils/dist/array.js";
+import { observeAttributes as Y } from "../../dom-query/dist/mutation-observer.js";
+import { trackDismissableElement as q } from "../../dismissable/dist/dismissable-layer.js";
+import { isBoolean as j } from "../../utils/dist/guard.js";
+import { isEqual as z } from "../../utils/dist/equal.js";
+import { clickIfLink as $ } from "../../dom-query/dist/navigate.js";
+import { setup as J } from "../../core/dist/create-machine.js";
+import { scrollIntoView as k } from "../../dom-query/dist/overflow.js";
+var { guards: Q, createMachine: X, choose: Z } = J(), { and: c, not: m } = Q, ve = X({
+  props({ props: e }) {
+    return {
+      loopFocus: !0,
+      openOnClick: !1,
+      defaultValue: [],
+      defaultInputValue: "",
+      closeOnSelect: !e.multiple,
+      allowCustomValue: !1,
+      alwaysSubmitOnEnter: !1,
+      inputBehavior: "none",
+      selectionBehavior: e.multiple ? "clear" : "replace",
+      openOnKeyPress: !0,
+      openOnChange: !0,
+      composite: !0,
+      navigate({ node: t }) {
+        $(t);
+      },
+      collection: _.empty(),
+      ...e,
+      positioning: {
+        placement: "bottom",
+        sameWidth: !0,
+        ...e.positioning
+      },
+      translations: {
+        triggerLabel: "Toggle suggestions",
+        clearTriggerLabel: "Clear value",
+        ...e.translations
+      }
+    };
+  },
+  initialState({ prop: e }) {
+    return e("open") || e("defaultOpen") ? "open.suggesting" : "closed.idle";
+  },
+  context({ prop: e, bindable: t, getContext: l, getEvent: i }) {
+    const n = e("value") ?? e("defaultValue") ?? [], a = e("collection").findMany(n);
+    return {
+      currentPlacement: t(() => ({
+        defaultValue: void 0
+      })),
+      value: t(() => ({
+        defaultValue: e("defaultValue"),
+        value: e("value"),
+        isEqual: z,
+        hash(o) {
+          return o.join(",");
+        },
+        onChange(o) {
+          var O;
+          const s = l(), u = e("collection"), p = s.get("selectedItemMap"), r = f({
+            values: o,
+            collection: u,
+            selectedItemMap: p
+          }), d = e("value") ?? o, v = d === o ? r : f({
+            values: d,
+            collection: u,
+            selectedItemMap: r.nextSelectedItemMap
+          });
+          s.set("selectedItemMap", v.nextSelectedItemMap), (O = e("onValueChange")) == null || O({ value: o, items: r.selectedItems });
+        }
+      })),
+      highlightedValue: t(() => ({
+        defaultValue: e("defaultHighlightedValue") || null,
+        value: e("highlightedValue"),
+        onChange(o) {
+          var u;
+          const s = e("collection").find(o);
+          (u = e("onHighlightChange")) == null || u({ highlightedValue: o, highlightedItem: s });
+        }
+      })),
+      inputValue: t(() => {
+        let o = e("inputValue") || e("defaultInputValue");
+        const s = e("value") || e("defaultValue");
+        if (!o.trim() && !e("multiple")) {
+          const u = e("collection").stringifyMany(s);
+          o = h(e("selectionBehavior"), {
+            preserve: o || u,
+            replace: u,
+            clear: ""
+          });
+        }
+        return {
+          defaultValue: o,
+          value: e("inputValue"),
+          onChange(u) {
+            var d;
+            const p = i(), r = (p.previousEvent || p).src;
+            (d = e("onInputValueChange")) == null || d({ inputValue: u, reason: r });
+          }
+        };
+      }),
+      highlightedItem: t(() => {
+        const o = e("highlightedValue");
+        return { defaultValue: e("collection").find(o) };
+      }),
+      selectedItemMap: t(() => ({
+        defaultValue: A({
+          selectedItems: a,
+          collection: e("collection")
+        })
+      }))
+    };
+  },
+  computed: {
+    isInputValueEmpty: ({ context: e }) => e.get("inputValue").length === 0,
+    isInteractive: ({ prop: e }) => !(e("readOnly") || e("disabled")),
+    autoComplete: ({ prop: e }) => e("inputBehavior") === "autocomplete",
+    autoHighlight: ({ prop: e }) => e("inputBehavior") === "autohighlight",
+    hasSelectedItems: ({ context: e }) => e.get("value").length > 0,
+    selectedItems: ({ context: e, prop: t }) => P({
+      values: e.get("value"),
+      collection: t("collection"),
+      selectedItemMap: e.get("selectedItemMap")
+    }),
+    valueAsString: ({ computed: e, prop: t }) => t("collection").stringifyItems(e("selectedItems")),
+    isCustomValue: ({ context: e, computed: t }) => e.get("inputValue") !== t("valueAsString")
+  },
+  watch({ context: e, prop: t, track: l, action: i, send: n }) {
+    l([() => e.hash("value")], () => {
+      i(["syncSelectedItems"]);
+    }), l([() => e.get("inputValue")], () => {
+      i(["syncInputValue"]);
+    }), l([() => e.get("highlightedValue")], () => {
+      i(["syncHighlightedItem", "autofillInputValue", "announceHighlightedItem"]);
+    }), l([() => t("open")], () => {
+      i(["toggleVisibility"]);
+    }), l([() => t("collection").toString()], () => {
+      n({ type: "CHILDREN_CHANGE" });
+    });
+  },
+  on: {
+    "SELECTED_ITEMS.SYNC": {
+      actions: ["syncSelectedItems"]
+    },
+    "HIGHLIGHTED_VALUE.SET": {
+      actions: ["setHighlightedValue"]
+    },
+    "HIGHLIGHTED_VALUE.CLEAR": {
+      actions: ["clearHighlightedValue"]
+    },
+    "ITEM.SELECT": {
+      actions: ["selectItem"]
+    },
+    "ITEM.CLEAR": {
+      actions: ["clearItem"]
+    },
+    "VALUE.SET": {
+      actions: ["setValue"]
+    },
+    "INPUT_VALUE.SET": {
+      actions: ["setInputValue"]
+    },
+    "POSITIONING.SET": {
+      actions: ["reposition"]
+    }
+  },
+  entry: Z([
+    {
+      guard: "autoFocus",
+      actions: ["setInitialFocus"]
+    }
+  ]),
+  states: {
+    closed: {
+      tags: ["closed"],
+      initial: "idle",
+      states: {
+        idle: {
+          tags: ["idle"],
+          entry: ["scrollContentToTop", "clearHighlightedValue"],
+          on: {
+            "CONTROLLED.OPEN": {
+              target: "open.interacting"
+            },
+            "TRIGGER.CLICK": [
+              {
+                guard: "isOpenControlled",
+                actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
+              }
+            ],
+            "INPUT.CLICK": [
+              {
+                guard: "isOpenControlled",
+                actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
+              }
+            ],
+            "INPUT.FOCUS": {
+              target: "focused"
+            },
+            OPEN: [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["invokeOnOpen"]
+              }
+            ],
+            "VALUE.CLEAR": {
+              target: "focused",
+              actions: ["clearInputValue", "clearSelectedItems", "setInitialFocus"]
+            }
+          }
+        },
+        focused: {
+          tags: ["focused"],
+          entry: ["scrollContentToTop", "clearHighlightedValue"],
+          on: {
+            "CONTROLLED.OPEN": [
+              {
+                guard: "isChangeEvent",
+                target: "open.suggesting"
+              },
+              {
+                target: "open.interacting"
+              }
+            ],
+            "INPUT.CHANGE": [
+              {
+                guard: c("isOpenControlled", "openOnChange"),
+                actions: ["setInputValue", "invokeOnOpen", "highlightFirstItemIfNeeded"]
+              },
+              {
+                guard: "openOnChange",
+                target: "open.suggesting",
+                actions: ["setInputValue", "invokeOnOpen", "highlightFirstItemIfNeeded"]
+              },
+              {
+                actions: ["setInputValue"]
+              }
+            ],
+            "LAYER.INTERACT_OUTSIDE": {
+              target: "idle"
+            },
+            "INPUT.ESCAPE": {
+              guard: c("isCustomValue", m("allowCustomValue")),
+              actions: ["revertInputValue"]
+            },
+            "INPUT.BLUR": {
+              target: "idle"
+            },
+            "INPUT.CLICK": [
+              {
+                guard: "isOpenControlled",
+                actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
+              }
+            ],
+            "TRIGGER.CLICK": [
+              {
+                guard: "isOpenControlled",
+                actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
+              }
+            ],
+            "INPUT.ARROW_DOWN": [
+              // == group 1 ==
+              {
+                guard: c("isOpenControlled", "autoComplete"),
+                actions: ["invokeOnOpen"]
+              },
+              {
+                guard: "autoComplete",
+                target: "open.interacting",
+                actions: ["invokeOnOpen"]
+              },
+              // == group 2 ==
+              {
+                guard: "isOpenControlled",
+                actions: ["highlightFirstOrSelectedItem", "invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["highlightFirstOrSelectedItem", "invokeOnOpen"]
+              }
+            ],
+            "INPUT.ARROW_UP": [
+              // == group 1 ==
+              {
+                guard: c("isOpenControlled", "autoComplete"),
+                actions: ["invokeOnOpen"]
+              },
+              {
+                guard: "autoComplete",
+                target: "open.interacting",
+                actions: ["invokeOnOpen"]
+              },
+              // == group 2 ==
+              {
+                guard: "isOpenControlled",
+                actions: ["highlightLastOrSelectedItem", "invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["highlightLastOrSelectedItem", "invokeOnOpen"]
+              }
+            ],
+            OPEN: [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnOpen"]
+              },
+              {
+                target: "open.interacting",
+                actions: ["invokeOnOpen"]
+              }
+            ],
+            "VALUE.CLEAR": {
+              actions: ["clearInputValue", "clearSelectedItems"]
+            }
+          }
+        }
+      }
+    },
+    open: {
+      tags: ["open", "focused"],
+      entry: ["setInitialFocus"],
+      effects: [
+        "trackFocusVisible",
+        "scrollToHighlightedItem",
+        "trackDismissableLayer",
+        "trackPlacement",
+        "trackLiveRegion"
+      ],
+      on: {
+        "CONTROLLED.CLOSE": [
+          {
+            guard: "restoreFocus",
+            target: "closed.focused",
+            actions: ["setFinalFocus"]
+          },
+          {
+            target: "closed.idle"
+          }
+        ],
+        "INPUT.ENTER": [
+          // == group 1 ==
+          {
+            guard: c("isOpenControlled", "isCustomValue", m("hasHighlightedItem"), m("allowCustomValue")),
+            actions: ["revertInputValue", "invokeOnClose"]
+          },
+          {
+            guard: c("isCustomValue", m("hasHighlightedItem"), m("allowCustomValue")),
+            target: "closed.focused",
+            actions: ["revertInputValue", "invokeOnClose"]
+          },
+          // == group 2 ==
+          {
+            guard: c("isOpenControlled", "closeOnSelect"),
+            actions: ["selectHighlightedItem", "invokeOnClose"]
+          },
+          {
+            guard: "closeOnSelect",
+            target: "closed.focused",
+            actions: ["selectHighlightedItem", "invokeOnClose", "setFinalFocus"]
+          },
+          {
+            actions: ["selectHighlightedItem"]
+          }
+        ],
+        "ITEM.CLICK": [
+          {
+            guard: c("isOpenControlled", "closeOnSelect"),
+            actions: ["selectItem", "invokeOnClose"]
+          },
+          {
+            guard: "closeOnSelect",
+            target: "closed.focused",
+            actions: ["selectItem", "invokeOnClose", "setFinalFocus"]
+          },
+          {
+            actions: ["selectItem"]
+          }
+        ],
+        "TRIGGER.CLICK": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed.focused",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "LAYER.INTERACT_OUTSIDE": [
+          // == group 1 ==
+          {
+            guard: c("isOpenControlled", "isCustomValue", m("allowCustomValue")),
+            actions: ["revertInputValue", "invokeOnClose"]
+          },
+          {
+            guard: c("isCustomValue", m("allowCustomValue")),
+            target: "closed.idle",
+            actions: ["revertInputValue", "invokeOnClose"]
+          },
+          // == group 2 ==
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed.idle",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        CLOSE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed.focused",
+            actions: ["invokeOnClose", "setFinalFocus"]
+          }
+        ],
+        "VALUE.CLEAR": [
+          {
+            guard: "isOpenControlled",
+            actions: ["clearInputValue", "clearSelectedItems", "invokeOnClose"]
+          },
+          {
+            target: "closed.focused",
+            actions: ["clearInputValue", "clearSelectedItems", "invokeOnClose", "setFinalFocus"]
+          }
+        ]
+      },
+      initial: "interacting",
+      states: {
+        interacting: {
+          on: {
+            CHILDREN_CHANGE: [
+              {
+                guard: "isHighlightedItemRemoved",
+                actions: ["clearHighlightedValue"]
+              },
+              {
+                actions: ["scrollToHighlightedItem"]
+              }
+            ],
+            "INPUT.HOME": {
+              actions: ["highlightFirstItem"]
+            },
+            "INPUT.END": {
+              actions: ["highlightLastItem"]
+            },
+            "INPUT.ARROW_DOWN": [
+              {
+                guard: c("autoComplete", "isLastItemHighlighted"),
+                actions: ["clearHighlightedValue", "scrollContentToTop"]
+              },
+              {
+                actions: ["highlightNextItem"]
+              }
+            ],
+            "INPUT.ARROW_UP": [
+              {
+                guard: c("autoComplete", "isFirstItemHighlighted"),
+                actions: ["clearHighlightedValue"]
+              },
+              {
+                actions: ["highlightPrevItem"]
+              }
+            ],
+            "INPUT.CHANGE": [
+              {
+                guard: "autoComplete",
+                target: "suggesting",
+                actions: ["setInputValue"]
+              },
+              {
+                target: "suggesting",
+                actions: ["clearHighlightedValue", "setInputValue"]
+              }
+            ],
+            "ITEM.POINTER_MOVE": {
+              actions: ["setHighlightedValue"]
+            },
+            "ITEM.POINTER_LEAVE": {
+              actions: ["clearHighlightedValue"]
+            },
+            "LAYER.ESCAPE": [
+              {
+                guard: c("isOpenControlled", "autoComplete"),
+                actions: ["syncInputValue", "invokeOnClose"]
+              },
+              {
+                guard: "autoComplete",
+                target: "closed.focused",
+                actions: ["syncInputValue", "invokeOnClose"]
+              },
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnClose"]
+              },
+              {
+                target: "closed.focused",
+                actions: ["invokeOnClose", "setFinalFocus"]
+              }
+            ]
+          }
+        },
+        suggesting: {
+          on: {
+            CHILDREN_CHANGE: [
+              {
+                guard: c("isHighlightedItemRemoved", "hasCollectionItems", "autoHighlight"),
+                actions: ["clearHighlightedValue", "highlightFirstItem"]
+              },
+              {
+                guard: "isHighlightedItemRemoved",
+                actions: ["clearHighlightedValue"]
+              },
+              {
+                guard: "autoHighlight",
+                actions: ["highlightFirstItem"]
+              }
+            ],
+            "INPUT.ARROW_DOWN": {
+              target: "interacting",
+              actions: ["highlightNextItem"]
+            },
+            "INPUT.ARROW_UP": {
+              target: "interacting",
+              actions: ["highlightPrevItem"]
+            },
+            "INPUT.HOME": {
+              target: "interacting",
+              actions: ["highlightFirstItem"]
+            },
+            "INPUT.END": {
+              target: "interacting",
+              actions: ["highlightLastItem"]
+            },
+            "INPUT.CHANGE": {
+              actions: ["setInputValue"]
+            },
+            "LAYER.ESCAPE": [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnClose"]
+              },
+              {
+                target: "closed.focused",
+                actions: ["invokeOnClose"]
+              }
+            ],
+            "ITEM.POINTER_MOVE": {
+              target: "interacting",
+              actions: ["setHighlightedValue"]
+            },
+            "ITEM.POINTER_LEAVE": {
+              actions: ["clearHighlightedValue"]
+            }
+          }
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isInputValueEmpty: ({ computed: e }) => e("isInputValueEmpty"),
+      autoComplete: ({ computed: e, prop: t }) => e("autoComplete") && !t("multiple"),
+      autoHighlight: ({ computed: e }) => e("autoHighlight"),
+      isFirstItemHighlighted: ({ prop: e, context: t }) => e("collection").firstValue === t.get("highlightedValue"),
+      isLastItemHighlighted: ({ prop: e, context: t }) => e("collection").lastValue === t.get("highlightedValue"),
+      isCustomValue: ({ computed: e }) => e("isCustomValue"),
+      allowCustomValue: ({ prop: e }) => !!e("allowCustomValue"),
+      hasHighlightedItem: ({ context: e }) => e.get("highlightedValue") != null,
+      closeOnSelect: ({ prop: e }) => !!e("closeOnSelect"),
+      isOpenControlled: ({ prop: e }) => e("open") != null,
+      openOnChange: ({ prop: e, context: t }) => {
+        const l = e("openOnChange");
+        return j(l) ? l : !!(l != null && l({ inputValue: t.get("inputValue") }));
+      },
+      restoreFocus: ({ event: e }) => {
+        var l;
+        const t = e.restoreFocus ?? ((l = e.previousEvent) == null ? void 0 : l.restoreFocus);
+        return t == null ? !0 : !!t;
+      },
+      isChangeEvent: ({ event: e }) => {
+        var t;
+        return ((t = e.previousEvent) == null ? void 0 : t.type) === "INPUT.CHANGE";
+      },
+      autoFocus: ({ prop: e }) => !!e("autoFocus"),
+      isHighlightedItemRemoved: ({ prop: e, context: t }) => !e("collection").has(t.get("highlightedValue")),
+      hasCollectionItems: ({ prop: e }) => e("collection").size > 0
+    },
+    effects: {
+      trackFocusVisible({ scope: e }) {
+        var t;
+        return U({ root: (t = e.getRootNode) == null ? void 0 : t.call(e) });
+      },
+      trackDismissableLayer({ send: e, prop: t, scope: l }) {
+        return t("disableLayer") ? void 0 : q(() => I(l), {
+          type: "listbox",
+          defer: !0,
+          exclude: () => [C(l), E(l), B(l)],
+          onFocusOutside: t("onFocusOutside"),
+          onPointerDownOutside: t("onPointerDownOutside"),
+          onInteractOutside: t("onInteractOutside"),
+          onEscapeKeyDown(n) {
+            n.preventDefault(), n.stopPropagation(), e({ type: "LAYER.ESCAPE", src: "escape-key" });
+          },
+          onDismiss() {
+            e({ type: "LAYER.INTERACT_OUTSIDE", src: "interact-outside", restoreFocus: !1 });
+          }
+        });
+      },
+      trackLiveRegion({ refs: e, scope: t }) {
+        const l = D({
+          level: "assertive",
+          document: t.getDoc()
+        });
+        return e.set("liveRegion", l), () => l.destroy();
+      },
+      trackPlacement({ context: e, prop: t, scope: l }) {
+        const i = () => N(l) || E(l), n = () => F(l);
+        return e.set("currentPlacement", t("positioning").placement), T(i, n, {
+          ...t("positioning"),
+          defer: !0,
+          onComplete(a) {
+            e.set("currentPlacement", a.placement);
+          }
+        });
+      },
+      scrollToHighlightedItem({ context: e, prop: t, scope: l }) {
+        const i = C(l);
+        let n = [];
+        const a = (u) => {
+          if (x() === "pointer") return;
+          const r = e.get("highlightedValue");
+          if (!r) return;
+          const d = I(l), v = t("scrollToIndexFn");
+          if (v) {
+            const y = t("collection").indexOf(r);
+            v({
+              index: y,
+              immediate: u,
+              getElement: () => V(l, r)
+            });
+            return;
+          }
+          const O = V(l, r), R = g(() => {
+            k(O, { rootEl: d, block: "nearest" });
+          });
+          n.push(R);
+        }, o = g(() => {
+          M("virtual"), a(!0);
+        });
+        n.push(o);
+        const s = Y(i, {
+          attributes: ["aria-activedescendant"],
+          callback: () => a(!1)
+        });
+        return n.push(s), () => {
+          n.forEach((u) => u());
+        };
+      }
+    },
+    actions: {
+      reposition({ context: e, prop: t, scope: l, event: i }) {
+        T(() => N(l), () => F(l), {
+          ...t("positioning"),
+          ...i.options,
+          defer: !0,
+          listeners: !1,
+          onComplete(o) {
+            e.set("currentPlacement", o.placement);
+          }
+        });
+      },
+      setHighlightedValue({ context: e, event: t }) {
+        t.value != null && e.set("highlightedValue", t.value);
+      },
+      clearHighlightedValue({ context: e }) {
+        e.set("highlightedValue", null);
+      },
+      selectHighlightedItem(e) {
+        var s;
+        const { context: t, prop: l } = e, i = l("collection"), n = t.get("highlightedValue");
+        if (!n || !i.has(n)) return;
+        const a = l("multiple") ? H(t.get("value"), n) : [n];
+        (s = l("onSelect")) == null || s({ value: a, itemValue: n }), t.set("value", a);
+        const o = h(l("selectionBehavior"), {
+          preserve: t.get("inputValue"),
+          replace: i.stringifyMany(a),
+          clear: ""
+        });
+        t.set("inputValue", o);
+      },
+      scrollToHighlightedItem({ context: e, prop: t, scope: l }) {
+        b(() => {
+          const i = e.get("highlightedValue");
+          if (i == null) return;
+          const n = V(l, i), a = I(l), o = t("scrollToIndexFn");
+          if (o) {
+            const s = t("collection").indexOf(i);
+            o({
+              index: s,
+              immediate: !0,
+              getElement: () => V(l, i)
+            });
+            return;
+          }
+          k(n, { rootEl: a, block: "nearest" });
+        });
+      },
+      selectItem(e) {
+        const { context: t, event: l, flush: i, prop: n } = e;
+        l.value != null && i(() => {
+          var s;
+          const a = n("multiple") ? H(t.get("value"), l.value) : [l.value];
+          (s = n("onSelect")) == null || s({ value: a, itemValue: l.value }), t.set("value", a);
+          const o = h(n("selectionBehavior"), {
+            preserve: t.get("inputValue"),
+            replace: n("collection").stringifyMany(a),
+            clear: ""
+          });
+          t.set("inputValue", o);
+        });
+      },
+      clearItem(e) {
+        const { context: t, event: l, flush: i, prop: n } = e;
+        l.value != null && i(() => {
+          const a = K(t.get("value"), l.value);
+          t.set("value", a);
+          const o = h(n("selectionBehavior"), {
+            preserve: t.get("inputValue"),
+            replace: n("collection").stringifyMany(a),
+            clear: ""
+          });
+          t.set("inputValue", o);
+        });
+      },
+      setInitialFocus({ scope: e }) {
+        g(() => {
+          S(e);
+        });
+      },
+      setFinalFocus({ scope: e }) {
+        g(() => {
+          const t = E(e);
+          (t == null ? void 0 : t.dataset.focusable) == null ? S(e) : G(e);
+        });
+      },
+      syncInputValue({ context: e, scope: t, event: l }) {
+        const i = C(t);
+        i && (i.value = e.get("inputValue"), queueMicrotask(() => {
+          l.current().type !== "INPUT.CHANGE" && W(i);
+        }));
+      },
+      setInputValue({ context: e, event: t }) {
+        e.set("inputValue", t.value);
+      },
+      clearInputValue({ context: e }) {
+        e.set("inputValue", "");
+      },
+      revertInputValue({ context: e, prop: t, computed: l }) {
+        const i = t("selectionBehavior"), n = h(i, {
+          replace: l("hasSelectedItems") ? l("valueAsString") : "",
+          preserve: e.get("inputValue"),
+          clear: ""
+        });
+        e.set("inputValue", n);
+      },
+      setValue(e) {
+        const { context: t, flush: l, event: i, prop: n } = e;
+        l(() => {
+          t.set("value", i.value);
+          const a = h(n("selectionBehavior"), {
+            preserve: t.get("inputValue"),
+            replace: n("collection").stringifyMany(i.value),
+            clear: ""
+          });
+          t.set("inputValue", a);
+        });
+      },
+      clearSelectedItems(e) {
+        const { context: t, flush: l, prop: i } = e;
+        l(() => {
+          t.set("value", []);
+          const n = h(i("selectionBehavior"), {
+            preserve: t.get("inputValue"),
+            replace: i("collection").stringifyMany([]),
+            clear: ""
+          });
+          t.set("inputValue", n);
+        });
+      },
+      scrollContentToTop({ prop: e, scope: t }) {
+        const l = e("scrollToIndexFn");
+        if (l) {
+          const i = e("collection").firstValue;
+          l({
+            index: 0,
+            immediate: !0,
+            getElement: () => V(t, i)
+          });
+        } else {
+          const i = I(t);
+          if (!i) return;
+          i.scrollTop = 0;
+        }
+      },
+      invokeOnOpen({ prop: e, event: t, context: l }) {
+        var n;
+        const i = L(t);
+        (n = e("onOpenChange")) == null || n({ open: !0, reason: i, value: l.get("value") });
+      },
+      invokeOnClose({ prop: e, event: t, context: l }) {
+        var n;
+        const i = L(t);
+        (n = e("onOpenChange")) == null || n({ open: !1, reason: i, value: l.get("value") });
+      },
+      highlightFirstItem({ context: e, prop: t, scope: l }) {
+        (I(l) ? queueMicrotask : g)(() => {
+          const n = t("collection").firstValue;
+          n && e.set("highlightedValue", n);
+        });
+      },
+      highlightFirstItemIfNeeded({ computed: e, action: t }) {
+        e("autoHighlight") && t(["highlightFirstItem"]);
+      },
+      highlightLastItem({ context: e, prop: t, scope: l }) {
+        (I(l) ? queueMicrotask : g)(() => {
+          const n = t("collection").lastValue;
+          n && e.set("highlightedValue", n);
+        });
+      },
+      highlightNextItem({ context: e, prop: t }) {
+        let l = null;
+        const i = e.get("highlightedValue"), n = t("collection");
+        i ? (l = n.getNextValue(i), !l && t("loopFocus") && (l = n.firstValue)) : l = n.firstValue, l && e.set("highlightedValue", l);
+      },
+      highlightPrevItem({ context: e, prop: t }) {
+        let l = null;
+        const i = e.get("highlightedValue"), n = t("collection");
+        i ? (l = n.getPreviousValue(i), !l && t("loopFocus") && (l = n.lastValue)) : l = n.lastValue, l && e.set("highlightedValue", l);
+      },
+      highlightFirstSelectedItem({ context: e, prop: t }) {
+        g(() => {
+          const [l] = t("collection").sort(e.get("value"));
+          l && e.set("highlightedValue", l);
+        });
+      },
+      highlightFirstOrSelectedItem({ context: e, prop: t, computed: l }) {
+        g(() => {
+          let i = null;
+          l("hasSelectedItems") ? i = t("collection").sort(e.get("value"))[0] : i = t("collection").firstValue, i && e.set("highlightedValue", i);
+        });
+      },
+      highlightLastOrSelectedItem({ context: e, prop: t, computed: l }) {
+        g(() => {
+          const i = t("collection");
+          let n = null;
+          l("hasSelectedItems") ? n = i.sort(e.get("value"))[0] : n = i.lastValue, n && e.set("highlightedValue", n);
+        });
+      },
+      autofillInputValue({ context: e, computed: t, prop: l, event: i, scope: n }) {
+        const a = C(n), o = l("collection");
+        if (!t("autoComplete") || !a || !i.keypress) return;
+        const s = o.stringify(e.get("highlightedValue"));
+        g(() => {
+          a.value = s || e.get("inputValue");
+        });
+      },
+      syncSelectedItems(e) {
+        queueMicrotask(() => {
+          const { context: t, prop: l } = e, i = l("collection"), n = t.get("value"), a = t.get("selectedItemMap"), o = f({ values: n, collection: i, selectedItemMap: a });
+          t.set("selectedItemMap", o.nextSelectedItemMap);
+          const s = h(l("selectionBehavior"), {
+            preserve: t.get("inputValue"),
+            replace: i.stringifyMany(n),
+            clear: ""
+          });
+          t.set("inputValue", s);
+        });
+      },
+      syncHighlightedItem({ context: e, prop: t }) {
+        const l = t("collection").find(e.get("highlightedValue"));
+        e.set("highlightedItem", l);
+      },
+      announceHighlightedItem({ context: e, prop: t, refs: l }) {
+        var o;
+        if (!w()) return;
+        const i = e.get("highlightedValue"), n = i ? t("collection").stringifyItem(t("collection").find(i)) : null;
+        if (!n) return;
+        const a = i ? e.get("value").includes(i) : !1;
+        (o = l.get("liveRegion")) == null || o.announce(a ? `${n}, selected` : n);
+      },
+      toggleVisibility({ event: e, send: t, prop: l }) {
+        t({ type: l("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE", previousEvent: e });
+      }
+    }
+  }
+});
+function L(e) {
+  return (e.previousEvent || e).src;
+}
+export {
+  ve as machine
+};