@manafishrov/ui 1.2.5 → 1.2.7

package/dist/node_modules/.bun/@zag-js_combobox@1.35.2/node_modules/@zag-js/combobox/dist/combobox.machine.js

@@ -1,974 +0,0 @@
-import { setInteractionModality as y, trackFocusVisible as P, getInteractionModality as A } from "../../../../../@zag-js_focus-visible@1.35.2/node_modules/@zag-js/focus-visible/dist/index.js";
-import { getPlacement as f } from "../../../../../@zag-js_popper@1.35.2/node_modules/@zag-js/popper/dist/get-placement.js";
-import { collection as U } from "./combobox.collection.js";
-import { getInputEl as C, getContentEl as m, getItemEl as O, getTriggerEl as E, focusInputEl as T, focusTriggerEl as D, getPositionerEl as k, getControlEl as F, getClearTriggerEl as x } from "./combobox.dom.js";
-import { setup as M } from "../../../../../@zag-js_core@1.35.2/node_modules/@zag-js/core/dist/create-machine.js";
-import { match as h } from "../../../../../@zag-js_utils@1.35.2/node_modules/@zag-js/utils/dist/functions.js";
-import { isBoolean as _ } from "../../../../../@zag-js_utils@1.35.2/node_modules/@zag-js/utils/dist/guard.js";
-import { clickIfLink as G } from "../../../../../@zag-js_dom-query@1.35.2/node_modules/@zag-js/dom-query/dist/navigate.js";
-import { scrollIntoView as S } from "../../../../../@zag-js_dom-query@1.35.2/node_modules/@zag-js/dom-query/dist/overflow.js";
-import { raf as r, nextTick as w } from "../../../../../@zag-js_dom-query@1.35.2/node_modules/@zag-js/dom-query/dist/raf.js";
-import { setCaretToEnd as b } from "../../../../../@zag-js_dom-query@1.35.2/node_modules/@zag-js/dom-query/dist/caret.js";
-import { remove as B, addOrRemove as L } from "../../../../../@zag-js_utils@1.35.2/node_modules/@zag-js/utils/dist/array.js";
-import { observeAttributes as K } from "../../../../../@zag-js_dom-query@1.35.2/node_modules/@zag-js/dom-query/dist/mutation-observer.js";
-import { trackDismissableElement as W } from "../../../../../@zag-js_dismissable@1.35.2/node_modules/@zag-js/dismissable/dist/dismissable-layer.js";
-import { isEqual as Y } from "../../../../../@zag-js_utils@1.35.2/node_modules/@zag-js/utils/dist/equal.js";
-var { guards: q, createMachine: j, choose: z } = M(), { and: s, not: c } = q, re = j({
-  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 }) {
-        G(t);
-      },
-      collection: U.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") ? "suggesting" : "idle";
-  },
-  context({ prop: e, bindable: t, getContext: l, getEvent: n }) {
-    return {
-      currentPlacement: t(() => ({
-        defaultValue: void 0
-      })),
-      value: t(() => ({
-        defaultValue: e("defaultValue"),
-        value: e("value"),
-        isEqual: Y,
-        hash(i) {
-          return i.join(",");
-        },
-        onChange(i) {
-          const o = l(), a = o.get("selectedItems"), u = e("collection"), g = (p) => p.map((I) => a.find((v) => u.getItemValue(v) === I) || u.find(I)), V = g(i), d = e("value") || i;
-          o.set("selectedItems", g(d)), e("onValueChange")?.({ value: i, items: V });
-        }
-      })),
-      highlightedValue: t(() => ({
-        defaultValue: e("defaultHighlightedValue") || null,
-        value: e("highlightedValue"),
-        onChange(i) {
-          const o = e("collection").find(i);
-          e("onHighlightChange")?.({ highlightedValue: i, highlightedItem: o });
-        }
-      })),
-      inputValue: t(() => {
-        let i = e("inputValue") || e("defaultInputValue");
-        const o = e("value") || e("defaultValue");
-        if (!i.trim() && !e("multiple")) {
-          const a = e("collection").stringifyMany(o);
-          i = h(e("selectionBehavior"), {
-            preserve: i || a,
-            replace: a,
-            clear: ""
-          });
-        }
-        return {
-          defaultValue: i,
-          value: e("inputValue"),
-          onChange(a) {
-            const u = n(), g = (u.previousEvent || u).src;
-            e("onInputValueChange")?.({ inputValue: a, reason: g });
-          }
-        };
-      }),
-      highlightedItem: t(() => {
-        const i = e("highlightedValue");
-        return { defaultValue: e("collection").find(i) };
-      }),
-      selectedItems: t(() => {
-        const i = e("value") || e("defaultValue") || [];
-        return { defaultValue: e("collection").findMany(i) };
-      })
-    };
-  },
-  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,
-    valueAsString: ({ context: e, prop: t }) => t("collection").stringifyItems(e.get("selectedItems")),
-    isCustomValue: ({ context: e, computed: t }) => e.get("inputValue") !== t("valueAsString")
-  },
-  watch({ context: e, prop: t, track: l, action: n, send: i }) {
-    l([() => e.hash("value")], () => {
-      n(["syncSelectedItems"]);
-    }), l([() => e.get("inputValue")], () => {
-      n(["syncInputValue"]);
-    }), l([() => e.get("highlightedValue")], () => {
-      n(["syncHighlightedItem", "autofillInputValue"]);
-    }), l([() => t("open")], () => {
-      n(["toggleVisibility"]);
-    }), l([() => t("collection").toString()], () => {
-      i({ 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: {
-    idle: {
-      tags: ["idle", "closed"],
-      entry: ["scrollContentToTop", "clearHighlightedValue"],
-      on: {
-        "CONTROLLED.OPEN": {
-          target: "interacting"
-        },
-        "TRIGGER.CLICK": [
-          {
-            guard: "isOpenControlled",
-            actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
-          }
-        ],
-        "INPUT.CLICK": [
-          {
-            guard: "isOpenControlled",
-            actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
-          }
-        ],
-        "INPUT.FOCUS": {
-          target: "focused"
-        },
-        OPEN: [
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["invokeOnOpen"]
-          }
-        ],
-        "VALUE.CLEAR": {
-          target: "focused",
-          actions: ["clearInputValue", "clearSelectedItems", "setInitialFocus"]
-        }
-      }
-    },
-    focused: {
-      tags: ["focused", "closed"],
-      entry: ["scrollContentToTop", "clearHighlightedValue"],
-      on: {
-        "CONTROLLED.OPEN": [
-          {
-            guard: "isChangeEvent",
-            target: "suggesting"
-          },
-          {
-            target: "interacting"
-          }
-        ],
-        "INPUT.CHANGE": [
-          {
-            guard: s("isOpenControlled", "openOnChange"),
-            actions: ["setInputValue", "invokeOnOpen", "highlightFirstItemIfNeeded"]
-          },
-          {
-            guard: "openOnChange",
-            target: "suggesting",
-            actions: ["setInputValue", "invokeOnOpen", "highlightFirstItemIfNeeded"]
-          },
-          {
-            actions: ["setInputValue"]
-          }
-        ],
-        "LAYER.INTERACT_OUTSIDE": {
-          target: "idle"
-        },
-        "INPUT.ESCAPE": {
-          guard: s("isCustomValue", c("allowCustomValue")),
-          actions: ["revertInputValue"]
-        },
-        "INPUT.BLUR": {
-          target: "idle"
-        },
-        "INPUT.CLICK": [
-          {
-            guard: "isOpenControlled",
-            actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["highlightFirstSelectedItem", "invokeOnOpen"]
-          }
-        ],
-        "TRIGGER.CLICK": [
-          {
-            guard: "isOpenControlled",
-            actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["setInitialFocus", "highlightFirstSelectedItem", "invokeOnOpen"]
-          }
-        ],
-        "INPUT.ARROW_DOWN": [
-          // == group 1 ==
-          {
-            guard: s("isOpenControlled", "autoComplete"),
-            actions: ["invokeOnOpen"]
-          },
-          {
-            guard: "autoComplete",
-            target: "interacting",
-            actions: ["invokeOnOpen"]
-          },
-          // == group 2 ==
-          {
-            guard: "isOpenControlled",
-            actions: ["highlightFirstOrSelectedItem", "invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["highlightFirstOrSelectedItem", "invokeOnOpen"]
-          }
-        ],
-        "INPUT.ARROW_UP": [
-          // == group 1 ==
-          {
-            guard: s("isOpenControlled", "autoComplete"),
-            actions: ["invokeOnOpen"]
-          },
-          {
-            guard: "autoComplete",
-            target: "interacting",
-            actions: ["invokeOnOpen"]
-          },
-          // == group 2 ==
-          {
-            guard: "isOpenControlled",
-            actions: ["highlightLastOrSelectedItem", "invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["highlightLastOrSelectedItem", "invokeOnOpen"]
-          }
-        ],
-        OPEN: [
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnOpen"]
-          },
-          {
-            target: "interacting",
-            actions: ["invokeOnOpen"]
-          }
-        ],
-        "VALUE.CLEAR": {
-          actions: ["clearInputValue", "clearSelectedItems"]
-        }
-      }
-    },
-    interacting: {
-      tags: ["open", "focused"],
-      entry: ["setInitialFocus"],
-      effects: ["trackFocusVisible", "scrollToHighlightedItem", "trackDismissableLayer", "trackPlacement"],
-      on: {
-        "CONTROLLED.CLOSE": [
-          {
-            guard: "restoreFocus",
-            target: "focused",
-            actions: ["setFinalFocus"]
-          },
-          {
-            target: "idle"
-          }
-        ],
-        CHILDREN_CHANGE: [
-          {
-            guard: "isHighlightedItemRemoved",
-            actions: ["clearHighlightedValue"]
-          },
-          {
-            actions: ["scrollToHighlightedItem"]
-          }
-        ],
-        "INPUT.HOME": {
-          actions: ["highlightFirstItem"]
-        },
-        "INPUT.END": {
-          actions: ["highlightLastItem"]
-        },
-        "INPUT.ARROW_DOWN": [
-          {
-            guard: s("autoComplete", "isLastItemHighlighted"),
-            actions: ["clearHighlightedValue", "scrollContentToTop"]
-          },
-          {
-            actions: ["highlightNextItem"]
-          }
-        ],
-        "INPUT.ARROW_UP": [
-          {
-            guard: s("autoComplete", "isFirstItemHighlighted"),
-            actions: ["clearHighlightedValue"]
-          },
-          {
-            actions: ["highlightPrevItem"]
-          }
-        ],
-        "INPUT.ENTER": [
-          // == group 1 ==
-          {
-            guard: s("isOpenControlled", "isCustomValue", c("hasHighlightedItem"), c("allowCustomValue")),
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          {
-            guard: s("isCustomValue", c("hasHighlightedItem"), c("allowCustomValue")),
-            target: "focused",
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          // == group 2 ==
-          {
-            guard: s("isOpenControlled", "closeOnSelect"),
-            actions: ["selectHighlightedItem", "invokeOnClose"]
-          },
-          {
-            guard: "closeOnSelect",
-            target: "focused",
-            actions: ["selectHighlightedItem", "invokeOnClose", "setFinalFocus"]
-          },
-          {
-            actions: ["selectHighlightedItem"]
-          }
-        ],
-        "INPUT.CHANGE": [
-          {
-            guard: "autoComplete",
-            target: "suggesting",
-            actions: ["setInputValue"]
-          },
-          {
-            target: "suggesting",
-            actions: ["clearHighlightedValue", "setInputValue"]
-          }
-        ],
-        "ITEM.POINTER_MOVE": {
-          actions: ["setHighlightedValue"]
-        },
-        "ITEM.POINTER_LEAVE": {
-          actions: ["clearHighlightedValue"]
-        },
-        "ITEM.CLICK": [
-          {
-            guard: s("isOpenControlled", "closeOnSelect"),
-            actions: ["selectItem", "invokeOnClose"]
-          },
-          {
-            guard: "closeOnSelect",
-            target: "focused",
-            actions: ["selectItem", "invokeOnClose", "setFinalFocus"]
-          },
-          {
-            actions: ["selectItem"]
-          }
-        ],
-        "LAYER.ESCAPE": [
-          {
-            guard: s("isOpenControlled", "autoComplete"),
-            actions: ["syncInputValue", "invokeOnClose"]
-          },
-          {
-            guard: "autoComplete",
-            target: "focused",
-            actions: ["syncInputValue", "invokeOnClose"]
-          },
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["invokeOnClose", "setFinalFocus"]
-          }
-        ],
-        "TRIGGER.CLICK": [
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["invokeOnClose"]
-          }
-        ],
-        "LAYER.INTERACT_OUTSIDE": [
-          // == group 1 ==
-          {
-            guard: s("isOpenControlled", "isCustomValue", c("allowCustomValue")),
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          {
-            guard: s("isCustomValue", c("allowCustomValue")),
-            target: "idle",
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          // == group 2 ==
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "idle",
-            actions: ["invokeOnClose"]
-          }
-        ],
-        CLOSE: [
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["invokeOnClose", "setFinalFocus"]
-          }
-        ],
-        "VALUE.CLEAR": [
-          {
-            guard: "isOpenControlled",
-            actions: ["clearInputValue", "clearSelectedItems", "invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["clearInputValue", "clearSelectedItems", "invokeOnClose", "setFinalFocus"]
-          }
-        ]
-      }
-    },
-    suggesting: {
-      tags: ["open", "focused"],
-      effects: ["trackFocusVisible", "trackDismissableLayer", "scrollToHighlightedItem", "trackPlacement"],
-      entry: ["setInitialFocus"],
-      on: {
-        "CONTROLLED.CLOSE": [
-          {
-            guard: "restoreFocus",
-            target: "focused",
-            actions: ["setFinalFocus"]
-          },
-          {
-            target: "idle"
-          }
-        ],
-        CHILDREN_CHANGE: [
-          {
-            guard: s("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.ENTER": [
-          // == group 1 ==
-          {
-            guard: s("isOpenControlled", "isCustomValue", c("hasHighlightedItem"), c("allowCustomValue")),
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          {
-            guard: s("isCustomValue", c("hasHighlightedItem"), c("allowCustomValue")),
-            target: "focused",
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          // == group 2 ==
-          {
-            guard: s("isOpenControlled", "closeOnSelect"),
-            actions: ["selectHighlightedItem", "invokeOnClose"]
-          },
-          {
-            guard: "closeOnSelect",
-            target: "focused",
-            actions: ["selectHighlightedItem", "invokeOnClose", "setFinalFocus"]
-          },
-          {
-            actions: ["selectHighlightedItem"]
-          }
-        ],
-        "INPUT.CHANGE": {
-          actions: ["setInputValue"]
-        },
-        "LAYER.ESCAPE": [
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["invokeOnClose"]
-          }
-        ],
-        "ITEM.POINTER_MOVE": {
-          target: "interacting",
-          actions: ["setHighlightedValue"]
-        },
-        "ITEM.POINTER_LEAVE": {
-          actions: ["clearHighlightedValue"]
-        },
-        "LAYER.INTERACT_OUTSIDE": [
-          // == group 1 ==
-          {
-            guard: s("isOpenControlled", "isCustomValue", c("allowCustomValue")),
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          {
-            guard: s("isCustomValue", c("allowCustomValue")),
-            target: "idle",
-            actions: ["revertInputValue", "invokeOnClose"]
-          },
-          // == group 2 ==
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "idle",
-            actions: ["invokeOnClose"]
-          }
-        ],
-        "TRIGGER.CLICK": [
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["invokeOnClose"]
-          }
-        ],
-        "ITEM.CLICK": [
-          {
-            guard: s("isOpenControlled", "closeOnSelect"),
-            actions: ["selectItem", "invokeOnClose"]
-          },
-          {
-            guard: "closeOnSelect",
-            target: "focused",
-            actions: ["selectItem", "invokeOnClose", "setFinalFocus"]
-          },
-          {
-            actions: ["selectItem"]
-          }
-        ],
-        CLOSE: [
-          {
-            guard: "isOpenControlled",
-            actions: ["invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["invokeOnClose", "setFinalFocus"]
-          }
-        ],
-        "VALUE.CLEAR": [
-          {
-            guard: "isOpenControlled",
-            actions: ["clearInputValue", "clearSelectedItems", "invokeOnClose"]
-          },
-          {
-            target: "focused",
-            actions: ["clearInputValue", "clearSelectedItems", "invokeOnClose", "setFinalFocus"]
-          }
-        ]
-      }
-    }
-  },
-  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 _(l) ? l : !!l?.({ inputValue: t.get("inputValue") });
-      },
-      restoreFocus: ({ event: e }) => {
-        const t = e.restoreFocus ?? e.previousEvent?.restoreFocus;
-        return t == null ? !0 : !!t;
-      },
-      isChangeEvent: ({ event: e }) => e.previousEvent?.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 }) {
-        return P({ root: e.getRootNode?.() });
-      },
-      trackDismissableLayer({ send: e, prop: t, scope: l }) {
-        return t("disableLayer") ? void 0 : W(() => m(l), {
-          type: "listbox",
-          defer: !0,
-          exclude: () => [C(l), E(l), x(l)],
-          onFocusOutside: t("onFocusOutside"),
-          onPointerDownOutside: t("onPointerDownOutside"),
-          onInteractOutside: t("onInteractOutside"),
-          onEscapeKeyDown(i) {
-            i.preventDefault(), i.stopPropagation(), e({ type: "LAYER.ESCAPE", src: "escape-key" });
-          },
-          onDismiss() {
-            e({ type: "LAYER.INTERACT_OUTSIDE", src: "interact-outside", restoreFocus: !1 });
-          }
-        });
-      },
-      trackPlacement({ context: e, prop: t, scope: l }) {
-        const n = () => F(l) || E(l), i = () => k(l);
-        return e.set("currentPlacement", t("positioning").placement), f(n, i, {
-          ...t("positioning"),
-          defer: !0,
-          onComplete(o) {
-            e.set("currentPlacement", o.placement);
-          }
-        });
-      },
-      scrollToHighlightedItem({ context: e, prop: t, scope: l }) {
-        const n = C(l);
-        let i = [];
-        const o = (g) => {
-          if (A() === "pointer") return;
-          const d = e.get("highlightedValue");
-          if (!d) return;
-          const p = m(l), I = t("scrollToIndexFn");
-          if (I) {
-            const R = t("collection").indexOf(d);
-            I({
-              index: R,
-              immediate: g,
-              getElement: () => O(l, d)
-            });
-            return;
-          }
-          const v = O(l, d), H = r(() => {
-            S(v, { rootEl: p, block: "nearest" });
-          });
-          i.push(H);
-        }, a = r(() => {
-          y("virtual"), o(!0);
-        });
-        i.push(a);
-        const u = K(n, {
-          attributes: ["aria-activedescendant"],
-          callback: () => o(!1)
-        });
-        return i.push(u), () => {
-          i.forEach((g) => g());
-        };
-      }
-    },
-    actions: {
-      reposition({ context: e, prop: t, scope: l, event: n }) {
-        f(() => F(l), () => k(l), {
-          ...t("positioning"),
-          ...n.options,
-          defer: !0,
-          listeners: !1,
-          onComplete(a) {
-            e.set("currentPlacement", a.placement);
-          }
-        });
-      },
-      setHighlightedValue({ context: e, event: t }) {
-        t.value != null && e.set("highlightedValue", t.value);
-      },
-      clearHighlightedValue({ context: e }) {
-        e.set("highlightedValue", null);
-      },
-      selectHighlightedItem(e) {
-        const { context: t, prop: l } = e, n = l("collection"), i = t.get("highlightedValue");
-        if (!i || !n.has(i)) return;
-        const o = l("multiple") ? L(t.get("value"), i) : [i];
-        l("onSelect")?.({ value: o, itemValue: i }), t.set("value", o);
-        const a = h(l("selectionBehavior"), {
-          preserve: t.get("inputValue"),
-          replace: n.stringifyMany(o),
-          clear: ""
-        });
-        t.set("inputValue", a);
-      },
-      scrollToHighlightedItem({ context: e, prop: t, scope: l }) {
-        w(() => {
-          const n = e.get("highlightedValue");
-          if (n == null) return;
-          const i = O(l, n), o = m(l), a = t("scrollToIndexFn");
-          if (a) {
-            const u = t("collection").indexOf(n);
-            a({
-              index: u,
-              immediate: !0,
-              getElement: () => O(l, n)
-            });
-            return;
-          }
-          S(i, { rootEl: o, block: "nearest" });
-        });
-      },
-      selectItem(e) {
-        const { context: t, event: l, flush: n, prop: i } = e;
-        l.value != null && n(() => {
-          const o = i("multiple") ? L(t.get("value"), l.value) : [l.value];
-          i("onSelect")?.({ value: o, itemValue: l.value }), t.set("value", o);
-          const a = h(i("selectionBehavior"), {
-            preserve: t.get("inputValue"),
-            replace: i("collection").stringifyMany(o),
-            clear: ""
-          });
-          t.set("inputValue", a);
-        });
-      },
-      clearItem(e) {
-        const { context: t, event: l, flush: n, prop: i } = e;
-        l.value != null && n(() => {
-          const o = B(t.get("value"), l.value);
-          t.set("value", o);
-          const a = h(i("selectionBehavior"), {
-            preserve: t.get("inputValue"),
-            replace: i("collection").stringifyMany(o),
-            clear: ""
-          });
-          t.set("inputValue", a);
-        });
-      },
-      setInitialFocus({ scope: e }) {
-        r(() => {
-          T(e);
-        });
-      },
-      setFinalFocus({ scope: e }) {
-        r(() => {
-          E(e)?.dataset.focusable == null ? T(e) : D(e);
-        });
-      },
-      syncInputValue({ context: e, scope: t, event: l }) {
-        const n = C(t);
-        n && (n.value = e.get("inputValue"), queueMicrotask(() => {
-          l.current().type !== "INPUT.CHANGE" && b(n);
-        }));
-      },
-      setInputValue({ context: e, event: t }) {
-        e.set("inputValue", t.value);
-      },
-      clearInputValue({ context: e }) {
-        e.set("inputValue", "");
-      },
-      revertInputValue({ context: e, prop: t, computed: l }) {
-        const n = t("selectionBehavior"), i = h(n, {
-          replace: l("hasSelectedItems") ? l("valueAsString") : "",
-          preserve: e.get("inputValue"),
-          clear: ""
-        });
-        e.set("inputValue", i);
-      },
-      setValue(e) {
-        const { context: t, flush: l, event: n, prop: i } = e;
-        l(() => {
-          t.set("value", n.value);
-          const o = h(i("selectionBehavior"), {
-            preserve: t.get("inputValue"),
-            replace: i("collection").stringifyMany(n.value),
-            clear: ""
-          });
-          t.set("inputValue", o);
-        });
-      },
-      clearSelectedItems(e) {
-        const { context: t, flush: l, prop: n } = e;
-        l(() => {
-          t.set("value", []);
-          const i = h(n("selectionBehavior"), {
-            preserve: t.get("inputValue"),
-            replace: n("collection").stringifyMany([]),
-            clear: ""
-          });
-          t.set("inputValue", i);
-        });
-      },
-      scrollContentToTop({ prop: e, scope: t }) {
-        const l = e("scrollToIndexFn");
-        if (l) {
-          const n = e("collection").firstValue;
-          l({
-            index: 0,
-            immediate: !0,
-            getElement: () => O(t, n)
-          });
-        } else {
-          const n = m(t);
-          if (!n) return;
-          n.scrollTop = 0;
-        }
-      },
-      invokeOnOpen({ prop: e, event: t, context: l }) {
-        const n = N(t);
-        e("onOpenChange")?.({ open: !0, reason: n, value: l.get("value") });
-      },
-      invokeOnClose({ prop: e, event: t, context: l }) {
-        const n = N(t);
-        e("onOpenChange")?.({ open: !1, reason: n, value: l.get("value") });
-      },
-      highlightFirstItem({ context: e, prop: t, scope: l }) {
-        (m(l) ? queueMicrotask : r)(() => {
-          const i = t("collection").firstValue;
-          i && e.set("highlightedValue", i);
-        });
-      },
-      highlightFirstItemIfNeeded({ computed: e, action: t }) {
-        e("autoHighlight") && t(["highlightFirstItem"]);
-      },
-      highlightLastItem({ context: e, prop: t, scope: l }) {
-        (m(l) ? queueMicrotask : r)(() => {
-          const i = t("collection").lastValue;
-          i && e.set("highlightedValue", i);
-        });
-      },
-      highlightNextItem({ context: e, prop: t }) {
-        let l = null;
-        const n = e.get("highlightedValue"), i = t("collection");
-        n ? (l = i.getNextValue(n), !l && t("loopFocus") && (l = i.firstValue)) : l = i.firstValue, l && e.set("highlightedValue", l);
-      },
-      highlightPrevItem({ context: e, prop: t }) {
-        let l = null;
-        const n = e.get("highlightedValue"), i = t("collection");
-        n ? (l = i.getPreviousValue(n), !l && t("loopFocus") && (l = i.lastValue)) : l = i.lastValue, l && e.set("highlightedValue", l);
-      },
-      highlightFirstSelectedItem({ context: e, prop: t }) {
-        r(() => {
-          const [l] = t("collection").sort(e.get("value"));
-          l && e.set("highlightedValue", l);
-        });
-      },
-      highlightFirstOrSelectedItem({ context: e, prop: t, computed: l }) {
-        r(() => {
-          let n = null;
-          l("hasSelectedItems") ? n = t("collection").sort(e.get("value"))[0] : n = t("collection").firstValue, n && e.set("highlightedValue", n);
-        });
-      },
-      highlightLastOrSelectedItem({ context: e, prop: t, computed: l }) {
-        r(() => {
-          const n = t("collection");
-          let i = null;
-          l("hasSelectedItems") ? i = n.sort(e.get("value"))[0] : i = n.lastValue, i && e.set("highlightedValue", i);
-        });
-      },
-      autofillInputValue({ context: e, computed: t, prop: l, event: n, scope: i }) {
-        const o = C(i), a = l("collection");
-        if (!t("autoComplete") || !o || !n.keypress) return;
-        const u = a.stringify(e.get("highlightedValue"));
-        r(() => {
-          o.value = u || e.get("inputValue");
-        });
-      },
-      syncSelectedItems(e) {
-        queueMicrotask(() => {
-          const { context: t, prop: l } = e, n = l("collection"), i = t.get("value"), o = i.map((u) => t.get("selectedItems").find((V) => n.getItemValue(V) === u) || n.find(u));
-          t.set("selectedItems", o);
-          const a = h(l("selectionBehavior"), {
-            preserve: t.get("inputValue"),
-            replace: n.stringifyMany(i),
-            clear: ""
-          });
-          t.set("inputValue", a);
-        });
-      },
-      syncHighlightedItem({ context: e, prop: t }) {
-        const l = t("collection").find(e.get("highlightedValue"));
-        e.set("highlightedItem", l);
-      },
-      toggleVisibility({ event: e, send: t, prop: l }) {
-        t({ type: l("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE", previousEvent: e });
-      }
-    }
-  }
-});
-function N(e) {
-  return (e.previousEvent || e).src;
-}
-export {
-  re as machine
-};
-//# sourceMappingURL=combobox.machine.js.map