@serendie/ui 0.1.12 → 0.1.13

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

@@ -0,0 +1,1266 @@
+import { createAnatomy as B } from "../../anatomy/dist/index.js";
+import { Collection as D } from "../../collection/dist/index.js";
+import { createMachine as W, guards as $ } from "../../core/dist/index.js";
+import { getEventKey as U, isLeftClick as Y, isContextMenuEvent as q, clickIfLink as j } from "../../dom-event/dist/index.js";
+import { createScope as J, query as Q, dataAttr as u, ariaAttr as A, isComposingEvent as X, isDownloadingEvent as Z, isOpeningInNewTab as z, observeChildren as x, raf as C, observeAttributes as ee, scrollIntoView as te } from "../../dom-query/dist/index.js";
+import { getPlacementStyles as ne, getPlacement as H } from "../../popper/dist/index.js";
+import { ariaHidden as ie } from "../../aria-hidden/dist/index.js";
+import { trackDismissableElement as le } from "../../dismissable/dist/index.js";
+import { compact as oe, isBoolean as ae, match as R, isArray as G, isEqual as F, addOrRemove as re } from "../../utils/dist/index.js";
+import { ref as M } from "../../store/dist/index.js";
+var se = B("combobox").parts(
+  "root",
+  "clearTrigger",
+  "content",
+  "control",
+  "input",
+  "item",
+  "itemGroup",
+  "itemGroupLabel",
+  "itemIndicator",
+  "itemText",
+  "label",
+  "list",
+  "positioner",
+  "trigger"
+), I = se.build(), _ = (t) => M(new D(t));
+_.empty = () => M(new D({ items: [] }));
+var o = J({
+  getRootId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.root) ?? `combobox:${t.id}`;
+  },
+  getLabelId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.label) ?? `combobox:${t.id}:label`;
+  },
+  getControlId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.control) ?? `combobox:${t.id}:control`;
+  },
+  getInputId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.input) ?? `combobox:${t.id}:input`;
+  },
+  getContentId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.content) ?? `combobox:${t.id}:content`;
+  },
+  getPositionerId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.positioner) ?? `combobox:${t.id}:popper`;
+  },
+  getTriggerId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.trigger) ?? `combobox:${t.id}:toggle-btn`;
+  },
+  getClearTriggerId: (t) => {
+    var n;
+    return ((n = t.ids) == null ? void 0 : n.clearTrigger) ?? `combobox:${t.id}:clear-btn`;
+  },
+  getItemGroupId: (t, n) => {
+    var e, i;
+    return ((i = (e = t.ids) == null ? void 0 : e.itemGroup) == null ? void 0 : i.call(e, n)) ?? `combobox:${t.id}:optgroup:${n}`;
+  },
+  getItemGroupLabelId: (t, n) => {
+    var e, i;
+    return ((i = (e = t.ids) == null ? void 0 : e.itemGroupLabel) == null ? void 0 : i.call(e, n)) ?? `combobox:${t.id}:optgroup-label:${n}`;
+  },
+  getItemId: (t, n) => {
+    var e, i;
+    return ((i = (e = t.ids) == null ? void 0 : e.item) == null ? void 0 : i.call(e, n)) ?? `combobox:${t.id}:option:${n}`;
+  },
+  getContentEl: (t) => o.getById(t, o.getContentId(t)),
+  getInputEl: (t) => o.getById(t, o.getInputId(t)),
+  getPositionerEl: (t) => o.getById(t, o.getPositionerId(t)),
+  getControlEl: (t) => o.getById(t, o.getControlId(t)),
+  getTriggerEl: (t) => o.getById(t, o.getTriggerId(t)),
+  getClearTriggerEl: (t) => o.getById(t, o.getClearTriggerId(t)),
+  getHighlightedItemEl: (t) => {
+    const n = t.highlightedValue;
+    if (n == null) return;
+    const e = `[role=option][data-value="${CSS.escape(n)}"`;
+    return Q(o.getContentEl(t), e);
+  },
+  focusInputEl: (t) => {
+    const n = o.getInputEl(t);
+    o.isActiveElement(t, n) || n == null || n.focus({ preventScroll: !0 });
+  },
+  focusTriggerEl: (t) => {
+    const n = o.getTriggerEl(t);
+    o.isActiveElement(t, n) || n == null || n.focus({ preventScroll: !0 });
+  }
+});
+function Ee(t, n, e) {
+  const i = t.context.translations, r = t.context.collection, s = t.context.disabled, c = t.context.isInteractive, O = t.context.invalid, V = t.context.readOnly, d = t.hasTag("open"), v = t.hasTag("focused"), E = t.context.composite, b = t.context.highlightedValue, N = ne({
+    ...t.context.positioning,
+    placement: t.context.currentPlacement
+  });
+  function T(l) {
+    const { item: a } = l, p = r.getItemDisabled(a), h = r.getItemValue(a);
+    return {
+      value: h,
+      disabled: !!(p || p),
+      highlighted: b === h,
+      selected: t.context.value.includes(h)
+    };
+  }
+  return {
+    focused: v,
+    open: d,
+    inputValue: t.context.inputValue,
+    highlightedValue: b,
+    highlightedItem: t.context.highlightedItem,
+    value: t.context.value,
+    valueAsString: t.context.valueAsString,
+    hasSelectedItems: t.context.hasSelectedItems,
+    selectedItems: t.context.selectedItems,
+    collection: t.context.collection,
+    reposition(l = {}) {
+      n({ type: "POSITIONING.SET", options: l });
+    },
+    setCollection(l) {
+      n({ type: "COLLECTION.SET", value: l });
+    },
+    setHighlightValue(l) {
+      n({ type: "HIGHLIGHTED_VALUE.SET", value: l });
+    },
+    selectValue(l) {
+      n({ type: "ITEM.SELECT", value: l });
+    },
+    setValue(l) {
+      n({ type: "VALUE.SET", value: l });
+    },
+    setInputValue(l) {
+      n({ type: "INPUT_VALUE.SET", value: l });
+    },
+    clearValue(l) {
+      l != null ? n({ type: "ITEM.CLEAR", value: l }) : n("VALUE.CLEAR");
+    },
+    focus() {
+      var l;
+      (l = o.getInputEl(t.context)) == null || l.focus();
+    },
+    setOpen(l) {
+      l !== d && n(l ? "OPEN" : "CLOSE");
+    },
+    getRootProps() {
+      return e.element({
+        ...I.root.attrs,
+        dir: t.context.dir,
+        id: o.getRootId(t.context),
+        "data-invalid": u(O),
+        "data-readonly": u(V)
+      });
+    },
+    getLabelProps() {
+      return e.label({
+        ...I.label.attrs,
+        dir: t.context.dir,
+        htmlFor: o.getInputId(t.context),
+        id: o.getLabelId(t.context),
+        "data-readonly": u(V),
+        "data-disabled": u(s),
+        "data-invalid": u(O),
+        "data-focus": u(v),
+        onClick(l) {
+          var a;
+          E || (l.preventDefault(), (a = o.getTriggerEl(t.context)) == null || a.focus({ preventScroll: !0 }));
+        }
+      });
+    },
+    getControlProps() {
+      return e.element({
+        ...I.control.attrs,
+        dir: t.context.dir,
+        id: o.getControlId(t.context),
+        "data-state": d ? "open" : "closed",
+        "data-focus": u(v),
+        "data-disabled": u(s),
+        "data-invalid": u(O)
+      });
+    },
+    getPositionerProps() {
+      return e.element({
+        ...I.positioner.attrs,
+        dir: t.context.dir,
+        id: o.getPositionerId(t.context),
+        style: N.floating
+      });
+    },
+    getInputProps() {
+      return e.input({
+        ...I.input.attrs,
+        dir: t.context.dir,
+        "aria-invalid": A(O),
+        "data-invalid": u(O),
+        name: t.context.name,
+        form: t.context.form,
+        disabled: s,
+        autoFocus: t.context.autoFocus,
+        required: t.context.required,
+        autoComplete: "off",
+        autoCorrect: "off",
+        autoCapitalize: "none",
+        spellCheck: "false",
+        readOnly: V,
+        placeholder: t.context.placeholder,
+        id: o.getInputId(t.context),
+        type: "text",
+        role: "combobox",
+        defaultValue: t.context.inputValue,
+        "aria-autocomplete": t.context.autoComplete ? "both" : "list",
+        "aria-controls": o.getContentId(t.context),
+        "aria-expanded": d,
+        "data-state": d ? "open" : "closed",
+        "aria-activedescendant": b ? o.getItemId(t.context, b) : void 0,
+        onClick(l) {
+          l.defaultPrevented || t.context.openOnClick && c && n("INPUT.CLICK");
+        },
+        onFocus() {
+          s || n("INPUT.FOCUS");
+        },
+        onBlur() {
+          s || n("INPUT.BLUR");
+        },
+        onChange(l) {
+          n({ type: "INPUT.CHANGE", value: l.currentTarget.value });
+        },
+        onKeyDown(l) {
+          if (l.defaultPrevented || !c || l.ctrlKey || l.shiftKey || X(l)) return;
+          const a = t.context.openOnKeyPress, p = l.ctrlKey || l.metaKey || l.shiftKey, h = !0, y = {
+            ArrowDown(f) {
+              !a && !d || (n({ type: f.altKey ? "OPEN" : "INPUT.ARROW_DOWN", keypress: h }), f.preventDefault());
+            },
+            ArrowUp() {
+              !a && !d || (n({ type: l.altKey ? "CLOSE" : "INPUT.ARROW_UP", keypress: h }), l.preventDefault());
+            },
+            Home(f) {
+              p || (n({ type: "INPUT.HOME", keypress: h }), d && f.preventDefault());
+            },
+            End(f) {
+              p || (n({ type: "INPUT.END", keypress: h }), d && f.preventDefault());
+            },
+            Enter(f) {
+              n({ type: "INPUT.ENTER", keypress: h }), d && f.preventDefault();
+              const K = o.getHighlightedItemEl(t.context);
+              j(K);
+            },
+            Escape() {
+              n({ type: "INPUT.ESCAPE", keypress: h }), l.preventDefault();
+            }
+          }, w = U(l, t.context), k = y[w];
+          k == null || k(l);
+        }
+      });
+    },
+    getTriggerProps(l = {}) {
+      return e.button({
+        ...I.trigger.attrs,
+        dir: t.context.dir,
+        id: o.getTriggerId(t.context),
+        "aria-haspopup": E ? "listbox" : "dialog",
+        type: "button",
+        tabIndex: l.focusable ? void 0 : -1,
+        "aria-label": i.triggerLabel,
+        "aria-expanded": d,
+        "data-state": d ? "open" : "closed",
+        "aria-controls": d ? o.getContentId(t.context) : void 0,
+        disabled: s,
+        "data-invalid": u(O),
+        "data-focusable": u(l.focusable),
+        "data-readonly": u(V),
+        "data-disabled": u(s),
+        onFocus() {
+          l.focusable && n({ type: "INPUT.FOCUS", src: "trigger" });
+        },
+        onClick(a) {
+          a.defaultPrevented || c && Y(a) && n("TRIGGER.CLICK");
+        },
+        onPointerDown(a) {
+          c && a.pointerType !== "touch" && (a.preventDefault(), queueMicrotask(() => {
+            var p;
+            (p = o.getInputEl(t.context)) == null || p.focus({ preventScroll: !0 });
+          }));
+        },
+        onKeyDown(a) {
+          if (a.defaultPrevented || E) return;
+          const p = {
+            ArrowDown() {
+              n({ type: "INPUT.ARROW_DOWN", src: "trigger" });
+            },
+            ArrowUp() {
+              n({ type: "INPUT.ARROW_UP", src: "trigger" });
+            }
+          }, h = U(a, t.context), y = p[h];
+          y && (y(a), a.preventDefault());
+        }
+      });
+    },
+    getContentProps() {
+      return e.element({
+        ...I.content.attrs,
+        dir: t.context.dir,
+        id: o.getContentId(t.context),
+        role: E ? "listbox" : "dialog",
+        tabIndex: -1,
+        hidden: !d,
+        "data-state": d ? "open" : "closed",
+        "data-placement": t.context.currentPlacement,
+        "aria-labelledby": o.getLabelId(t.context),
+        "aria-multiselectable": t.context.multiple && E ? !0 : void 0,
+        onPointerDown(l) {
+          l.preventDefault();
+        }
+      });
+    },
+    getListProps() {
+      return e.element({
+        ...I.list.attrs,
+        role: E ? void 0 : "listbox",
+        "aria-labelledby": o.getLabelId(t.context),
+        "aria-multiselectable": t.context.multiple && !E ? !0 : void 0
+      });
+    },
+    getClearTriggerProps() {
+      return e.button({
+        ...I.clearTrigger.attrs,
+        dir: t.context.dir,
+        id: o.getClearTriggerId(t.context),
+        type: "button",
+        tabIndex: -1,
+        disabled: s,
+        "data-invalid": u(O),
+        "aria-label": i.clearTriggerLabel,
+        "aria-controls": o.getInputId(t.context),
+        hidden: !t.context.value.length,
+        onPointerDown(l) {
+          l.preventDefault();
+        },
+        onClick(l) {
+          l.defaultPrevented || c && n({ type: "VALUE.CLEAR", src: "clear-trigger" });
+        }
+      });
+    },
+    getItemState: T,
+    getItemProps(l) {
+      const a = T(l), p = a.value;
+      return e.element({
+        ...I.item.attrs,
+        dir: t.context.dir,
+        id: o.getItemId(t.context, p),
+        role: "option",
+        tabIndex: -1,
+        "data-highlighted": u(a.highlighted),
+        "data-state": a.selected ? "checked" : "unchecked",
+        "aria-selected": A(a.highlighted),
+        "aria-disabled": A(a.disabled),
+        "data-disabled": u(a.disabled),
+        "data-value": a.value,
+        onPointerMove() {
+          a.disabled || a.highlighted || n({ type: "ITEM.POINTER_MOVE", value: p });
+        },
+        onPointerLeave() {
+          l.persistFocus || a.disabled || !t.previousEvent.type.includes("POINTER") || n({ type: "ITEM.POINTER_LEAVE", value: p });
+        },
+        onClick(h) {
+          Z(h) || z(h) || q(h) || a.disabled || n({ type: "ITEM.CLICK", src: "click", value: p });
+        }
+      });
+    },
+    getItemTextProps(l) {
+      const a = T(l);
+      return e.element({
+        ...I.itemText.attrs,
+        dir: t.context.dir,
+        "data-state": a.selected ? "checked" : "unchecked",
+        "data-disabled": u(a.disabled),
+        "data-highlighted": u(a.highlighted)
+      });
+    },
+    getItemIndicatorProps(l) {
+      const a = T(l);
+      return e.element({
+        "aria-hidden": !0,
+        ...I.itemIndicator.attrs,
+        dir: t.context.dir,
+        "data-state": a.selected ? "checked" : "unchecked",
+        hidden: !a.selected
+      });
+    },
+    getItemGroupProps(l) {
+      const { id: a } = l;
+      return e.element({
+        ...I.itemGroup.attrs,
+        dir: t.context.dir,
+        id: o.getItemGroupId(t.context, a),
+        "aria-labelledby": o.getItemGroupLabelId(t.context, a)
+      });
+    },
+    getItemGroupLabelProps(l) {
+      const { htmlFor: a } = l;
+      return e.element({
+        ...I.itemGroupLabel.attrs,
+        dir: t.context.dir,
+        id: o.getItemGroupLabelId(t.context, a),
+        role: "group"
+      });
+    }
+  };
+}
+var { and: m, not: P } = $;
+function fe(t) {
+  const n = oe(t);
+  return W(
+    {
+      id: "combobox",
+      initial: n.open ? "suggesting" : "idle",
+      context: {
+        loopFocus: !0,
+        openOnClick: !1,
+        value: [],
+        highlightedValue: null,
+        inputValue: "",
+        allowCustomValue: !1,
+        closeOnSelect: !n.multiple,
+        inputBehavior: "none",
+        selectionBehavior: "replace",
+        openOnKeyPress: !0,
+        openOnChange: !0,
+        composite: !0,
+        readOnly: !1,
+        disabled: !1,
+        ...n,
+        highlightedItem: null,
+        selectedItems: [],
+        valueAsString: "",
+        collection: n.collection ?? _.empty(),
+        positioning: {
+          placement: "bottom",
+          flip: !1,
+          sameWidth: !0,
+          ...n.positioning
+        },
+        translations: {
+          triggerLabel: "Toggle suggestions",
+          clearTriggerLabel: "Clear value",
+          ...n.translations
+        }
+      },
+      created: ["syncInitialValues", "syncSelectionBehavior"],
+      computed: {
+        isInputValueEmpty: (e) => e.inputValue.length === 0,
+        isInteractive: (e) => !(e.readOnly || e.disabled),
+        autoComplete: (e) => e.inputBehavior === "autocomplete",
+        autoHighlight: (e) => e.inputBehavior === "autohighlight",
+        hasSelectedItems: (e) => e.value.length > 0
+      },
+      watch: {
+        value: ["syncSelectedItems"],
+        inputValue: ["syncInputValue"],
+        highlightedValue: ["syncHighlightedItem", "autofillInputValue"],
+        multiple: ["syncSelectionBehavior"],
+        open: ["toggleVisibility"]
+      },
+      on: {
+        "HIGHLIGHTED_VALUE.SET": {
+          actions: ["setHighlightedItem"]
+        },
+        "ITEM.SELECT": {
+          actions: ["selectItem"]
+        },
+        "ITEM.CLEAR": {
+          actions: ["clearItem"]
+        },
+        "VALUE.SET": {
+          actions: ["setSelectedItems"]
+        },
+        "INPUT_VALUE.SET": {
+          actions: "setInputValue"
+        },
+        "COLLECTION.SET": {
+          actions: ["setCollection"]
+        },
+        "POSITIONING.SET": {
+          actions: ["reposition"]
+        }
+      },
+      states: {
+        idle: {
+          tags: ["idle", "closed"],
+          entry: ["scrollContentToTop", "clearHighlightedItem"],
+          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", "clearHighlightedItem"],
+          on: {
+            "CONTROLLED.OPEN": [
+              {
+                guard: "isChangeEvent",
+                target: "suggesting"
+              },
+              {
+                target: "interacting"
+              }
+            ],
+            "INPUT.CHANGE": [
+              {
+                guard: m("isOpenControlled", "openOnChange"),
+                actions: ["setInputValue", "invokeOnOpen", "highlightFirstItemIfNeeded"]
+              },
+              {
+                guard: "openOnChange",
+                target: "suggesting",
+                actions: ["setInputValue", "invokeOnOpen", "highlightFirstItemIfNeeded"]
+              },
+              {
+                actions: "setInputValue"
+              }
+            ],
+            "LAYER.INTERACT_OUTSIDE": {
+              target: "idle"
+            },
+            "INPUT.ESCAPE": {
+              guard: m("isCustomValue", P("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: m("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: "autoComplete",
+                target: "interacting",
+                actions: "invokeOnOpen"
+              },
+              {
+                guard: "autoComplete",
+                target: "interacting",
+                actions: "invokeOnOpen"
+              },
+              // == group 2 ==
+              {
+                target: "interacting",
+                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"],
+          activities: ["scrollToHighlightedItem", "trackDismissableLayer", "computePlacement", "hideOtherElements"],
+          on: {
+            "CONTROLLED.CLOSE": [
+              {
+                guard: "restoreFocus",
+                target: "focused",
+                actions: ["setFinalFocus"]
+              },
+              {
+                target: "idle"
+              }
+            ],
+            "INPUT.HOME": {
+              actions: ["highlightFirstItem"]
+            },
+            "INPUT.END": {
+              actions: ["highlightLastItem"]
+            },
+            "INPUT.ARROW_DOWN": [
+              {
+                guard: m("autoComplete", "isLastItemHighlighted"),
+                actions: ["clearHighlightedItem", "scrollContentToTop"]
+              },
+              {
+                actions: ["highlightNextItem"]
+              }
+            ],
+            "INPUT.ARROW_UP": [
+              {
+                guard: m("autoComplete", "isFirstItemHighlighted"),
+                actions: "clearHighlightedItem"
+              },
+              {
+                actions: "highlightPrevItem"
+              }
+            ],
+            "INPUT.ENTER": [
+              {
+                guard: m("isOpenControlled", "closeOnSelect"),
+                actions: ["selectHighlightedItem", "invokeOnClose"]
+              },
+              {
+                guard: "closeOnSelect",
+                target: "focused",
+                actions: ["selectHighlightedItem", "invokeOnClose", "setFinalFocus"]
+              },
+              {
+                actions: ["selectHighlightedItem"]
+              }
+            ],
+            "INPUT.CHANGE": [
+              {
+                guard: "autoComplete",
+                target: "suggesting",
+                actions: ["setInputValue", "invokeOnOpen"]
+              },
+              {
+                target: "suggesting",
+                actions: ["clearHighlightedItem", "setInputValue", "invokeOnOpen"]
+              }
+            ],
+            "ITEM.POINTER_MOVE": {
+              actions: ["setHighlightedItem"]
+            },
+            "ITEM.POINTER_LEAVE": {
+              actions: ["clearHighlightedItem"]
+            },
+            "ITEM.CLICK": [
+              {
+                guard: m("isOpenControlled", "closeOnSelect"),
+                actions: ["selectItem", "invokeOnClose"]
+              },
+              {
+                guard: "closeOnSelect",
+                target: "focused",
+                actions: ["selectItem", "invokeOnClose", "setFinalFocus"]
+              },
+              {
+                actions: ["selectItem"]
+              }
+            ],
+            "LAYER.ESCAPE": [
+              {
+                guard: m("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: m("isOpenControlled", "isCustomValue", P("allowCustomValue")),
+                actions: ["revertInputValue", "invokeOnClose"]
+              },
+              {
+                guard: m("isCustomValue", P("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"],
+          activities: [
+            "trackDismissableLayer",
+            "scrollToHighlightedItem",
+            "computePlacement",
+            "trackChildNodes",
+            "hideOtherElements"
+          ],
+          entry: ["setInitialFocus"],
+          on: {
+            "CONTROLLED.CLOSE": [
+              {
+                guard: "restoreFocus",
+                target: "focused",
+                actions: ["setFinalFocus"]
+              },
+              {
+                target: "idle"
+              }
+            ],
+            CHILDREN_CHANGE: {
+              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": [
+              {
+                guard: m("isOpenControlled", "closeOnSelect"),
+                actions: ["selectHighlightedItem", "invokeOnClose"]
+              },
+              {
+                guard: "closeOnSelect",
+                target: "focused",
+                actions: ["selectHighlightedItem", "invokeOnClose", "setFinalFocus"]
+              },
+              {
+                actions: ["selectHighlightedItem"]
+              }
+            ],
+            "INPUT.CHANGE": [
+              {
+                guard: "autoHighlight",
+                actions: ["setInputValue"]
+              },
+              {
+                actions: ["setInputValue"]
+              }
+            ],
+            "LAYER.ESCAPE": [
+              {
+                guard: "isOpenControlled",
+                actions: ["invokeOnClose"]
+              },
+              {
+                target: "focused",
+                actions: ["invokeOnClose"]
+              }
+            ],
+            "ITEM.POINTER_MOVE": {
+              target: "interacting",
+              actions: ["setHighlightedItem"]
+            },
+            "ITEM.POINTER_LEAVE": {
+              actions: ["clearHighlightedItem"]
+            },
+            "LAYER.INTERACT_OUTSIDE": [
+              // == group 1 ==
+              {
+                guard: m("isOpenControlled", "isCustomValue", P("allowCustomValue")),
+                actions: ["revertInputValue", "invokeOnClose"]
+              },
+              {
+                guard: m("isCustomValue", P("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: m("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"]
+              }
+            ]
+          }
+        }
+      }
+    },
+    {
+      guards: {
+        isInputValueEmpty: (e) => e.isInputValueEmpty,
+        autoComplete: (e) => e.autoComplete && !e.multiple,
+        autoHighlight: (e) => e.autoHighlight,
+        isFirstItemHighlighted: (e) => e.collection.firstValue === e.highlightedValue,
+        isLastItemHighlighted: (e) => e.collection.lastValue === e.highlightedValue,
+        isCustomValue: (e) => e.inputValue !== e.valueAsString,
+        allowCustomValue: (e) => !!e.allowCustomValue,
+        hasHighlightedItem: (e) => e.highlightedValue != null,
+        closeOnSelect: (e) => !!e.closeOnSelect,
+        isOpenControlled: (e) => !!e["open.controlled"],
+        openOnChange: (e, i) => {
+          var r;
+          return ae(e.openOnChange) ? e.openOnChange : !!((r = e.openOnChange) != null && r.call(e, { inputValue: i.value }));
+        },
+        restoreFocus: (e, i) => i.restoreFocus == null ? !0 : !!i.restoreFocus,
+        isChangeEvent: (e, i) => {
+          var r;
+          return ((r = i.previousEvent) == null ? void 0 : r.type) === "INPUT.CHANGE";
+        }
+      },
+      activities: {
+        trackDismissableLayer(e, i, { send: r }) {
+          return e.disableLayer ? void 0 : le(() => o.getContentEl(e), {
+            defer: !0,
+            exclude: () => [o.getInputEl(e), o.getTriggerEl(e), o.getClearTriggerEl(e)],
+            onFocusOutside: e.onFocusOutside,
+            onPointerDownOutside: e.onPointerDownOutside,
+            onInteractOutside: e.onInteractOutside,
+            onEscapeKeyDown(c) {
+              c.preventDefault(), c.stopPropagation(), r("LAYER.ESCAPE");
+            },
+            onDismiss() {
+              r({ type: "LAYER.INTERACT_OUTSIDE", restoreFocus: !1 });
+            }
+          });
+        },
+        hideOtherElements(e) {
+          return ie([o.getInputEl(e), o.getContentEl(e), o.getTriggerEl(e)]);
+        },
+        computePlacement(e) {
+          const i = () => o.getControlEl(e), r = () => o.getPositionerEl(e);
+          return e.currentPlacement = e.positioning.placement, H(i, r, {
+            ...e.positioning,
+            defer: !0,
+            onComplete(s) {
+              e.currentPlacement = s.placement;
+            }
+          });
+        },
+        // in event the options are fetched (async), we still want to auto-highlight the first option
+        trackChildNodes(e, i, { send: r }) {
+          return e.autoHighlight ? x(() => o.getContentEl(e), {
+            callback: () => r("CHILDREN_CHANGE"),
+            defer: !0
+          }) : void 0;
+        },
+        scrollToHighlightedItem(e, i, { getState: r }) {
+          const s = o.getInputEl(e);
+          let c = [];
+          const O = (v) => {
+            if (r().event.type.includes("POINTER") || !e.highlightedValue) return;
+            const N = o.getHighlightedItemEl(e), T = o.getContentEl(e);
+            if (e.scrollToIndexFn) {
+              const a = e.collection.indexOf(e.highlightedValue);
+              e.scrollToIndexFn({ index: a, immediate: v });
+              return;
+            }
+            const l = C(() => {
+              te(N, { rootEl: T, block: "nearest" });
+            });
+            c.push(l);
+          }, V = C(() => O(!0));
+          c.push(V);
+          const d = ee(s, {
+            attributes: ["aria-activedescendant"],
+            callback: () => O(!1)
+          });
+          return c.push(d), () => {
+            c.forEach((v) => v());
+          };
+        }
+      },
+      actions: {
+        reposition(e, i) {
+          H(() => o.getControlEl(e), () => o.getPositionerEl(e), {
+            ...e.positioning,
+            ...i.options,
+            defer: !0,
+            listeners: !1,
+            onComplete(c) {
+              e.currentPlacement = c.placement;
+            }
+          });
+        },
+        setHighlightedItem(e, i) {
+          i.value != null && g.highlightedValue(e, i.value);
+        },
+        clearHighlightedItem(e) {
+          g.highlightedValue(e, null, !0);
+        },
+        selectHighlightedItem(e) {
+          g.value(e, e.highlightedValue);
+        },
+        selectItem(e, i) {
+          i.value != null && g.value(e, i.value);
+        },
+        clearItem(e, i) {
+          if (i.value == null) return;
+          const r = e.value.filter((s) => s !== i.value);
+          g.value(e, r);
+        },
+        setInitialFocus(e) {
+          C(() => {
+            o.focusInputEl(e);
+          });
+        },
+        setFinalFocus(e) {
+          C(() => {
+            const i = o.getTriggerEl(e);
+            (i == null ? void 0 : i.dataset.focusable) == null ? o.focusInputEl(e) : o.focusTriggerEl(e);
+          });
+        },
+        syncInputValue(e) {
+          const i = o.getInputEl(e);
+          i && (i.value = e.inputValue, queueMicrotask(() => {
+            const { selectionStart: r, selectionEnd: s } = i;
+            Math.abs((s ?? 0) - (r ?? 0)) === 0 && r === 0 && i.setSelectionRange(i.value.length, i.value.length);
+          }));
+        },
+        setInputValue(e, i) {
+          g.inputValue(e, i.value);
+        },
+        clearInputValue(e) {
+          g.inputValue(e, "");
+        },
+        revertInputValue(e) {
+          const i = R(e.selectionBehavior, {
+            replace: e.hasSelectedItems ? e.valueAsString : "",
+            preserve: e.inputValue,
+            clear: ""
+          });
+          g.inputValue(e, i);
+        },
+        syncInitialValues(e) {
+          const i = e.collection.findMany(e.value), r = e.collection.stringifyMany(e.value);
+          e.highlightedItem = e.collection.find(e.highlightedValue), e.selectedItems = i, e.valueAsString = r, !(e.inputValue.trim() || e.multiple) && (e.inputValue = R(e.selectionBehavior, {
+            preserve: e.inputValue || r,
+            replace: r,
+            clear: ""
+          }));
+        },
+        syncSelectionBehavior(e) {
+          e.multiple && (e.selectionBehavior = "clear");
+        },
+        setSelectedItems(e, i) {
+          G(i.value) && g.value(e, i.value);
+        },
+        clearSelectedItems(e) {
+          g.value(e, []);
+        },
+        scrollContentToTop(e) {
+          if (e.scrollToIndexFn)
+            e.scrollToIndexFn({ index: 0, immediate: !0 });
+          else {
+            const i = o.getContentEl(e);
+            if (!i) return;
+            i.scrollTop = 0;
+          }
+        },
+        invokeOnOpen(e) {
+          var i;
+          (i = e.onOpenChange) == null || i.call(e, { open: !0 });
+        },
+        invokeOnClose(e) {
+          var i;
+          (i = e.onOpenChange) == null || i.call(e, { open: !1 });
+        },
+        highlightFirstItem(e) {
+          C(() => {
+            const i = e.collection.firstValue;
+            g.highlightedValue(e, i);
+          });
+        },
+        highlightFirstItemIfNeeded(e) {
+          e.autoHighlight && C(() => {
+            const i = e.collection.firstValue;
+            g.highlightedValue(e, i);
+          });
+        },
+        highlightLastItem(e) {
+          C(() => {
+            const i = e.collection.lastValue;
+            g.highlightedValue(e, i);
+          });
+        },
+        highlightNextItem(e) {
+          let i = null;
+          e.highlightedValue ? (i = e.collection.getNextValue(e.highlightedValue), !i && e.loopFocus && (i = e.collection.firstValue)) : i = e.collection.firstValue, g.highlightedValue(e, i);
+        },
+        highlightPrevItem(e) {
+          let i = null;
+          e.highlightedValue ? (i = e.collection.getPreviousValue(e.highlightedValue), !i && e.loopFocus && (i = e.collection.lastValue)) : i = e.collection.lastValue, g.highlightedValue(e, i);
+        },
+        highlightFirstSelectedItem(e) {
+          C(() => {
+            const [i] = e.collection.sort(e.value);
+            g.highlightedValue(e, i);
+          });
+        },
+        highlightFirstOrSelectedItem(e) {
+          C(() => {
+            let i = null;
+            e.hasSelectedItems ? i = e.collection.sort(e.value)[0] : i = e.collection.firstValue, g.highlightedValue(e, i);
+          });
+        },
+        highlightLastOrSelectedItem(e) {
+          C(() => {
+            let i = null;
+            e.hasSelectedItems ? i = e.collection.sort(e.value)[0] : i = e.collection.lastValue, g.highlightedValue(e, i);
+          });
+        },
+        autofillInputValue(e, i) {
+          const r = o.getInputEl(e);
+          if (!e.autoComplete || !r || !i.keypress) return;
+          const s = e.collection.stringify(e.highlightedValue);
+          C(() => {
+            r.value = s || e.inputValue;
+          });
+        },
+        setCollection(e, i) {
+          e.collection = i.value;
+        },
+        syncSelectedItems(e) {
+          L.valueChange(e);
+        },
+        syncHighlightedItem(e) {
+          L.highlightChange(e);
+        },
+        toggleVisibility(e, i, { send: r }) {
+          r({ type: e.open ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE", previousEvent: i });
+        }
+      }
+    }
+  );
+}
+var L = {
+  valueChange: (t) => {
+    const n = t.selectedItems;
+    t.selectedItems = t.value.map((r) => {
+      const s = n.find((c) => t.collection.getItemValue(c) === r);
+      return s || t.collection.find(r);
+    });
+    const e = t.collection.stringifyItems(t.selectedItems);
+    t.valueAsString = e;
+    let i;
+    t.getSelectionValue ? i = t.getSelectionValue({
+      inputValue: t.inputValue,
+      selectedItems: Array.from(t.selectedItems),
+      valueAsString: e
+    }) : i = R(t.selectionBehavior, {
+      replace: t.valueAsString,
+      preserve: t.inputValue,
+      clear: ""
+    }), g.inputValue(t, i);
+  },
+  highlightChange: (t) => {
+    t.highlightedItem = t.collection.find(t.highlightedValue);
+  }
+}, S = {
+  valueChange: (t) => {
+    var n;
+    L.valueChange(t), (n = t.onValueChange) == null || n.call(t, {
+      value: Array.from(t.value),
+      items: Array.from(t.selectedItems)
+    });
+  },
+  highlightChange: (t) => {
+    var n;
+    L.highlightChange(t), (n = t.onHighlightChange) == null || n.call(t, {
+      highlightedValue: t.highlightedValue,
+      highlightedItem: t.highlightedItem
+    });
+  },
+  inputChange: (t) => {
+    var n;
+    (n = t.onInputValueChange) == null || n.call(t, { inputValue: t.inputValue });
+  }
+}, g = {
+  value: (t, n, e = !1) => {
+    if (!F(t.value, n) && !(n == null && !e)) {
+      if (n == null && e) {
+        t.value = [], S.valueChange(t);
+        return;
+      }
+      G(n) ? t.value = n : n != null && (t.value = t.multiple ? re(t.value, n) : [n]), S.valueChange(t);
+    }
+  },
+  highlightedValue: (t, n, e = !1) => {
+    F(t.highlightedValue, n) || !n && !e || (t.highlightedValue = n || null, S.highlightChange(t));
+  },
+  inputValue: (t, n) => {
+    F(t.inputValue, n) || (t.inputValue = n, S.inputChange(t));
+  }
+};
+export {
+  se as anatomy,
+  _ as collection,
+  Ee as connect,
+  fe as machine
+};