import { jsx as g, jsxs as ve, Fragment as He } from "react/jsx-runtime";
import { useReducer as St, useRef as A, useEffect as Y, createContext as Qe, useMemo as _, useContext as Pe, useState as Z, useCallback as R, isValidElement as wt, cloneElement as $t } from "react";
import { d as Kt } from "./Header-CiYtrnTw.es.js";
import { $ as Xe, a as It, b as Bt, c as Mt, d as At } from "./ListBox-RrHJjnuq.es.js";
import { f as Ft, g as Ot } from "./CollectionBuilder-BOe312C_.es.js";
import { createSlotRecipeContext as Vt } from "@chakra-ui/react";
import { Close as Lt, KeyboardArrowDown as Tt, Check as Et } from "@commercetools/nimbus-icons";
import { e as fe } from "./extract-style-props-BdibuNZ7.es.js";
import { P as Rt } from "./popover-CuA9VugH.es.js";
import { I as Ue } from "./icon-button-CosIm3oY.es.js";
import { L as Pt } from "./loading-spinner-gf62wtm3.es.js";
import { $ as Me, a as Dt } from "./Input-Cmg08oRP.es.js";
import { $ as De, T as Te } from "./tag-group-BE8d6xcP.es.js";
import { useSlotRecipe as zt } from "@chakra-ui/react/styled-system";
import { b as Nt } from "./RSPContexts-DLgb84PF.es.js";
import { $ as Ee } from "./Button-BjcDZ5eb.es.js";
import { $ as kt, e as Ye } from "./utils-B6pV5ewr.es.js";
import { a as Wt } from "./Group-BQc9LuMT.es.js";
import { $ as Gt } from "./Label-DIseLESi.es.js";
import { h as qt } from "./Dialog-B0BQfdQa.es.js";
import { $ as jt } from "./Text-DOcU1ycg.es.js";
import { n as xe, u as Ht } from "./normalize-messages-D5T4I93D.es.js";
import { $ as Ut } from "./useListData-CX8_NxJv.es.js";
import { a as Je } from "./mergeProps-Dsl8k3Ig.es.js";
import { a as Jt } from "./useListState-Dd0Mtev3.es.js";
function Qt(e, t) {
  let r;
  switch (e.state) {
    case "idle":
    case "error":
      switch (t.type) {
        case "loading":
        case "loadingMore":
        case "sorting":
        case "filtering":
          var s, o;
          return {
            ...e,
            filterText: (s = t.filterText) !== null && s !== void 0 ? s : e.filterText,
            state: t.type,
            // Reset items to an empty list if loading, but not when sorting.
            items: t.type === "loading" ? [] : e.items,
            sortDescriptor: (o = t.sortDescriptor) !== null && o !== void 0 ? o : e.sortDescriptor,
            abortController: t.abortController
          };
        case "update":
          var n;
          return {
            ...e,
            ...(n = t.updater) === null || n === void 0 ? void 0 : n.call(t, e)
          };
        case "success":
        case "error":
          return e;
        default:
          throw new Error(`Invalid action "${t.type}" in state "${e.state}"`);
      }
    case "loading":
    case "sorting":
    case "filtering":
      switch (t.type) {
        case "success":
          if (t.abortController !== e.abortController) return e;
          var c;
          r = (c = t.selectedKeys) !== null && c !== void 0 ? c : e.selectedKeys;
          var l, u, b;
          return {
            ...e,
            filterText: (l = t.filterText) !== null && l !== void 0 ? l : e.filterText,
            state: "idle",
            items: [
              ...(u = t.items) !== null && u !== void 0 ? u : []
            ],
            selectedKeys: r === "all" ? "all" : new Set(r),
            sortDescriptor: (b = t.sortDescriptor) !== null && b !== void 0 ? b : e.sortDescriptor,
            abortController: void 0,
            cursor: t.cursor
          };
        case "error":
          return t.abortController !== e.abortController ? e : {
            ...e,
            state: "error",
            error: t.error,
            abortController: void 0
          };
        case "loading":
        case "loadingMore":
        case "sorting":
        case "filtering":
          var h;
          (h = e.abortController) === null || h === void 0 || h.abort();
          var d;
          return {
            ...e,
            filterText: (d = t.filterText) !== null && d !== void 0 ? d : e.filterText,
            state: t.type,
            // Reset items to an empty list if loading, but not when sorting.
            items: t.type === "loading" ? [] : e.items,
            abortController: t.abortController
          };
        case "update":
          var w;
          return {
            ...e,
            ...(w = t.updater) === null || w === void 0 ? void 0 : w.call(t, e)
          };
        default:
          throw new Error(`Invalid action "${t.type}" in state "${e.state}"`);
      }
    case "loadingMore":
      switch (t.type) {
        case "success":
          var p;
          r = e.selectedKeys === "all" || t.selectedKeys === "all" ? "all" : /* @__PURE__ */ new Set([
            ...e.selectedKeys,
            ...(p = t.selectedKeys) !== null && p !== void 0 ? p : []
          ]);
          var K, T;
          return {
            ...e,
            state: "idle",
            items: [
              ...e.items,
              ...(K = t.items) !== null && K !== void 0 ? K : []
            ],
            selectedKeys: r,
            sortDescriptor: (T = t.sortDescriptor) !== null && T !== void 0 ? T : e.sortDescriptor,
            abortController: void 0,
            cursor: t.cursor
          };
        case "error":
          return t.abortController !== e.abortController ? e : {
            ...e,
            state: "error",
            error: t.error
          };
        case "loading":
        case "sorting":
        case "filtering":
          var I;
          (I = e.abortController) === null || I === void 0 || I.abort();
          var y;
          return {
            ...e,
            filterText: (y = t.filterText) !== null && y !== void 0 ? y : e.filterText,
            state: t.type,
            // Reset items to an empty list if loading, but not when sorting.
            items: t.type === "loading" ? [] : e.items,
            abortController: t.abortController
          };
        case "loadingMore":
          var F;
          return (F = t.abortController) === null || F === void 0 || F.abort(), e;
        case "update":
          var $;
          return {
            ...e,
            ...($ = t.updater) === null || $ === void 0 ? void 0 : $.call(t, e)
          };
        default:
          throw new Error(`Invalid action "${t.type}" in state "${e.state}"`);
      }
    default:
      throw new Error(`Invalid state "${e.state}"`);
  }
}
function Xt(e) {
  const { load: t, sort: r, initialSelectedKeys: s, initialSortDescriptor: o, getKey: n = (d) => d.id || d.key, initialFilterText: c = "" } = e;
  let [l, u] = St(Qt, {
    state: "idle",
    error: void 0,
    items: [],
    selectedKeys: s === "all" ? "all" : new Set(s),
    sortDescriptor: o,
    filterText: c
  });
  const b = async (d, w) => {
    let p = new AbortController();
    try {
      u({
        ...d,
        abortController: p
      });
      var K;
      let y = (K = d.filterText) !== null && K !== void 0 ? K : l.filterText;
      var T;
      let F = await w({
        items: l.items.slice(),
        selectedKeys: l.selectedKeys,
        sortDescriptor: (T = d.sortDescriptor) !== null && T !== void 0 ? T : l.sortDescriptor,
        signal: p.signal,
        cursor: d.type === "loadingMore" ? l.cursor : void 0,
        filterText: y,
        loadingState: l.state
      });
      var I;
      let $ = (I = F.filterText) !== null && I !== void 0 ? I : y;
      u({
        type: "success",
        ...F,
        abortController: p
      }), $ && $ !== y && !p.signal.aborted && b({
        type: "filtering",
        filterText: $
      }, t);
    } catch (y) {
      u({
        type: "error",
        error: y,
        abortController: p
      });
    }
  };
  let h = A(!1);
  return Y(() => {
    h.current || (b({
      type: "loading"
    }, t), h.current = !0);
  }, []), {
    items: l.items,
    selectedKeys: l.selectedKeys,
    sortDescriptor: l.sortDescriptor,
    isLoading: l.state === "loading" || l.state === "loadingMore" || l.state === "sorting" || l.state === "filtering",
    loadingState: l.state,
    error: l.error,
    filterText: l.filterText,
    getItem(d) {
      return l.items.find((w) => n(w) === d);
    },
    reload() {
      b({
        type: "loading"
      }, t);
    },
    loadMore() {
      l.state === "loading" || l.state === "loadingMore" || l.state === "filtering" || l.cursor == null || b({
        type: "loadingMore"
      }, t);
    },
    sort(d) {
      b({
        type: "sorting",
        sortDescriptor: d
      }, r || t);
    },
    ...Ut({
      ...e,
      getKey: n,
      cursor: l.cursor
    }, (d) => {
      u({
        type: "update",
        updater: d
      });
    }),
    setFilterText(d) {
      b({
        type: "filtering",
        filterText: d
      }, t);
    }
  };
}
const Yt = /* @__PURE__ */ Qe(null);
function Zt(e, t, r, s) {
  var o = this, n = A(null), c = A(0), l = A(0), u = A(null), b = A([]), h = A(), d = A(), w = A(e), p = A(!0), K = A(), T = A();
  w.current = e;
  var I = typeof window < "u", y = !t && t !== 0 && I;
  if (typeof e != "function") throw new TypeError("Expected a function");
  t = +t || 0;
  var F = !!(r = r || {}).leading, $ = !("trailing" in r) || !!r.trailing, H = !!r.flushOnExit && $, U = "maxWait" in r, q = "debounceOnServer" in r && !!r.debounceOnServer, J = U ? Math.max(+r.maxWait || 0, t) : null, ne = _(function() {
    var P = function(x) {
      var O = b.current, D = h.current;
      return b.current = h.current = null, c.current = x, l.current = l.current || x, d.current = w.current.apply(D, O);
    }, Q = function(x, O) {
      y && cancelAnimationFrame(u.current), u.current = y ? requestAnimationFrame(x) : setTimeout(x, O);
    }, se = function(x) {
      if (!p.current) return !1;
      var O = x - n.current;
      return !n.current || O >= t || O < 0 || U && x - c.current >= J;
    }, le = function(x) {
      return u.current = null, $ && b.current ? P(x) : (b.current = h.current = null, d.current);
    }, B = function x() {
      var O = Date.now();
      if (F && l.current === c.current && me(), se(O)) return le(O);
      if (p.current) {
        var D = t - (O - n.current), j = U ? Math.min(D, J - (O - c.current)) : D;
        Q(x, j);
      }
    }, me = function() {
    }, ee = function() {
      if (I || q) {
        var x, O = Date.now(), D = se(O);
        if (b.current = [].slice.call(arguments), h.current = o, n.current = O, H && !K.current && (K.current = function() {
          var j;
          ((j = global.document) == null ? void 0 : j.visibilityState) === "hidden" && T.current.flush();
        }, (x = global.document) == null || x.addEventListener == null || x.addEventListener("visibilitychange", K.current)), D) {
          if (!u.current && p.current) return c.current = n.current, Q(B, t), F ? P(n.current) : d.current;
          if (U) return Q(B, t), P(n.current);
        }
        return u.current || Q(B, t), d.current;
      }
    };
    return ee.cancel = function() {
      var x = u.current;
      x && (y ? cancelAnimationFrame(u.current) : clearTimeout(u.current)), c.current = 0, b.current = n.current = h.current = u.current = null;
    }, ee.isPending = function() {
      return !!u.current;
    }, ee.flush = function() {
      return u.current ? le(Date.now()) : d.current;
    }, ee;
  }, [F, U, t, J, $, H, y, I, q, s]);
  return T.current = ne, Y(function() {
    return p.current = !0, function() {
      var P;
      H && T.current.flush(), K.current && ((P = global.document) == null || P.removeEventListener == null || P.removeEventListener("visibilitychange", K.current), K.current = null), p.current = !1;
    };
  }, [H]), ne;
}
const { withProvider: _t, withContext: G } = /* @__PURE__ */ Vt({
  key: "combobox"
}), er = /* @__PURE__ */ _t("div", "root"), tr = /* @__PURE__ */ G("div", "trigger"), rr = /* @__PURE__ */ G("div", "leadingElement"), or = /* @__PURE__ */ G("div", "content"), nr = /* @__PURE__ */ G("div", "tagGroup"), sr = /* @__PURE__ */ G("div", "input"), lr = /* @__PURE__ */ G("div", "popover"), ir = /* @__PURE__ */ G("div", "listBox"), cr = /* @__PURE__ */ G("div", "section"), ar = /* @__PURE__ */ G("div", "option"), ur = /* @__PURE__ */ G("div", "optionIndicator"), dr = /* @__PURE__ */ G("div", "optionContent"), fr = {
  clearSelection: "Clear selection",
  toggleOptions: "Toggle options",
  selectedValues: "Selected values",
  options: "Options menu"
}, mr = {
  clearSelection: "Auswahl löschen",
  toggleOptions: "Optionen umschalten",
  selectedValues: "Ausgewählte Werte",
  options: "Optionsmenü"
}, pr = {
  clearSelection: "Borrar selección",
  toggleOptions: "Alternar opciones",
  selectedValues: "Valores seleccionados",
  options: "Menú de opciones"
}, gr = {
  clearSelection: "Effacer la sélection",
  toggleOptions: "Basculer les options",
  selectedValues: "Valeurs sélectionnées",
  options: "Menu des options"
}, yr = {
  clearSelection: "Limpar seleção",
  toggleOptions: "Alternar opções",
  selectedValues: "Valores selecionados",
  options: "Menu de opções"
}, br = {
  en: /* @__PURE__ */ xe(fr),
  de: /* @__PURE__ */ xe(mr),
  es: /* @__PURE__ */ xe(pr),
  "fr-FR": /* @__PURE__ */ xe(gr),
  "pt-BR": /* @__PURE__ */ xe(yr)
};
function Ze(e) {
  if (typeof e == "string" || typeof e == "number")
    return e;
  if ("id" in e)
    return e.id;
  throw new Error(
    "ComboBox - Item must have an 'id' property or provide getKey function"
  );
}
function hr(e) {
  return typeof e == "string" ? e : "name" in e ? String(e.name) : "label" in e ? String(e.label) : (console.warn(
    "ComboBox - Item should have 'name' or 'label' property. Provide a getTextValue function to ensure proper item display and filtering."
  ), String(e));
}
function xr(e) {
  return {
    id: e,
    name: e
  };
}
const vr = (e) => e ? e instanceof Set ? e : new Set(Array.isArray(e) ? e : [e]) : /* @__PURE__ */ new Set(), Cr = (e) => Array.from(e), Re = /* @__PURE__ */ Qe(null), Ae = () => {
  const e = Pe(Re);
  if (!e)
    throw new Error(
      "Nimbus - ComboBox components must be used within ComboBox.Root"
    );
  return e;
}, _e = (e) => {
  const {
    name: t,
    form: r,
    selectedKeys: s,
    selectionMode: o,
    formValue: n,
    allowsCustomOptions: c,
    collection: l,
    inputValue: u
  } = e;
  if (!t) return null;
  const b = _(() => {
    if (o === "single") {
      const h = Array.from(s)[0];
      return h ? n === "text" || c ? Array.from(l).find(
        (w) => w.key === h
      )?.textValue || u || "" : String(h) : "";
    } else {
      const h = Array.from(s);
      return n === "text" || c ? h.map((d) => Array.from(l).find(
        (p) => p.key === d
      )?.textValue || "").filter(Boolean).join(",") : h.join(",");
    }
  }, [
    o,
    s,
    n,
    c,
    l,
    u
  ]);
  return /* @__PURE__ */ g(
    "input",
    {
      type: "hidden",
      name: t,
      form: typeof r == "string" ? r : void 0,
      value: b
    }
  );
};
_e.displayName = "ComboBoxHiddenInput";
function et(e) {
  let t;
  [e, t] = kt(e, null, Yt);
  const {
    selectionMode: r = "single",
    size: s = "md",
    getKey: o = Ze,
    getTextValue: n = hr,
    children: c,
    leadingElement: l,
    inputValue: u,
    onInputChange: b,
    isLoading: h,
    allowsEmptyMenu: d,
    renderEmptyState: w,
    async: p,
    filter: K,
    allowsCustomOptions: T = !1,
    isDisabled: I = !1,
    isInvalid: y = !1,
    isRequired: F = !1,
    isReadOnly: $ = !1
  } = e, H = zt({ key: "combobox" }), [U, q] = H.splitVariantProps(e), [J, ne] = fe(q), P = A(null), Q = A(null), [se, le] = Z([]), B = Xt({
    getKey: o,
    async load({ signal: M, filterText: k }) {
      if (!p) return { items: [] };
      const v = p.minSearchLength ?? 0;
      if (!k || k.length < v)
        return { items: [] };
      try {
        return { items: await p.load(k, M) };
      } catch (V) {
        if (V.name === "AbortError")
          throw V;
        const te = V;
        return p.onError?.(te), { items: [] };
      }
    }
  }), [me, ee] = Z(u), [x, O] = Z(!1), [D, j] = Z([]), Fe = p?.debounce ?? 300, Ce = Zt((M) => {
    O(!1), B.setFilterText(M);
  }, Fe), Se = R(
    (M) => {
      ee(M), O(!0), Ce(M);
    },
    [Ce]
  ), z = p ? me : u, we = p ? Se : b, X = p ? x || B.loadingState === "loading" || B.loadingState === "loadingMore" || B.loadingState === "filtering" : h, $e = p || T ? !0 : d, Ke = R(() => X ? z?.length ? `loading results for "${z}"` : "loading results" : z?.length && p?.minSearchLength && z.length >= p.minSearchLength ? `no results for "${z}"` : p?.minSearchLength ? `enter at least ${p?.minSearchLength} characters` : "type to search", [p?.minSearchLength, X, z]), Ie = R(() => X ? z?.length ? `loading results for "${z}"` : "loading results" : 'hit "enter" to create an option', [X, z]), ge = (T ? Ie : p ? Ke : void 0) ?? w, ue = _(() => {
    const M = p ? Array.from(B.items) : e.items, k = M ? Array.from(M) : [], v = new Set(k.map((ie) => o(ie)));
    let te = [...se.filter(
      (ie) => !v.has(o(ie))
    ), ...k];
    if (p && r === "multiple" && D.length > 0) {
      const ie = new Set(te.map((L) => o(L)));
      te = [...D.filter(
        (L) => !ie.has(o(L))
      ), ...te];
    }
    return te;
  }, [
    p,
    B.items,
    e.items,
    se,
    D,
    r,
    o
  ]), ye = _(
    () => ({
      selectionMode: r,
      size: s,
      getKey: o,
      getTextValue: n,
      leadingElement: l,
      triggerRef: P,
      inputRef: Q,
      isLoading: X,
      isDisabled: I,
      isRequired: F,
      isInvalid: y,
      isReadOnly: $
    }),
    [
      r,
      o,
      n,
      l,
      P,
      Q,
      I,
      F,
      y,
      $
    ]
  ), be = _(() => {
    if (ue)
      return Array.from(ue).map((M) => {
        const k = "id" in M, v = "textValue" in M;
        return k && v ? M : {
          ...M,
          ...k ? {} : { id: o(M) },
          ...v ? {} : { textValue: n(M) }
        };
      });
  }, [ue, o, n]), Oe = _(
    () => /* @__PURE__ */ g(
      Re.Provider,
      {
        value: ye,
        children: /* @__PURE__ */ g(Xe.Provider, { value: { items: be }, children: typeof c == "function" ? c({
          isOpen: !1,
          isDisabled: I,
          isInvalid: y,
          isRequired: F,
          defaultChildren: null
        }) : c })
      }
    ),
    [
      c,
      I,
      y,
      F,
      be,
      ye
    ]
  );
  return /* @__PURE__ */ g(
    Ye,
    {
      values: [
        [Ee, {}],
        [Me, {}],
        [De, {}]
      ],
      children: /* @__PURE__ */ g(
        Re.Provider,
        {
          value: ye,
          children: /* @__PURE__ */ g(
            er,
            {
              ref: t,
              ...U,
              ...J,
              size: s,
              "data-disabled": I,
              "data-invalid": y,
              "data-required": F,
              "data-readonly": $,
              "data-open": e.isOpen,
              role: "group",
              children: /* @__PURE__ */ g(Ft, { content: Oe, children: (M) => (
                // Pass the built collection to ComboBoxRootInner which handles all behavior
                /* @__PURE__ */ g(
                  Sr,
                  {
                    ...ne,
                    size: s,
                    filter: K,
                    selectionMode: r,
                    inputValue: z,
                    onInputChange: we,
                    getKey: o,
                    getTextValue: n,
                    allowsEmptyMenu: $e,
                    renderEmptyState: ge,
                    isDisabled: I,
                    isRequired: F,
                    isInvalid: y,
                    isReadOnly: $,
                    collection: M,
                    allowsCustomOptions: T,
                    asyncConfig: p,
                    onAsyncSelectedItemsChange: p && r === "multiple" ? j : void 0,
                    onAddCustomItem: le,
                    onAddAsyncSelectedItem: j
                  }
                )
              ) })
            }
          )
        }
      )
    }
  );
}
et.displayName = "ComboBox.Root";
const Sr = (e) => {
  const t = Ht(br), {
    selectionMode: r = "single",
    items: s,
    collection: o,
    getKey: n = Ze,
    children: c,
    selectedKeys: l = [],
    onSelectionChange: u,
    disabledKeys: b,
    inputValue: h = "",
    onInputChange: d,
    filter: w,
    placeholder: p,
    menuTrigger: K = "input",
    shouldCloseOnBlur: T = !0,
    shouldCloseOnSelect: I = !0,
    isOpen: y,
    defaultOpen: F = !1,
    onOpenChange: $,
    allowsEmptyMenu: H = !1,
    renderEmptyState: U,
    allowsCustomOptions: q = !1,
    isValidNewOption: J,
    getNewOptionData: ne = xr,
    onCreateOption: P,
    "aria-label": Q,
    "aria-labelledby": se,
    "aria-describedby": le,
    isDisabled: B = !1,
    isRequired: me = !1,
    isInvalid: ee = !1,
    isReadOnly: x = !1,
    shouldFocusWrap: O = !0,
    autoFocus: D = !1,
    name: j,
    formValue: Fe,
    validationBehavior: Ce = "aria",
    form: Se,
    validate: z,
    isLoading: we,
    asyncConfig: X,
    onAsyncSelectedItemsChange: $e,
    onAddCustomItem: Ke,
    onAddAsyncSelectedItem: Ie
  } = e, pe = Je(), ge = Je(), ue = A(null), ye = A(null), be = _(
    () => vr(l),
    [l]
  ), Oe = !!u, [M, k] = Z(
    be
  ), v = Oe ? be : M, V = d !== void 0, te = () => {
    if (h) return h;
    if (V || r !== "single") return "";
    const i = Array.from(v);
    if (i.length === 0) return "";
    const a = i[0];
    return o.getItem(a)?.textValue ?? "";
  }, [ie, re] = Z(
    te
  ), L = V ? h : ie, oe = A(L), [at, ze] = Z(F), C = y ?? at, [Ve, he] = Z(
    null
  ), E = R(
    (i) => {
      y === void 0 && ze(i), $?.(i);
    },
    [y, $]
  ), ut = _(() => {
    if (L.trim() === "")
      return o;
    if (r === "single") {
      const a = Array.from(v);
      if (a.length > 0) {
        const f = a[0];
        if (o.getItem(f)?.textValue === L)
          return o;
      }
    }
    if (w) {
      const a = Array.from(o), f = Array.from(w(a, L)), S = new Set(f.map((Be) => Be.key));
      return o.filter?.((Be, Le) => S.has(Le.key)) ?? o;
    }
    const i = L.toLowerCase();
    return o.filter?.((a) => a.toLowerCase().includes(i)) ?? o;
  }, [o, L, w, r, v]), dt = _(
    () => r === "multiple" ? Array.from(v).map((i) => o.getItem(i)?.value).filter((i) => i !== void 0) : [],
    [r, v, o]
  ), [ft, mt] = Z(null), pt = R(() => {
    const i = y === void 0 ? !C : !y;
    y === void 0 ? ze((a) => !a) : $?.(!y), i && (ce.current?.focus(), he("first"));
  }, [y, C, $]), gt = R(
    (i) => {
      V || re(i), d?.(i), K === "input" && i !== oe.current && E(!0), oe.current = i;
    },
    [V, d, K, E]
  ), W = R(
    (i, a) => {
      let f = i === "all" ? new Set(Array.from(o).map((N) => N.key)) : i;
      const S = a ?? v, Be = f.size > 0 && Array.from(f).every((N) => S.has(N)) && f.size < S.size;
      if (r === "multiple" && f.size === 1 && !Be) {
        const N = Array.from(f)[0], de = S.has(N), ae = new Set(S);
        de ? ae.delete(N) : ae.add(N), f = ae;
      }
      const Le = Cr(f);
      if (u ? u(Le) : k(f), X && r === "multiple" && $e) {
        const N = Array.from(f).map((de) => o.getItem(de)?.value).filter((de) => de !== void 0);
        $e(N);
      }
      if (r === "single") {
        const N = Array.from(f)[0];
        if (N !== null) {
          const ae = o.getItem(N)?.textValue ?? "";
          V || (re(ae), oe.current = ae), d?.(ae);
        }
        I && E(!1);
      }
    },
    [
      o,
      r,
      v,
      u,
      d,
      I,
      E,
      V
    ]
  ), m = Jt({
    selectionMode: r,
    collection: ut,
    selectedKeys: v,
    onSelectionChange: W,
    disabledKeys: b
  }), yt = R(() => {
    m.selectionManager.setSelectedKeys(/* @__PURE__ */ new Set()), r === "single" && (V || (re(""), oe.current = ""), d?.(""));
  }, [m.selectionManager, r, V, d]), Ne = R(
    (i) => {
      Ke?.((S) => [...S, i]), X && r === "multiple" && Ie?.((S) => [...S, i]);
      const a = n(i), f = v;
      if (r === "single")
        W(/* @__PURE__ */ new Set([a]), f);
      else {
        const S = new Set(f);
        S.add(a), W(S, f);
      }
    },
    [
      Ke,
      X,
      r,
      Ie,
      n,
      v,
      W
    ]
  ), ke = R(() => {
    if (!q) return !1;
    const i = L.trim();
    if (!i || Array.from(o).some(
      (S) => S.textValue?.toLowerCase() === i.toLowerCase()
    ) || J && !J(i))
      return !1;
    const f = ne(i);
    return Ne(f), r === "multiple" ? (V || (re(""), oe.current = ""), d?.("")) : (V || (re(i), oe.current = i), d?.(i)), P?.(f), !0;
  }, [
    q,
    ne,
    J,
    L,
    o,
    r,
    d,
    P,
    Ne,
    V,
    re,
    oe
  ]), bt = R(
    (i) => {
      if (B || x) return;
      const a = v, f = new Set(a);
      i.forEach((S) => f.delete(S)), W(f, a), f.size === 0 && ce.current?.focus();
    },
    [v, W, B, x]
  ), ht = R(
    (i) => {
      switch (i.key) {
        case "ArrowDown":
          if (i.preventDefault(), !C)
            E(!0), he("first");
          else {
            const a = m.selectionManager.focusedKey, f = a ? m.collection.getKeyAfter(a) : m.collection.getFirstKey();
            m.selectionManager.setFocusedKey(
              f ?? m.collection.getFirstKey()
            );
          }
          break;
        case "ArrowUp":
          if (i.preventDefault(), !C)
            E(!0), he("last");
          else {
            const a = m.selectionManager.focusedKey, f = a ? m.collection.getKeyBefore(a) : m.collection.getLastKey();
            m.selectionManager.setFocusedKey(
              f ?? m.collection.getLastKey()
            );
          }
          break;
        case "Enter":
          if (C && m.selectionManager.focusedKey) {
            i.preventDefault();
            const a = m.selectionManager.focusedKey;
            if (r === "multiple") {
              const f = new Set(v);
              f.has(a) ? f.delete(a) : f.add(a), W(f);
            } else
              W(/* @__PURE__ */ new Set([a])), m.selectionManager.setFocusedKey(null);
          } else C && !m.selectionManager.focusedKey && q && ke() && i.preventDefault();
          break;
        case "Escape":
          C && (i.preventDefault(), E(!1), m.selectionManager.setFocusedKey(null));
          break;
        case "Home":
          if (C) {
            i.preventDefault();
            const a = m.collection.getFirstKey();
            m.selectionManager.setFocusedKey(a);
          }
          break;
        case "End":
          if (C) {
            i.preventDefault();
            const a = m.collection.getLastKey();
            m.selectionManager.setFocusedKey(a);
          }
          break;
        case "Backspace":
          if (L === "") {
            const a = Array.from(v);
            if (a.length > 0)
              if (i.preventDefault(), r === "single")
                W(/* @__PURE__ */ new Set());
              else {
                const f = new Set(a);
                f.delete(a[a.length - 1]), W(f);
              }
          }
          break;
      }
    },
    [
      C,
      m.selectionManager,
      m.collection,
      W,
      E,
      he,
      r,
      L,
      v,
      q,
      ke
    ]
  ), xt = R(() => {
    K === "focus" && !B && !x && E(!0), r === "single" && L && ce.current && ce.current.select();
  }, [
    K,
    B,
    x,
    E,
    r,
    L
  ]), vt = R(
    (i) => {
      if (!T) return;
      const a = i.currentTarget;
      setTimeout(() => {
        const f = document.activeElement;
        a.contains(f) || E(!1);
      }, 150);
    },
    [T, E]
  ), We = A(null);
  Y(() => {
    D && ce.current && !B && ce.current.focus();
  }, [D, B]);
  const Ge = A(C);
  Y(() => {
    y === void 0 && Ge.current !== C && (Ge.current = C, $?.(C));
  }, [C, y, $]), Y(() => {
    if (r !== "single") return;
    const i = Array.from(m.selectionManager.selectedKeys), a = i.length > 0 ? i[0] : null;
    if (a === We.current) return;
    We.current = a;
    const f = a !== null ? m.collection.getItem(a) : null;
    if (a !== null && !f)
      return;
    const S = f?.textValue ?? "";
    V ? d?.(S) : (re(S), oe.current = S);
  }, [
    r,
    m.selectionManager.selectedKeys,
    m.collection,
    V,
    d
  ]), Y(() => {
    if (C && Ve) {
      const i = Ve === "first" ? m.collection.getFirstKey() : m.collection.getLastKey();
      m.selectionManager.setFocusedKey(i ?? null), he(null);
    }
  }, [C, Ve, m.collection, m.selectionManager]), Y(() => {
    C ? m.selectionManager.setFocused(!0) : (m.selectionManager.setFocused(!1), m.selectionManager.setFocusedKey(null));
  }, [C, m.selectionManager]);
  const qe = A(!1);
  m.collection.size > 0 && (qe.current = !0), Y(() => {
    if (!C || H || we || !qe.current) return;
    m.collection.size > 0 || E(!1);
  }, [
    C,
    H,
    we,
    m.collection.size,
    E,
    L
  ]);
  const { triggerRef: je, inputRef: ce } = Ae();
  Y(() => {
    const i = je.current;
    if (!i) return;
    const a = () => {
      const S = i.offsetWidth;
      mt(`${S}px`);
    };
    a();
    const f = new ResizeObserver(a);
    return f.observe(i), () => {
      f.disconnect();
    };
  }, []);
  const Ct = [
    // InputContext: Props for ComboBox.Input component
    // Configures the input field with ARIA attributes, event handlers, and validation
    [
      Me,
      {
        ref: ce,
        role: "combobox",
        // ARIA role for autocomplete input
        "aria-autocomplete": "list",
        // Indicates suggestions are in a list
        "aria-controls": r === "multiple" ? `${ge} ${pe}` : pe,
        // Single-select: controls only listbox
        "aria-expanded": C,
        // Announces menu open/closed state
        "aria-activedescendant": m.selectionManager.focusedKey ? `${pe}-option-${m.selectionManager.focusedKey}` : void 0,
        "aria-describedby": r === "multiple" ? `${ge} ${le ?? ""}` : le,
        "aria-label": Q,
        "aria-labelledby": se,
        value: L,
        onChange: (i) => gt(i.target.value),
        onKeyDown: ht,
        onFocus: xt,
        onBlur: vt,
        disabled: B,
        readOnly: x,
        required: me,
        "aria-invalid": ee,
        placeholder: p,
        name: j,
        form: Se,
        validationbehavior: Ce,
        validate: z
      }
    ],
    // TagGroupContext: Props for ComboBox.TagGroup component (multi-select only)
    // Renders selected items as removable tags
    [
      De,
      {
        id: ge,
        "aria-label": t.format("selectedValues"),
        items: dt,
        // Selected items to display as tags
        onRemove: bt
        // Handle tag removal
      }
    ],
    // ButtonContext: Props for toggle and clear buttons
    // Uses "slots" pattern to configure multiple buttons via single context
    [
      Ee,
      {
        slots: {
          toggle: {
            onPress: pt,
            "aria-label": t.format("toggleOptions"),
            isDisabled: B || x,
            isPressed: C
            // Visual indicator that menu is open
          },
          clear: {
            onPress: yt,
            "aria-label": t.format("clearSelection"),
            style: v.size > 0 ? void 0 : { display: "none" },
            isDisabled: B || x || m.selectionManager.selectedKeys.size === 0
            // Disabled when nothing selected
          }
        }
      }
    ],
    // PopoverContext: Props for ComboBox.Popover component
    // Controls menu positioning, portal rendering, and open/close behavior
    [
      qt,
      {
        isOpen: C,
        // No-op onOpenChange: We control state internally, prevent React Aria from managing its own state
        onOpenChange: () => {
        },
        ref: ye,
        triggerRef: je,
        // Popover positions relative to this element
        scrollRef: ue,
        // Enables scroll-into-view for keyboard navigation
        isNonModal: !0,
        // Non-modal: doesn't trap focus, allows interaction outside
        trigger: "ComboBox",
        // Identifies this as a combobox popover (not tooltip, dialog, etc.)
        placement: "bottom start",
        // Default placement below trigger, aligned to start
        style: {
          "--nimbus-combobox-trigger-width": ft
        },
        // CSS custom property for menu width
        clearContexts: [
          // Clear these contexts so popover content doesn't inherit combobox contexts
          Gt,
          Ee,
          Me,
          Wt,
          jt
        ]
      }
    ],
    // SelectableCollectionContext: Enables virtual focus for keyboard navigation
    // Virtual focus uses aria-activedescendant instead of moving browser focus
    [Nt, { shouldUseVirtualFocus: !0 }],
    // ListBoxContext: Props for ComboBox.ListBox component
    // Configures the option list with items, ARIA attributes, and behaviors
    [
      Xe,
      {
        items: s,
        // Items to render (merged from outer component)
        id: pe,
        // ID referenced by aria-controls on input
        ref: ue,
        // Ref for scroll positioning
        renderEmptyState: U,
        // Custom empty state renderer
        shouldFocusWrap: O,
        // Whether to wrap focus from last to first item
        "aria-label": t.format("options")
      }
    ],
    // ListStateContext: React Aria's collection state for managing selection and focus
    [It, m]
  ];
  return /* @__PURE__ */ ve(
    Ye,
    {
      values: Ct,
      children: [
        /* @__PURE__ */ g(
          _e,
          {
            name: j,
            form: Se,
            selectedKeys: v,
            selectionMode: r,
            formValue: Fe,
            allowsCustomOptions: q,
            collection: m.collection,
            inputValue: L
          }
        ),
        c
      ]
    }
  );
}, tt = (e) => {
  const [t, r] = fe(e), s = Pe(Me), { inputRef: o } = Ae();
  let n = "", c = "";
  s && typeof s == "object" && "value" in s && (n = s.value || "", c = s.placeholder || "");
  const l = Math.max(n.length || c.length || 1, 1);
  return /* @__PURE__ */ g(sr, { asChild: !0, ...t, children: /* @__PURE__ */ g(
    Dt,
    {
      ref: o,
      ...r,
      size: l,
      "data-empty": !(n.length || c.length)
    }
  ) });
};
tt.displayName = "ComboBox.Input";
const wr = ({
  children: e
}) => /* @__PURE__ */ g(rr, { children: e }), rt = (e) => {
  const { selectionMode: t, size: r, getKey: s, getTextValue: o, isDisabled: n, isReadOnly: c } = Ae(), [l, u] = fe(e), b = Pe(De), h = (b && "items" in b ? b.items : void 0) ?? [];
  return t !== "multiple" ? null : /* @__PURE__ */ g(nr, { ...l, ...u, asChild: !0, children: /* @__PURE__ */ g(Te.Root, { size: r, children: /* @__PURE__ */ g(Te.TagList, { items: h, display: "contents", children: (d) => {
    const w = s(d), p = o(d);
    return /* @__PURE__ */ g(
      Te.Tag,
      {
        id: w,
        textValue: p,
        isDisabled: n || c,
        maxW: "100%",
        children: p
      }
    );
  } }) }) });
};
rt.displayName = "ComboBox.TagGroup";
const ot = ({
  children: e,
  ...t
}) => {
  const { triggerRef: r, leadingElement: s, inputRef: o, isLoading: n, isDisabled: c } = Ae();
  return /* @__PURE__ */ ve(tr, { ref: r, onClick: (u) => {
    !c && u.target instanceof HTMLElement && !u.target.closest("button") && o.current?.focus();
  }, ...t, children: [
    s && /* @__PURE__ */ g(wr, { children: s }),
    /* @__PURE__ */ ve(or, { children: [
      /* @__PURE__ */ g(rt, {}),
      /* @__PURE__ */ g(tt, {})
    ] }),
    /* @__PURE__ */ g(
      Ue,
      {
        slot: "clear",
        size: "2xs",
        variant: "ghost",
        colorPalette: "primary",
        children: /* @__PURE__ */ g(Lt, {})
      }
    ),
    /* @__PURE__ */ g(
      Ue,
      {
        slot: "toggle",
        size: "2xs",
        variant: "ghost",
        colorPalette: "neutral",
        excludeFromTabOrder: !0,
        children: n ? /* @__PURE__ */ g(Pt, { size: "xs", margin: "50" }) : /* @__PURE__ */ g(Tt, {})
      }
    ),
    e
  ] });
};
ot.displayName = "ComboBox.Trigger";
const nt = ({
  children: e,
  ref: t,
  ...r
}) => {
  const [s, o] = fe(r);
  return /* @__PURE__ */ g(lr, { asChild: !0, ...s, children: /* @__PURE__ */ g(
    Rt,
    {
      ref: t,
      isNonModal: !0,
      autoFocus: !0,
      ...o,
      children: e
    }
  ) });
};
nt.displayName = "ComboBox.Popover";
function st({
  children: e,
  ref: t,
  ...r
}) {
  const [s, o] = fe(r);
  return /* @__PURE__ */ g(ir, { ...s, ref: t, asChild: !0, children: /* @__PURE__ */ g(Bt, { ...o, children: typeof e == "function" ? (c) => {
    const l = e(c), u = c;
    return wt(l) && (u.id || u.textValue) ? $t(
      l,
      {
        ...l.props,
        ...u.id ? { id: u.id } : {},
        ...u.textValue ? { textValue: u.textValue } : {}
      }
    ) : l;
  } : e }) });
}
st.displayName = "ComboBox.ListBox";
function lt({
  children: e,
  ref: t,
  ...r
}) {
  const [s, o] = fe(r);
  return /* @__PURE__ */ g(ar, { ...s, asChild: !0, children: /* @__PURE__ */ g(Mt, { ref: t, ...o, children: (n) => {
    const c = typeof e == "function" ? e({
      ...n
    }) : e;
    return n.selectionMode === "multiple" ? /* @__PURE__ */ ve(He, { children: [
      /* @__PURE__ */ g(ur, { children: /* @__PURE__ */ g("span", { "data-selected": n.isSelected, children: n.isSelected && /* @__PURE__ */ g(Et, {}) }) }),
      /* @__PURE__ */ g(dr, { children: c })
    ] }) : /* @__PURE__ */ g(He, { children: c });
  } }) });
}
lt.displayName = "ComboBox.Option";
function it({
  children: e,
  label: t,
  items: r,
  ref: s,
  ...o
}) {
  if (r && typeof e != "function")
    throw new Error(
      'ComboBox.Section: When "items" is provided, "children" must be a function'
    );
  return /* @__PURE__ */ ve(At, { ref: s, ...o, children: [
    t && /* @__PURE__ */ g(cr, { asChild: !0, children: /* @__PURE__ */ g(Kt, { children: t }) }),
    r ? /* @__PURE__ */ g(Ot, { items: r, children: (n) => typeof e == "function" ? e(n) : null }) : e
  ] });
}
it.displayName = "ComboBox.Section";
function ct(e, t) {
  if (!t.trim()) return e;
  const r = t.toLowerCase(), s = [];
  for (const o of e)
    o.textValue.toLowerCase().includes(r) && s.push(o);
  return s;
}
function $r(e, t) {
  if (!t.trim()) return e;
  const r = t.toLowerCase(), s = [];
  for (const o of e)
    o.textValue.toLowerCase().startsWith(r) && s.push(o);
  return s;
}
function Kr(e, t) {
  if (!t.trim()) return e;
  const r = [];
  for (const s of e)
    s.textValue.includes(t) && r.push(s);
  return r;
}
function Ir(e, t) {
  if (!t.trim()) return e;
  const r = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), s = new RegExp(`\\b${r}`, "i"), o = [];
  for (const n of e)
    s.test(n.textValue) && o.push(n);
  return o;
}
function Br(e, t) {
  if (!t.trim()) return e;
  const r = t.toLowerCase(), s = [];
  for (const o of e) {
    const n = o.textValue.toLowerCase();
    let c = 0;
    for (let l = 0; l < n.length && c < r.length; l++)
      n[l] === r[c] && c++;
    c === r.length && s.push(o);
  }
  return s;
}
function Mr(e) {
  return (t, r) => {
    if (!r.trim()) return t;
    const s = r.toLowerCase(), o = [];
    for (const n of t) {
      const c = n.value;
      if (!c) continue;
      e.some((u) => {
        const b = u.split(".").reduce((d, w) => d && typeof d == "object" ? d[w] : void 0, c);
        return b == null ? !1 : String(b).toLowerCase().includes(s);
      }) && o.push(n);
    }
    return o;
  };
}
function Ar(e) {
  return (t, r) => {
    if (!r.trim()) return t;
    const s = [];
    for (const o of t) {
      const n = e(o, r);
      n > 0 && s.push({ node: o, score: n });
    }
    return s.sort((o, n) => n.score - o.score), s.map((o) => o.node);
  };
}
function Fr(e = ct) {
  return (t, r) => {
    if (!r.trim()) return t;
    const s = r.split(/\s+/).filter((c) => c.length > 0);
    if (s.length === 0) return t;
    const o = /* @__PURE__ */ new Set();
    for (const c of s) {
      const l = e(t, c);
      for (const u of l)
        o.add(u.key);
    }
    const n = [];
    for (const c of t)
      o.has(c.key) && n.push(c);
    return n;
  };
}
function Or(e) {
  return (t, r) => {
    if (!r.trim()) return t;
    const s = [];
    let o = null;
    const n = [], c = () => {
      o && n.length > 0 && (s.push(o), s.push(...n)), n.length = 0;
    };
    for (const l of t)
      if (l.type === "section")
        c(), o = l;
      else {
        const u = Array.from(e([l], r));
        u.length > 0 && n.push(...u);
      }
    return c(), s;
  };
}
const oo = {
  /**
   * # ComboBox.Root
   *
   * The root component that provides state management and context for the combobox.
   * Handles selection state, input filtering, popover open/close, and keyboard navigation.
   *
   * @example
   * ```tsx
   * <ComboBox.Root items={items}>
   *   <ComboBox.Trigger />
   *   <ComboBox.Popover>
   *     <ComboBox.ListBox>
   *       {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
   *     </ComboBox.ListBox>
   *   </ComboBox.Popover>
   * </ComboBox.Root>
   * ```
   */
  Root: et,
  /**
   * # ComboBox.Trigger
   *
   * The trigger element that contains the input field and controls for the combobox.
   * Automatically renders tag group (multi-select), input field, toggle button, and clear button.
   *
   * @example
   * ```tsx
   * <ComboBox.Root items={items}>
   *   <ComboBox.Trigger />
   *   <ComboBox.Popover>...</ComboBox.Popover>
   * </ComboBox.Root>
   * ```
   */
  Trigger: ot,
  /**
   * # ComboBox.Popover
   *
   * The popover container that displays the dropdown options list.
   * Renders in a React portal and handles positioning relative to the trigger.
   *
   * @example
   * ```tsx
   * <ComboBox.Popover>
   *   <ComboBox.ListBox>
   *     {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
   *   </ComboBox.ListBox>
   * </ComboBox.Popover>
   * ```
   */
  Popover: nt,
  /**
   * # ComboBox.ListBox
   *
   * The container for dropdown options that displays filtered results.
   *
   * Use the render prop pattern - do **NOT** manually map over items as this is less performant.
   *
   * @example
   * ```tsx
   * <ComboBox.ListBox>
   *   {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
   * </ComboBox.ListBox>
   * ```
   */
  ListBox: st,
  /**
   * # ComboBox.Option
   *
   * An individual selectable option within the listbox.
   * Displays a checkmark indicator for selected items in multi-select mode.
   *
   * @example
   * ```tsx
   * <ComboBox.Option>Option text</ComboBox.Option>
   * ```
   *
   * @example Render prop pattern
   * ```tsx
   * <ComboBox.Option>
   *   {({ isSelected }) => (
   *     <span>Option 1 {isSelected && "✓"}</span>
   *   )}
   * </ComboBox.Option>
   * ```
   */
  Option: lt,
  /**
   * # ComboBox.Section
   *
   * Groups related options together with an optional heading.
   * Supports render prop pattern for dynamic option rendering within sections.
   *
   * @example
   * ```tsx
   * <ComboBox.Section label="Category Name">
   *   <ComboBox.Option id="opt-1">Option 1</ComboBox.Option>
   *   <ComboBox.Option id="opt-2">Option 2</ComboBox.Option>
   * </ComboBox.Section>
   * ```
   *
   * @example Render prop pattern
   * ```tsx
   * <ComboBox.Section items={categoryItems}>
   *   {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
   * </ComboBox.Section>
   * ```
   */
  Section: it,
  /**
   * # ComboBox.filters
   *
   * Built-in filter functions and utilities for customizing ComboBox filtering behavior.
   * These filters can be passed to the `filter` prop on ComboBox.Root to control how options are filtered based on user input.
   *
   * **Available Filters:**
   * - `filterByText`: Default substring matching (case-insensitive)
   * - `filterByStartsWith`: Prefix matching
   * - `filterByCaseSensitive`: Exact case substring matching
   * - `filterByWordBoundary`: Word boundary matching
   * - `filterByFuzzy`: Fuzzy matching (characters in order)
   * - `createMultiPropertyFilter`: Search across multiple object properties
   * - `createRankedFilter`: Custom scoring/ranking logic
   * - `createMultiTermFilter`: OR logic for multiple search terms
   * - `createSectionAwareFilter`: Preserves section structure while filtering
   *
   * @example Basic filter usage
   * ```tsx
   * import { ComboBox } from '@commercetools/nimbus';
   *
   * function MyComponent() {
   *   return (
   *     <ComboBox.Root
   *       items={items}
   *       filter={ComboBox.filters.filterByStartsWith}
   *     >
   *       <ComboBox.Trigger />
   *       <ComboBox.Popover>
   *         <ComboBox.ListBox>
   *           {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
   *         </ComboBox.ListBox>
   *       </ComboBox.Popover>
   *     </ComboBox.Root>
   *   );
   * }
   * ```
   *
   * @example Multi-property search
   * ```tsx
   * const productFilter = ComboBox.filters.createMultiPropertyFilter<Product>([
   *   'name',
   *   'category',
   *   'description'
   * ]);
   *
   * function ProductSearch() {
   *   return (
   *     <ComboBox.Root items={products} filter={productFilter}>
   *       <ComboBox.Trigger />
   *       <ComboBox.Popover>
   *         <ComboBox.ListBox>
   *           {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
   *         </ComboBox.ListBox>
   *       </ComboBox.Popover>
   *     </ComboBox.Root>
   *   );
   * }
   * ```
   *
   * @example Section-aware filtering
   * ```tsx
   * const sectionFilter = ComboBox.filters.createSectionAwareFilter(
   *   ComboBox.filters.filterByFuzzy
   * );
   *
   * function SectionedSearch() {
   *   return (
   *     <ComboBox.Root items={sectionsWithItems} filter={sectionFilter}>
   *       <ComboBox.Trigger />
   *       <ComboBox.Popover>
   *         <ComboBox.ListBox>
   *           {(section) => (
   *             <ComboBox.Section>
   *               {(item) => <ComboBox.Option>{item.name}</ComboBox.Option>}
   *             </ComboBox.Section>
   *           )}
   *         </ComboBox.ListBox>
   *       </ComboBox.Popover>
   *     </ComboBox.Root>
   *   );
   * }
   * ```
   */
  filters: {
    filterByText: ct,
    filterByStartsWith: $r,
    filterByCaseSensitive: Kr,
    filterByWordBoundary: Ir,
    filterByFuzzy: Br,
    createMultiPropertyFilter: Mr,
    createRankedFilter: Ar,
    createMultiTermFilter: Fr,
    createSectionAwareFilter: Or
  }
};
export {
  oo as C
};
//# sourceMappingURL=combobox-vjauyzlS.es.js.map
