@manafishrov/ui 1.5.0 → 1.5.2

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

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