@progress/kendo-react-data-tools 6.1.1 → 7.0.0-develop.2

package/index.mjs

@@ -0,0 +1,2901 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the package root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as a from "react";
+import * as d from "prop-types";
+import { classNames as _, kendoThemeMaps as _t, validatePackage as dt, Draggable as ht, Keys as B, IconWrap as Re, canUseDOM as $t, toIconName as sn, extendDataItem as gt, mapTree as ae, getItemPath as an, getNestedValue as $e, guid as ln, getActiveElement as cn, getter as Wt, hasRelativeStackingContext as un, useDocument as pn } from "@progress/kendo-react-common";
+import { Button as K, Toolbar as Ht, ToolbarItem as We, ButtonGroup as dn } from "@progress/kendo-react-buttons";
+import { provideLocalizationService as q, provideIntlService as Vt, registerForLocalization as $, registerForIntl as hn, useLocalization as Y } from "@progress/kendo-react-intl";
+import { NumericTextBox as Me, Input as Yt, TextBox as gn, Checkbox as fn } from "@progress/kendo-react-inputs";
+import { DropDownList as G } from "@progress/kendo-react-dropdowns";
+import { caretAltToRightIcon as Lt, caretAltToLeftIcon as Dt, caretAltRightIcon as wt, caretAltLeftIcon as Ot, filterIcon as Xt, filterClearIcon as mn, sortAscSmallIcon as Ut, sortDescSmallIcon as jt, cancelIcon as vn, plusIcon as En, xIcon as Zt, filterAddExpressionIcon as Cn, filterAddGroupIcon as xn, moreVerticalIcon as bn } from "@progress/kendo-svg-icons";
+import * as yn from "react-dom";
+import { createPortal as Jt } from "react-dom";
+import { isCompositeFilterDescriptor as Qt, orderBy as er, filterBy as In } from "@progress/kendo-data-query";
+import { DatePicker as ft } from "@progress/kendo-react-dateinputs";
+import { Popup as kn } from "@progress/kendo-react-popup";
+import { Reveal as Sn } from "@progress/kendo-react-animation";
+const de = "pager.info", he = "pager.firstPage", ge = "pager.previousPage", fe = "pager.nextPage", me = "pager.lastPage", ve = "pager.itemsPerPage", Fn = "pager.pageSelection", V = "pager.page", Ee = "pager.of", Ce = "pager.totalPages", Rn = "pager.pageLabel", xe = "pager.ariaKeyshortcuts", be = "pager.ariaLabel", ye = "pager.pageSizeAriaLabel", Ie = "pager.mobileSelect", ke = "pager.moreButtonLabel", ie = "filter.eqOperator", le = "filter.notEqOperator", Le = "filter.isNullOperator", De = "filter.isNotNullOperator", tr = "filter.isEmptyOperator", rr = "filter.isNotEmptyOperator", nr = "filter.startsWithOperator", or = "filter.containsOperator", sr = "filter.notContainsOperator", ar = "filter.endsWithOperator", ir = "filter.gteOperator", lr = "filter.gtOperator", cr = "filter.lteOperator", ur = "filter.ltOperator", pr = "filter.isTrue", dr = "filter.isFalse", hr = "filter.afterOrEqualOperator", gr = "filter.afterOperator", fr = "filter.beforeOperator", mr = "filter.beforeOrEqualOperator", Ve = "filter.andLogic", Ye = "filter.orLogic", te = "filter.addExpression", re = "filter.addGroup", oe = "filter.close", Xe = "filter.groupAriaLabel", Ue = "filter.expressionAriaLabel", je = "filter.expressionDropdownAriaLabel", Ze = "filter.expressionOperatorDropdownAriaLabel", Je = "filter.enumFilterDropdownAriaLabel", Qe = "filter.numericFilterAriaLabel", et = "filter.textFilterAriaLabel", tt = "columnMenu.filterClearButton", rt = "columnMenu.filterSubmitButton", nt = "columnMenu.filterTitle", ot = "columnMenu.sortAscending", st = "columnMenu.sortDescending", we = "columnMenu.filterEqOperator", Oe = "columnMenu.filterNotEqOperator", Ne = "columnMenu.filterIsNullOperator", Ae = "columnMenu.filterIsNotNullOperator", vr = "columnMenu.filterIsEmptyOperator", Er = "columnMenu.filterIsNotEmptyOperator", Cr = "columnMenu.filterStartsWithOperator", xr = "columnMenu.filterContainsOperator", br = "columnMenu.filterNotContainsOperator", yr = "columnMenu.filterEndsWithOperator", Ir = "columnMenu.filterGteOperator", kr = "columnMenu.filterGtOperator", Sr = "columnMenu.filterLteOperator", Fr = "columnMenu.filterLtOperator", Rr = "columnMenu.filterIsTrue", Mr = "columnMenu.filterAfterOrEqualOperator", Lr = "columnMenu.filterAfterOperator", Dr = "columnMenu.filterBeforeOperator", wr = "columnMenu.filterBeforeOrEqualOperator", Or = "columnMenu.filterAndLogic", Nr = "columnMenu.filterOrLogic", at = "sort.ariaLabel", it = "filter.ariaLabel", v = {
+  [ve]: "items per page",
+  [Fn]: "Select page",
+  [de]: "{0} - {1} of {2} items",
+  [he]: "Go to the first page",
+  [ge]: "Go to the previous page",
+  [fe]: "Go to the next page",
+  [me]: "Go to the last page",
+  [V]: "Page",
+  [Ee]: "of",
+  [Ce]: "{0}",
+  [Rn]: "Page",
+  [xe]: "Enter ArrowRight ArrowLeft",
+  [be]: "Pager",
+  [ye]: "Page size",
+  [Ie]: "Select",
+  [ke]: "More pages",
+  [at]: "Sortable",
+  [it]: "Filter",
+  [ie]: "Is equal to",
+  [le]: "Is not equal to",
+  [Le]: "Is null",
+  [De]: "Is not null",
+  [tr]: "Is empty",
+  [rr]: "Is not empty",
+  [nr]: "Starts with",
+  [or]: "Contains",
+  [sr]: "Does not contain",
+  [ar]: "Ends with",
+  [ir]: "Is greater than or equal to",
+  [lr]: "Is greater than",
+  [cr]: "Is less than or equal to",
+  [ur]: "Is less than",
+  [pr]: "Is true",
+  [dr]: "Is false",
+  [hr]: "Is after or equal to",
+  [gr]: "Is after",
+  [fr]: "Is before",
+  [mr]: "Is before or equal to",
+  [Ve]: "And",
+  [Ye]: "Or",
+  [te]: "Add Expression",
+  [re]: "Add Group",
+  [oe]: "Close",
+  [Xe]: "Filter toolbar",
+  [Ue]: "Filter expression row",
+  [je]: "Filter dropdown",
+  [Ze]: "Filter operator dropdown",
+  [Je]: "Select True/False",
+  [Qe]: "Enter number",
+  [et]: "Enter text",
+  [tt]: "Clear",
+  [rt]: "Filter",
+  [nt]: "Filter",
+  [ot]: "Sort Ascending",
+  [st]: "Sort Descending",
+  [we]: "Is equal to",
+  [Oe]: "Is not equal to",
+  [Ne]: "Is null",
+  [Ae]: "Is not null",
+  [vr]: "Is empty",
+  [Er]: "Is not empty",
+  [Cr]: "Starts with",
+  [xr]: "Contains",
+  [br]: "Does not contain",
+  [yr]: "Ends with",
+  [Ir]: "Is greater than or equal to",
+  [kr]: "Is greater than",
+  [Sr]: "Is less than or equal to",
+  [Fr]: "Is less than",
+  [Rr]: "Is true",
+  [Mr]: "Is after or equal to",
+  [Lr]: "Is after",
+  [Dr]: "Is before",
+  [wr]: "Is before or equal to",
+  [Or]: "And",
+  [Nr]: "Or"
+}, Nt = "...";
+class Mn extends a.Component {
+  constructor() {
+    super(...arguments), this.handlePageChange = (t, r) => {
+      t.preventDefault(), this.props.pageChange(r, t);
+    }, this.handleSelectPageChange = (t) => {
+      t.preventDefault(), this.props.pageChange(t.target.value, t);
+    };
+  }
+  render() {
+    const t = q(this), r = this.props.messagesMap ? this.props.messagesMap(Ie) : { messageKey: Ie, defaultMessage: v[Ie] }, n = this.props.messagesMap ? this.props.messagesMap(V) : { messageKey: V, defaultMessage: v[V] }, o = this.props.messagesMap ? this.props.messagesMap(ke) : { messageKey: ke, defaultMessage: v[ke] }, s = t.toLanguageString(o.messageKey, o.defaultMessage), i = this.start > 1 && this.renderDots(this.start - 1, s), l = this.end < this.props.totalPages && this.renderDots(this.end + 1, s), c = this.start > 1 && this.renderOptionDots(this.start - 1), u = this.end < this.props.totalPages && this.renderOptionDots(this.end + 1), p = [];
+    for (let h = this.start; h <= this.end; h++)
+      p.push(h);
+    const f = p.map((h) => /* @__PURE__ */ a.createElement(
+      K,
+      {
+        className: _({ "k-selected": this.props.currentPage === h }),
+        key: h,
+        fillMode: "flat",
+        themeColor: "primary",
+        size: this.props.size,
+        rounded: null,
+        role: "button",
+        "aria-label": t.toLanguageString(n.messageKey, n.defaultMessage) + " " + h,
+        "aria-current": this.props.currentPage === h ? !0 : void 0,
+        onClick: (C) => this.handlePageChange(C, h)
+      },
+      h
+    )), m = p.map((h) => /* @__PURE__ */ a.createElement("option", { key: h }, h));
+    return /* @__PURE__ */ a.createElement(a.Fragment, null, /* @__PURE__ */ a.createElement(
+      "select",
+      {
+        style: { width: "5em", margin: "0px 1em", display: this.props.type === "dropdown" ? "inline-flex" : "none" },
+        className: _(
+          "k-picker k-dropdown-list k-dropdown k-rounded-md",
+          {
+            [`k-picker-${_t.sizeMap[this.props.size] || this.props.size}`]: this.props.size
+          }
+        ),
+        "aria-label": t.toLanguageString(r.messageKey, r.defaultMessage),
+        value: this.props.currentPage,
+        onChange: (h) => this.handleSelectPageChange(h)
+      },
+      c,
+      m,
+      u
+    ), /* @__PURE__ */ a.createElement(
+      "div",
+      {
+        className: "k-pager-numbers",
+        style: { display: this.props.type === "numbers" ? "" : "none" }
+      },
+      i,
+      f,
+      l
+    ));
+  }
+  get end() {
+    return Math.min(this.start + this.props.buttonCount - 1, this.props.totalPages);
+  }
+  get start() {
+    const t = this.props.currentPage, r = this.props.buttonCount;
+    if (t > r) {
+      const n = t % r;
+      return n === 0 ? t - r + 1 : t - n + 1;
+    }
+    return 1;
+  }
+  renderDots(t, r) {
+    return /* @__PURE__ */ a.createElement(
+      K,
+      {
+        fillMode: "flat",
+        themeColor: "primary",
+        size: this.props.size,
+        rounded: null,
+        role: "button",
+        "aria-label": r,
+        onClick: (n) => this.handlePageChange(n, t)
+      },
+      Nt
+    );
+  }
+  renderOptionDots(t) {
+    return /* @__PURE__ */ a.createElement("option", { value: t }, Nt);
+  }
+}
+class Ar extends a.Component {
+  constructor() {
+    super(...arguments), this.state = { page: this.props.currentPage }, this.handleOnChange = (t) => {
+      this.setState({ page: t.target.value }), t.target.value && this.props.pageChange(t.target.value, t);
+    };
+  }
+  render() {
+    const t = Vt(this), r = q(this), n = this.props.messagesMap ? this.props.messagesMap(V) : { messageKey: V, defaultMessage: v[V] }, o = this.props.messagesMap ? this.props.messagesMap(Ee) : { messageKey: Ee, defaultMessage: v[Ee] }, s = this.props.messagesMap ? this.props.messagesMap(Ce) : { messageKey: Ce, defaultMessage: v[Ce] };
+    return /* @__PURE__ */ a.createElement(a.Fragment, null, /* @__PURE__ */ a.createElement("span", { className: "k-pager-input" }, /* @__PURE__ */ a.createElement("span", null, r.toLanguageString(n.messageKey, n.defaultMessage)), /* @__PURE__ */ a.createElement(
+      Me,
+      {
+        value: this.props.currentPage !== void 0 ? this.props.currentPage : this.state.page,
+        onChange: this.handleOnChange,
+        min: 1,
+        spinners: !1
+      }
+    ), /* @__PURE__ */ a.createElement("span", null, `${r.toLanguageString(o.messageKey, o.defaultMessage)} ${t.format(r.toLanguageString(s.messageKey, s.defaultMessage), [
+      this.props.totalPages
+    ])}`)));
+  }
+}
+$(Ar);
+class Pr extends a.Component {
+  constructor() {
+    super(...arguments), this.pageSizeChange = (t) => {
+      this.props.pageChange && this.props.pageChange({ skip: 0, take: parseInt(t.target.value, 10) }, t);
+    };
+  }
+  render() {
+    const { value: t, pageSizes: r, pageSize: n, messagesMap: o } = this.props, s = r.slice();
+    t === void 0 && s.filter((c) => c === n).length === 0 && s.unshift(n);
+    const i = o ? o(ve) : { messageKey: ve, defaultMessage: v[ve] }, l = o ? o(ye) : { messageKey: ye, defaultMessage: v[ye] };
+    return /* @__PURE__ */ a.createElement("span", { className: "k-pager-sizes" }, /* @__PURE__ */ a.createElement(
+      G,
+      {
+        value: t !== void 0 ? t : n,
+        data: s,
+        onChange: this.pageSizeChange,
+        ariaLabel: q(this).toLanguageString(l.messageKey, l.defaultMessage),
+        size: this.props.size
+      }
+    ), /* @__PURE__ */ a.createElement("span", null, q(this).toLanguageString(i.messageKey, i.defaultMessage)));
+  }
+}
+$(Pr);
+const mt = {
+  name: "@progress/kendo-react-data-tools",
+  productName: "KendoReact",
+  productCodes: ["KENDOUIREACT", "KENDOUICOMPLETE"],
+  publishDate: 1700573209,
+  version: "",
+  licensingDocsUrl: "https://www.telerik.com/kendo-react-ui/components/my-license/"
+}, At = 600, Ln = 768;
+class Pe extends a.Component {
+  constructor(t) {
+    super(t), this._element = null, this.onPageChange = (r, n) => {
+      const o = {
+        target: this,
+        syntheticEvent: n.syntheticEvent,
+        nativeEvent: n.nativeEvent,
+        targetEvent: n,
+        ...r
+      };
+      this.props.onPageChange && this.props.onPageChange.call(void 0, o);
+    }, this.changePage = (r, n) => {
+      this.props.onPageChange && r > 0 && r <= this.totalPages && this.props.onPageChange({
+        target: this,
+        skip: (r - 1) * this.props.take,
+        take: this.props.take,
+        syntheticEvent: n,
+        nativeEvent: n.nativeEvent,
+        targetEvent: n
+      });
+    }, this.onWindowResize = () => {
+      const r = this.element;
+      if (!r || !this.props.responsive)
+        return;
+      const n = r.offsetWidth;
+      n < At ? this.setState({ showPagerSizes: !1 }) : n >= At && n < Ln ? this.setState({ showPagerInfo: !1, showPagerSizes: !0 }) : this.setState({ showPagerInfo: !0, showPagerSizes: !0 });
+    }, dt(mt), this.state = { showPagerSizes: !0, showPagerInfo: !0 };
+  }
+  get isRtl() {
+    return this.props.dir === "rtl";
+  }
+  /**
+   * Returns the HTML element of the Pager component.
+   */
+  get element() {
+    return this._element;
+  }
+  /**
+   * @hidden
+   */
+  componentDidMount() {
+    window.addEventListener("resize", this.onWindowResize), this.onWindowResize();
+  }
+  /**
+   * @hidden
+   */
+  componentWillUnmount() {
+    window.removeEventListener("resize", this.onWindowResize);
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const { showPagerSizes: t, showPagerInfo: r } = this.state, { skip: n, take: o, total: s, pageSizes: i, size: l, responsive: c, messagesMap: u, pageSizeValue: p } = this.props, f = q(this), m = Vt(this), h = Math.floor(n / o) + 1, C = this.props.type === "numeric" ? /* @__PURE__ */ a.createElement(
+      Mn,
+      {
+        type: c && !t ? "dropdown" : "numbers",
+        buttonCount: this.props.buttonCount || 0,
+        totalPages: this.totalPages,
+        currentPage: h,
+        pageChange: this.changePage,
+        messagesMap: this.props.messagesMap,
+        size: this.props.size
+      }
+    ) : /* @__PURE__ */ a.createElement(
+      Ar,
+      {
+        buttonCount: this.props.buttonCount || 0,
+        totalPages: this.totalPages,
+        currentPage: h,
+        pageChange: this.changePage,
+        messagesMap: u,
+        size: this.props.size
+      }
+    ), b = u ? u(he) : { messageKey: he, defaultMessage: v[he] }, x = u ? u(ge) : { messageKey: ge, defaultMessage: v[ge] }, g = u ? u(fe) : { messageKey: fe, defaultMessage: v[fe] }, I = u ? u(me) : { messageKey: me, defaultMessage: v[me] }, F = u ? u(de) : { messageKey: de, defaultMessage: v[de] }, k = u ? u(xe) : { messageKey: xe, defaultMessage: v[xe] }, E = u ? u(be) : { messageKey: be, defaultMessage: v[be] };
+    let y, S, w, P;
+    this.props.previousNext && (y = this.renderButton(
+      1,
+      "k-pager-nav k-pager-first" + (h === 1 ? " k-disabled" : ""),
+      f.toLanguageString(b.messageKey, b.defaultMessage),
+      this.isRtl ? "caret-alt-to-right" : "caret-alt-to-left",
+      this.isRtl ? Lt : Dt,
+      h === 1 ? !0 : void 0
+    ), S = this.renderButton(
+      h - 1,
+      "k-pager-nav" + (h === 1 ? " k-disabled" : ""),
+      f.toLanguageString(x.messageKey, x.defaultMessage),
+      this.isRtl ? "caret-alt-right" : "caret-alt-left",
+      this.isRtl ? wt : Ot,
+      h === 1 ? !0 : void 0
+    ), w = this.renderButton(
+      h + 1,
+      "k-pager-nav" + (h >= this.totalPages ? " k-disabled" : ""),
+      f.toLanguageString(g.messageKey, g.defaultMessage),
+      this.isRtl ? "caret-alt-left" : "caret-alt-right",
+      this.isRtl ? Ot : wt,
+      h >= this.totalPages ? !0 : void 0
+    ), P = this.renderButton(
+      this.totalPages,
+      "k-pager-nav k-pager-last" + (h >= this.totalPages ? " k-disabled" : ""),
+      f.toLanguageString(I.messageKey, I.defaultMessage),
+      this.isRtl ? "caret-alt-to-left" : "caret-alt-to-right",
+      this.isRtl ? Dt : Lt,
+      h >= this.totalPages ? !0 : void 0
+    ));
+    const T = i && /* @__PURE__ */ a.createElement(
+      Pr,
+      {
+        pageChange: this.onPageChange,
+        pageSize: o,
+        pageSizes: i,
+        value: p,
+        messagesMap: u,
+        size: this.props.size
+      }
+    ), z = this.props.info && /* @__PURE__ */ a.createElement("span", { className: "k-pager-info" }, m.format(f.toLanguageString(F.messageKey, F.defaultMessage), [
+      Math.min(n + 1, s),
+      Math.min(n + o, s),
+      s
+    ]));
+    return /* @__PURE__ */ a.createElement(
+      "div",
+      {
+        className: _(
+          "k-pager",
+          {
+            [`k-pager-${_t.sizeMap[l] || l}`]: l
+          },
+          this.props.className
+        ),
+        style: this.props.style,
+        role: "application",
+        "aria-roledescription": "pager",
+        dir: this.props.dir,
+        "aria-keyshortcuts": f.toLanguageString(k.messageKey, k.defaultMessage),
+        "aria-label": f.toLanguageString(E.messageKey, E.defaultMessage),
+        ref: (L) => this._element = L
+      },
+      /* @__PURE__ */ a.createElement("div", { className: _("k-pager-numbers-wrap") }, y, S, C, w, P),
+      c ? t && T : T,
+      c ? r && z : z
+    );
+  }
+  renderButton(t, r, n, o, s, i) {
+    return /* @__PURE__ */ a.createElement(
+      K,
+      {
+        fillMode: "flat",
+        themeColor: "base",
+        size: this.props.size,
+        rounded: null,
+        className: r,
+        icon: o,
+        svgIcon: s,
+        title: n,
+        role: "button",
+        "aria-disabled": i,
+        onClick: (l) => {
+          l.preventDefault(), this.changePage(t, l);
+        }
+      }
+    );
+  }
+  get totalPages() {
+    return Math.ceil((this.props.total || 0) / this.props.take);
+  }
+}
+Pe.propTypes = {
+  className: d.string,
+  style: d.object,
+  total: d.number.isRequired,
+  skip: d.number.isRequired,
+  take: d.number.isRequired,
+  buttonCount: d.number,
+  info: d.bool,
+  type: d.oneOf(["numeric", "input"]),
+  pageSizes: d.arrayOf(d.oneOfType([
+    d.string,
+    d.number
+  ])),
+  previousNext: d.bool,
+  onPageChange: d.func,
+  messagesMap: d.func,
+  size: d.oneOf([null, "small", "medium", "large"]),
+  dir: d.string
+};
+Pe.defaultProps = {
+  buttonCount: 10,
+  info: !0,
+  type: "numeric",
+  size: "medium"
+};
+hn(Pe);
+$(Pe);
+const Te = (e) => class extends a.Component {
+  constructor() {
+    super(...arguments), this.filterChange = (n) => {
+      this.props.onFilterChange && this.props.onFilterChange(n);
+    }, this.inputChange = (n) => {
+      const o = n.target.value, { filter: s = [], field: i = "" } = this.props, l = this.findCellFilter(), c = l ? s.map((u) => u.field === i ? { ...l, value: o } : u) : [...s, { ...e.emptyFilter, value: o, field: i }];
+      this.filterChange({
+        filter: c,
+        field: i,
+        syntheticEvent: n.syntheticEvent
+      });
+    }, this.operatorChange = (n) => {
+      const { operator: o } = n.target.value, { filter: s = [], field: i = "" } = this.props, l = this.findCellFilter(), c = l ? s.map((u) => u.field === i ? { ...l, operator: o } : u) : [...s, { ...e.emptyFilter, field: i, operator: o }];
+      this.filterChange({
+        filter: c,
+        field: i,
+        syntheticEvent: n.syntheticEvent
+      });
+    }, this.clearButtonClick = (n) => {
+      const { filter: o = [], field: s = "" } = this.props;
+      this.filterChange({
+        filter: o.filter((i) => i.field !== s),
+        field: s,
+        syntheticEvent: n
+      });
+    }, this.findCellFilter = () => {
+      const { filter: n = [], field: o } = this.props;
+      return n.find((s) => s.field === o);
+    };
+  }
+  render() {
+    const { clearButtonTitle: n = "", operators: o = [] } = this.props, s = this.findCellFilter() || { ...e.emptyFilter, operator: "" }, { operator: i, value: l } = s, c = {
+      ariaLabel: "filter",
+      value: o.find((u) => u.operator === i) || null,
+      onChange: this.operatorChange,
+      className: "k-dropdown-operator",
+      iconClassName: "k-i-filter",
+      svgIcon: Xt,
+      data: o,
+      textField: "text",
+      popupSettings: { width: "" },
+      components: this.props.components
+    };
+    return /* @__PURE__ */ a.createElement("div", { className: "k-filtercell" }, /* @__PURE__ */ a.createElement("span", null, e.inputComponent({
+      value: l,
+      onChange: this.inputChange,
+      components: this.props.components,
+      ariaLabel: this.props.ariaLabel,
+      min: this.props.min,
+      max: this.props.max
+    }), /* @__PURE__ */ a.createElement("div", { className: "k-filtercell-operator" }, e.operatorComponent(c, this.props), " ", /* @__PURE__ */ a.createElement(
+      K,
+      {
+        className: _({
+          ["k-clear-button-visible"]: !(l === null || l === "") || i
+        }),
+        title: n,
+        type: "button",
+        onClick: this.clearButtonClick,
+        icon: "filter-clear",
+        svgIcon: mn,
+        disabled: !(!(l === null || l === "") || i)
+      }
+    ))));
+  }
+}, Pt = "eq", Dn = {
+  emptyFilter: { operator: Pt, value: "" },
+  inputComponent: (e) => null,
+  operatorComponent: function(e, t) {
+    const { filter: r = [], field: n } = t, o = r.find((s) => s.field === n);
+    return /* @__PURE__ */ a.createElement(
+      G,
+      {
+        ...e,
+        value: e.data.find((s) => s.operator === (o ? o.value : "")),
+        onChange: (s) => {
+          if (!t.onFilterChange)
+            return;
+          const i = s.target.value.operator;
+          if (i === "") {
+            o && t.onFilterChange.call(void 0, {
+              filter: r.filter((c) => c.field !== o.field),
+              field: n,
+              syntheticEvent: s.syntheticEvent
+            });
+            return;
+          }
+          let l = o ? r.map((c) => c.field === n ? { ...o, value: i } : c) : [...r, { value: i, field: n, operator: Pt }];
+          t.onFilterChange.call(void 0, {
+            filter: l,
+            field: n,
+            syntheticEvent: s.syntheticEvent
+          });
+        }
+      }
+    );
+  }
+};
+class ts extends Te(Dn) {
+}
+const wn = {
+  inputComponent: (e) => /* @__PURE__ */ a.createElement(ft, { ...e }),
+  operatorComponent: (e) => /* @__PURE__ */ a.createElement(G, { ...e }),
+  emptyFilter: { operator: "eq", value: null }
+};
+class rs extends Te(wn) {
+}
+const On = {
+  inputComponent: (e) => /* @__PURE__ */ a.createElement(Me, { ...e }),
+  operatorComponent: (e) => /* @__PURE__ */ a.createElement(G, { ...e }),
+  emptyFilter: { operator: "eq", value: null }
+};
+class ns extends Te(On) {
+}
+const Nn = {
+  inputComponent: (e) => /* @__PURE__ */ a.createElement(Yt, { ...e }),
+  operatorComponent: (e) => /* @__PURE__ */ a.createElement(G, { ...e }),
+  emptyFilter: { operator: "contains", value: "" }
+};
+class os extends Te(Nn) {
+}
+const An = {
+  filterable: !0,
+  editable: !0,
+  sortable: !0,
+  resizable: !0,
+  reorderable: !0,
+  groupable: !0
+}, X = "data-keyboardnavlevel", Tr = "data-keyboardnavscope", Br = "data-keyboardnavheader", Kr = "data-keyboardnavbody", Be = "data-keyboardnavid", ss = "data-keyboardnavzone", Pn = "_filter", qr = [
+  "input:not([disabled]):not([type=hidden])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "button:not([disabled])",
+  "a[href]",
+  "area[href]",
+  "summary",
+  "iframe",
+  "object",
+  "embed",
+  "audio[controls]",
+  "video[controls]",
+  "[contenteditable]"
+], vt = [...qr, "[tabindex]"], Tn = [...qr, "[tabindex]"].map((e) => e + ':not([tabindex="-1"])'), as = {
+  [Tr]: !0
+}, Bn = {
+  [Br]: !0
+}, is = {
+  [Kr]: !0
+}, zr = a.createContext(void 0);
+zr.displayName = "KendoReactTableKeyboardNavigationContext";
+const Kn = (e, t) => {
+  const r = a.useContext(zr);
+  return !r || !e || t === !1 ? {} : {
+    tabIndex: r && r.activeId && r.activeId === e ? 0 : -1,
+    [X]: r.level,
+    [Be]: e
+  };
+}, Et = (e) => {
+  const {
+    ariaSort: t,
+    colSpan: r,
+    rowSpan: n,
+    className: o,
+    style: s,
+    columnId: i,
+    onKeyDown: l,
+    navigatable: c,
+    ariaColumnIndex: u,
+    ariaLabel: p,
+    role: f,
+    ariaSelected: m
+  } = e, h = Kn(i, c);
+  return /* @__PURE__ */ a.createElement(
+    "th",
+    {
+      "aria-sort": t,
+      "aria-label": p,
+      "aria-colindex": u,
+      "aria-selected": m,
+      colSpan: r,
+      rowSpan: n,
+      className: o,
+      style: s,
+      onKeyDown: l,
+      role: f,
+      ...h
+    },
+    e.children
+  );
+};
+Et.displayName = "KendoReactHeaderThElement";
+const Gr = (e, t, r = "cell") => `${t}_${e}_${r}`, qn = (e) => {
+  if (e)
+    return parseInt(e.getAttribute(X) || "", 10);
+}, Ct = (e) => {
+  if (!e)
+    return;
+  const t = e.getAttribute(Be);
+  return t || void 0;
+}, lt = (e) => e ? !!e.getAttribute(Be) : !1, zn = (e, t = { level: 0 }) => e.querySelector(`[${X}='${t.level}']`), Gn = (e) => e.parentElement && e.parentElement.closest(`[${X}]`), _n = (e, t) => e.querySelector(`[${Be}='${t}']`), $n = (e) => e.parentElement && e.parentElement.closest(`[${Tr}]`), _r = (e) => e.querySelector(`[${Br}]`), $r = (e) => e.querySelector(`[${Kr}]`), Wn = (e, t = { focusable: !1 }) => {
+  let r = t.focusable ? vt : Tn;
+  return Array.from(e.querySelectorAll(r.join(",")));
+}, Hn = (e, t = { level: 0 }) => {
+  if (!e)
+    return [];
+  let r = vt.map((n) => n + `[${X}='${t.level}']`).join(",");
+  return Array.from(e.querySelectorAll(r));
+}, Vn = (e = { level: 0 }) => {
+  let t = vt.map(
+    (r) => r + `[${X}='${e.level}']`
+  ).join(",");
+  return (r) => r.matches(t);
+}, Yn = (e) => {
+  const { elementForFocus: t, event: r, contextStateRef: n, prevElement: o } = e;
+  n.current && t && t.focus && (r.preventDefault(), t.focus(), lt(t) && (t.setAttribute("tabIndex", "0"), n.current.activeId = Ct(t)), o && lt(o) && o.setAttribute("tabIndex", "-1"));
+}, Xn = (e) => e.current ? e.current.idPrefix : "", Wr = (e, t, r, n, o) => {
+  if (!r)
+    return [];
+  let s = e + (o ? -1 : 1);
+  for (; s >= 0 && s < n.length; ) {
+    const i = n[s][t];
+    if (i !== r)
+      return [i, [s, t]];
+    s = s + (o ? -1 : 1);
+  }
+  return [];
+}, Hr = (e, t, r, n, o) => {
+  if (!r)
+    return [];
+  let s = t + (o ? -1 : 1);
+  for (; s >= 0 && s < n[e].length; ) {
+    const i = n[e][s];
+    if (i !== r)
+      return [i, [e, s]];
+    s = s + (o ? -1 : 1);
+  }
+  return [];
+}, ct = (e, t) => {
+  if (t) {
+    for (let r = 0; r < e.length; r++)
+      for (let n = 0; n < e[r].length; n++)
+        if (e[r][n] === t)
+          return [r, n];
+  }
+}, Un = (e) => e.current ? e.current.navigationMatrix.length : 0, Vr = (e) => e ? `${e}${Pn}` : "", M = {
+  generateNavigatableId: Gr,
+  getNavigatableId: Ct,
+  getNavigatableLevel: qn,
+  getNavigatableElement: zn,
+  getClosestNavigatableElement: Gn,
+  getActiveElement: _n,
+  getClosestScope: $n,
+  getHeaderElement: _r,
+  getBodyElement: $r,
+  getFocusableElements: Wn,
+  getNavigatableElements: Hn,
+  filterNavigatableElements: Vn,
+  focusElement: Yn,
+  getIdPrefix: Xn,
+  isNavigatable: lt,
+  findNextIdByRowIndex: Wr,
+  findNextIdByCellIndex: Hr,
+  findId: ct,
+  getNextNavigationIndex: Un,
+  getFilterColumnId: Vr
+}, jn = "k-table-row k-filter-row", Zn = (e, t, r) => {
+  let n = `${r ? "k-grid-header-sticky" : ""}`;
+  return e.some((o) => o.field === t) && (n += " k-sorted"), n;
+}, ls = function(e) {
+  const { columns: t, filter: r, filterChange: n, sort: o = [], ariaRowIndex: s } = e, i = Y();
+  return /* @__PURE__ */ a.createElement("tr", { className: jn, "aria-rowindex": s, role: "row" }, t.map((l, c) => {
+    const u = l.locked !== void 0 ? {
+      left: l.left,
+      right: l.right,
+      borderRightWidth: l.rightBorder ? "1px" : ""
+    } : {}, p = l.filterCell || l.filter;
+    return /* @__PURE__ */ a.createElement(
+      Et,
+      {
+        columnId: Vr(l.id),
+        navigatable: l.navigatable,
+        style: u,
+        key: c,
+        ariaColumnIndex: l.ariaColumnIndex,
+        ariaLabel: p ? i.toLanguageString(it, v[it]) : void 0,
+        className: _(
+          "k-table-th k-header",
+          Zn(o, l.field, l.locked)
+        )
+      },
+      p && /* @__PURE__ */ a.createElement(
+        p,
+        {
+          field: l.field,
+          filter: r,
+          onFilterChange: n
+        }
+      )
+    );
+  }));
+};
+function Jn(e, t) {
+  const r = e[t].depth;
+  let n = null;
+  for (let o = t + 1; o < e.length; o++)
+    if (e[o].depth === r) {
+      n = e[o];
+      break;
+    }
+  return n;
+}
+const xt = (e) => {
+  let t = e.width ? parseFloat(e.width.toString()) : 0;
+  return !t && e.children && e.children.length && (t = e.children.reduce((r, n) => xt(n) + r, 0)), t;
+};
+function cs(e) {
+  const t = [[]];
+  let r = 0;
+  for (let s = e.length - 1; s >= 0; s--)
+    r = Math.max(r, e[s].depth), e[s].colSpan = e[s].colSpan || 1, e[s].parentIndex !== -1 && (e[e[s].parentIndex].colSpan = (e[e[s].parentIndex].colSpan || 0) + e[s].colSpan);
+  const n = [];
+  let o = 1;
+  return e.forEach((s, i) => {
+    t[s.depth] = t[s.depth] || [];
+    let l = !1;
+    t[s.depth].length === 0 && (o <= 1 ? o = 1 + (s.children.length > 0 ? 0 : r - s.depth) : (o--, l = !0)), s.rowSpan = 1 + (s.children.length > 0 ? 0 : r - s.depth), s.kFirst = l, s.index = t[s.depth].length, t[s.depth].push(i), s.ariaColumnIndex = n[s.depth] ? n[s.depth] + 1 : 1;
+    for (let c = s.depth; c < s.depth + s.rowSpan; c++)
+      n[c] = (n[c] || 0) + s.colSpan;
+  }), Qn(t, e), eo(t, e), t;
+}
+function Qn(e, t, r) {
+  let n = new Array(e.length).fill(0), o = 0;
+  t.forEach((s) => {
+    if (s.locked && (!s.left || r))
+      if (s.left = n[s.depth], o = xt(s), s.children.length === 0)
+        for (let i = s.depth; i < n.length; i++)
+          n[i] += o;
+      else
+        n[s.depth] += o;
+  });
+}
+function eo(e, t, r) {
+  let n = 0, o = new Array(e.length).fill(0);
+  for (let s = t.length - 1; s >= 0; s--) {
+    const i = t[s];
+    if (i.locked && (!i.right || r)) {
+      if (i.right = o[i.depth], n = xt(i), i.children.length === 0)
+        for (let c = i.depth; c < o.length; c++)
+          o[c] += n;
+      else
+        o[i.depth] += n;
+      const l = Jn(t, s);
+      i.rightBorder = !(l && l.locked);
+    }
+  }
+}
+function to(e, t, r = 0) {
+  let n = [];
+  if (!e || !e.length)
+    return [];
+  e.forEach((s) => {
+    const i = to(s.children || [], t, r + 1);
+    n.push(
+      Object.assign(
+        {},
+        { depth: r },
+        An,
+        s,
+        {
+          id: s.id ? s.id : Gr(`${t.prevId++}`, t.idPrefix, "column"),
+          declarationIndex: n.length,
+          children: i,
+          rowSpan: 0,
+          colSpan: 0,
+          isAccessible: !0
+        }
+      )
+    );
+  });
+  const o = (s, i) => s.orderIndex === i.orderIndex ? s.declarationIndex - i.declarationIndex : (s.orderIndex || 0) - (i.orderIndex || 0);
+  if (n.sort(o), r === 0) {
+    let s = [];
+    const i = (l, c) => l.forEach((u) => {
+      u.parentIndex = c, i(u.children, s.push(u) - 1);
+    });
+    return i(n, -1), s;
+  }
+  return n;
+}
+function ro(e) {
+  return !!(e && getComputedStyle(e).direction === "rtl");
+}
+function Tt(e, t) {
+  if (!t || !e || !e.originalEvent)
+    return -1;
+  const r = { x: e.clientX, y: e.originalEvent.clientY };
+  let n = t.ownerDocument ? t.ownerDocument.elementFromPoint(r.x, r.y) : null;
+  for (; n && n.parentElement !== t; )
+    n = n.parentElement;
+  if (!n && t.matches("tr")) {
+    const s = (i) => {
+      const l = i.getBoundingClientRect();
+      return r.x > l.left && r.x < l.left + l.width && r.y > l.top && r.y < l.top + l.height;
+    };
+    n = Array.from(t.children).find(s) || null;
+  }
+  const o = t.children;
+  for (let s = 0; s < o.length; s++)
+    if (o[s] === n)
+      return s;
+  return -1;
+}
+class us extends a.Component {
+  constructor() {
+    super(...arguments), this.element = null;
+  }
+  componentDidMount() {
+    const { columnResize: t } = this.props;
+    t && t.resizable && t.setIsRtl(ro(this.element));
+  }
+  render() {
+    return /* @__PURE__ */ a.createElement(
+      "thead",
+      {
+        className: "k-table-thead k-grid-header",
+        role: "presentation",
+        ref: (t) => this.element = t,
+        ...Bn
+      },
+      this.props.headerRow,
+      this.props.filterRow
+    );
+  }
+}
+function no(e) {
+  const t = e.onClick ? {
+    onClick: e.onClick
+  } : {}, r = /* @__PURE__ */ a.createElement("span", { className: "k-link", ...t }, /* @__PURE__ */ a.createElement("span", { className: "k-column-title" }, e.title || e.field || " "), e.children);
+  return /* @__PURE__ */ a.createElement(a.Fragment, null, e.render ? e.render.call(void 0, r, e) : r);
+}
+const oo = (...e) => Object.assign({ allowUnsort: !0, mode: "single" }, ...e);
+class so extends a.Component {
+  constructor() {
+    super(...arguments), this.draggable = null, this.isDragged = !1, this.onDrag = (t) => {
+      this.isDragged = !0;
+      const r = this.draggable && this.draggable.element;
+      r && this.props.resize(t.event, r, !1);
+    }, this.onRelease = (t) => {
+      if (!this.isDragged)
+        return;
+      const r = this.draggable && this.draggable.element;
+      r && this.props.resize(t.event, r, !0), this.isDragged = !1;
+    }, this.onDoubleClick = (t) => {
+      if (this.isDragged)
+        return;
+      const r = this.draggable && this.draggable.element;
+      r && this.props.autofit && this.props.autofit(t, r);
+    };
+  }
+  render() {
+    return /* @__PURE__ */ a.createElement(
+      ht,
+      {
+        onPress: (t) => {
+          t.event.originalEvent.stopPropagation();
+        },
+        onDrag: this.onDrag,
+        onRelease: this.onRelease,
+        ref: (t) => {
+          this.draggable = t;
+        }
+      },
+      /* @__PURE__ */ a.createElement(
+        "span",
+        {
+          className: "k-column-resizer",
+          style: { touchAction: "none" },
+          draggable: !1,
+          onDoubleClick: this.onDoubleClick
+        }
+      )
+    );
+  }
+}
+class ao extends a.PureComponent {
+  constructor() {
+    super(...arguments), this.draggable = null, this.onPress = (t) => {
+      const r = this.draggable && this.draggable.element;
+      r && this.props.pressHandler && this.props.pressHandler(t.event, r);
+    }, this.onDrag = (t) => {
+      const r = this.draggable && this.draggable.element;
+      r && this.props.dragHandler && this.props.dragHandler(t.event, r);
+    }, this.onRelease = (t) => {
+      this.draggable && this.draggable.element && this.props.releaseHandler && this.props.releaseHandler(t.event);
+    };
+  }
+  render() {
+    return /* @__PURE__ */ a.createElement(
+      ht,
+      {
+        onPress: this.onPress,
+        onDrag: this.onDrag,
+        onRelease: this.onRelease,
+        ref: (t) => {
+          this.draggable = t;
+        }
+      },
+      /* @__PURE__ */ a.createElement("tr", { className: "k-table-row", "aria-rowindex": this.props.ariaRowIndex, role: "row" }, this.props.children)
+    );
+  }
+}
+const io = {
+  true: { asc: "desc", desc: "", "": "asc" },
+  false: { asc: "desc", desc: "asc", "": "asc" }
+}, lo = {
+  none: "none",
+  asc: "ascending",
+  desc: "descending"
+};
+class co extends a.Component {
+  constructor() {
+    super(...arguments), this.cellClick = (t, r) => {
+      if (t.preventDefault(), !this.props.sortChange)
+        return;
+      const { allowUnsort: n, mode: o } = oo(this.props.sortable || !1, r.sortable || !1), s = (this.props.sort || []).filter((c) => c.field === r.field)[0], i = io[n][s && s.dir || ""], l = o === "single" ? [] : (this.props.sort || []).filter((c) => c.field !== r.field);
+      i !== "" && r.field && l.push({ field: r.field, dir: i }), this.props.sortChange(t, l, r.field);
+    }, this.cellKeyDown = (t, r) => {
+      t.isDefaultPrevented() || t.keyCode === B.enter && this.cellClick(t, r);
+    }, this.cells = (t) => t.map((r, n) => {
+      const o = this.props.columns[r], { columnResize: s } = this.props, i = s && s.resizable && o.resizable, l = this.props.sortable && o.sortable, c = this.props.sort ? this.props.sort.findIndex((g) => g.field === o.field) : -1, u = c >= 0 && this.props.sort[c].dir || "none", p = {
+        sort: this.props.sort,
+        onSortChange: this.props.sortChange,
+        filter: this.props.columnMenuFilter,
+        onFilterChange: this.props.columnMenuFilterChange,
+        field: o.field
+      }, f = {
+        field: o.field,
+        onClick: l && ((g) => this.cellClick(g, o)) || void 0,
+        selectionChange: this.props.selectionChange,
+        title: o.title,
+        selectionValue: o.headerSelectionValue,
+        render: this.props.cellRender,
+        children: this.sortIcon(c),
+        sort: this.props.sort,
+        sortable: this.props.sortable,
+        sortChange: this.props.sortChange,
+        filterChange: this.props.filterChange,
+        columns: this.props.columns,
+        columnMenuWrapperProps: p
+      }, m = o.columnMenu || this.props.columnMenu, h = _(
+        "k-table-th",
+        {
+          "k-first": o.kFirst,
+          "k-filterable": !!m,
+          "k-header": !0,
+          "k-grid-header-sticky": o.locked,
+          "k-sorted": this.props.sort && this.props.sort.some((g) => g.field === o.field)
+        },
+        o.headerClassName
+      ), C = o.locked !== void 0 ? {
+        left: o.left,
+        right: o.right,
+        borderRightWidth: o.rightBorder ? "1px" : ""
+      } : {}, b = q(this).toLanguageString(at, v[at]);
+      let x = o.isAccessible ? {
+        ariaSort: l ? lo[u] : void 0,
+        role: "columnheader",
+        ariaColumnIndex: o.ariaColumnIndex,
+        ariaSelected: !1,
+        ariaDescription: l ? b : ""
+      } : {
+        role: "presentation"
+      };
+      return /* @__PURE__ */ a.createElement(
+        Et,
+        {
+          key: n,
+          colSpan: o.colSpan,
+          rowSpan: o.rowSpan,
+          className: h,
+          style: C,
+          columnId: o.id,
+          navigatable: o.navigatable,
+          onKeyDown: l && ((g) => this.cellKeyDown(g, o)) || void 0,
+          ...x
+        },
+        o.headerCell && /* @__PURE__ */ a.createElement(o.headerCell, { ...f }),
+        !o.headerCell && /* @__PURE__ */ a.createElement("span", { className: "k-cell-inner" }, /* @__PURE__ */ a.createElement(no, { ...f }), m && /* @__PURE__ */ a.createElement(m, { ...p })),
+        s && i && /* @__PURE__ */ a.createElement(
+          so,
+          {
+            key: "ColumnResizer",
+            resize: (g, I, F) => s.dragHandler(g, o, I, F)
+          }
+        )
+      );
+    });
+  }
+  sortIcon(t) {
+    if (!this.props.sort || t < 0)
+      return null;
+    const r = this.props.sort[t].dir;
+    return r ? [
+      /* @__PURE__ */ a.createElement(Re, { key: 1, name: `sort-${r}-small`, icon: r === "asc" ? Ut : jt }),
+      this.props.sort.length > 1 && /* @__PURE__ */ a.createElement("span", { key: 2, className: "k-sort-order" }, t + 1)
+    ] : null;
+  }
+  render() {
+    return this.props.columnsMap.map((t, r) => this.props.pressHandler && /* @__PURE__ */ a.createElement(
+      ao,
+      {
+        key: r,
+        pressHandler: this.props.pressHandler,
+        dragHandler: this.props.dragHandler,
+        releaseHandler: this.props.releaseHandler,
+        ariaRowIndex: r + 1
+      },
+      this.cells(t)
+    ) || /* @__PURE__ */ a.createElement("tr", { className: "k-table-row", "aria-rowindex": r + 1, role: "row" }, this.cells(t)));
+  }
+}
+$(co);
+function ps(e) {
+  const t = [
+    /* @__PURE__ */ a.createElement(
+      "input",
+      {
+        key: 0,
+        checked: e.selectionValue,
+        id: e.inputId,
+        type: "checkbox",
+        className: "k-checkbox k-checkbox-md k-rounded-md",
+        onChange: (r) => e.selectionChange({
+          field: e.field,
+          syntheticEvent: r
+        })
+      }
+    ),
+    /* @__PURE__ */ a.createElement("label", { key: 1, className: "k-checkbox-label", htmlFor: e.inputId })
+  ];
+  return /* @__PURE__ */ a.createElement(a.Fragment, null, e.render ? e.render.call(void 0, t, e) : t);
+}
+function ds(e) {
+  const { enabled: t, columns: r = [], tableViewPortWidth: n, scrollLeft: o } = e, s = r.map(() => 1), i = r.map(() => !1);
+  if (!t)
+    return { colSpans: s, hiddenColumns: i };
+  const l = r.map((g) => parseFloat((g.width || "").toString()) || 10);
+  let c = 0;
+  for (let g = 0; g < r.length; g++) {
+    if (r[g].locked)
+      continue;
+    const I = g < l.length - 1 ? l[g + 1] : 0;
+    if (c + l[g] + I < o)
+      i[g] = !0, c += l[g];
+    else
+      break;
+  }
+  const u = l.reduce((g, I) => g + I, 0);
+  c = 0;
+  for (let g = r.length - 1; g >= 0; g--)
+    if (!r[g].locked)
+      if (c + 2 * l[g] < u - n - o)
+        i[g] = !0, c += l[g];
+      else
+        break;
+  const p = [...i], f = (g) => g;
+  let m = p.lastIndexOf(!1), h = p.some(f), C = p.every(f), b, x;
+  for (; h && p.length && (m !== -1 || C); ) {
+    for (m < p.length - 1 && (b = C ? p.length : p.length - m - 1, x = p.length - b, x === 0 && (x = b - 1), i[x] = !1, s[x] = b, p.splice(m + 1, b)); p.length && !p[p.length - 1]; )
+      p.pop();
+    m = p.lastIndexOf(!1), h = p.some(f), C = p.every(f);
+  }
+  return { colSpans: s, hiddenColumns: i };
+}
+class hs {
+  constructor(t) {
+    this.columns = [], this.resizable = !1, this.isRtl = !1, this.setIsRtl = (r) => {
+      this.isRtl = r;
+    }, this.onResize = t, this.dragHandler = this.dragHandler.bind(this);
+  }
+  dragHandler(t, r, n, o) {
+    const s = t.originalEvent;
+    o || (s.preventDefault(), s.stopPropagation(), s.stopImmediatePropagation());
+    const i = n.parentElement;
+    if (!i || !i.parentElement)
+      return;
+    const l = i.clientWidth;
+    let c;
+    if (this.isRtl ? (c = n.getBoundingClientRect().right - n.offsetWidth / 2 - t.clientX, c += l) : c = l + t.clientX - n.getBoundingClientRect().left - n.offsetWidth / 2, !o && Math.abs(c - l) < 1)
+      return;
+    this.setWidths(r, Math.floor(c) / l);
+    const u = this.columns.filter((p) => !p.children.length).indexOf(r);
+    this.onResize(u, l, c, s, o);
+  }
+  setWidths(t, r) {
+    const n = this.columns.indexOf(t), o = [];
+    let s = t.children.length;
+    for (let i = n + 1; s > 0 && i < this.columns.length; i++, s--) {
+      const l = this.columns[i];
+      l.children.length ? s += l.children.length : o.push(l);
+    }
+    o.length === 0 && o.push(t), o.forEach((i) => {
+      let l = i.width ? parseFloat(i.width.toString()) * r : 0;
+      const c = i.minResizableWidth === void 0 ? 10 : i.minResizableWidth;
+      l < c && (l = c), i.width = Math.floor(l);
+    }), this.updateColElements(o);
+  }
+  updateColElements(t) {
+    const r = this.columns.filter((o) => !o.children.length);
+    let n = 1e-10;
+    for (let o = 0; o < t.length; o++) {
+      const s = r.indexOf(t[o]), i = parseFloat((t[o].width || 0).toString());
+      n += i - Math.floor(i);
+      const l = Math.floor(i) + Math.floor(n);
+      n -= Math.floor(n), this.setColWidth(this.colGroupMain && this.colGroupMain.children[s], l), this.setColWidth(this.colGroupHeader && this.colGroupHeader.children[s], l), this.setColWidth(this.colGroupFooter && this.colGroupFooter.children[s], l);
+    }
+  }
+  setColWidth(t, r) {
+    t && (t.style.width = r + "px");
+  }
+}
+class gs {
+  constructor(t, r, n) {
+    this.columns = [], this.reorderable = !1, this.groupable = !1, this.startColumn = -1, this.startGroup = -1, this.currentColumn = -1, this.currentGroup = -1, this.dropElementClue = null, this.dragElementClue = null, this.groupPanelDivElement = null, this.refGroupPanelDiv = (o) => {
+      this.groupPanelDivElement = o;
+    }, this.refDropElementClue = (o) => {
+      this.dropElementClue = o;
+    }, this.refDragElementClue = (o) => {
+      this.dragElementClue = o;
+    }, this.pressHandler = (o, s) => {
+      const i = this.getColumnIndex(o, s);
+      if (this.startGroup = this.getGroupIndex(o), i >= 0) {
+        const l = this.columns[i];
+        (l.reorderable && this.reorderable || l.groupable && this.groupable) && (this.startColumn = i);
+      }
+    }, this.dragHandler = (o, s) => {
+      if (o.isTouch || o.originalEvent.preventDefault(), o.originalEvent.stopPropagation(), this.startColumn === -1 && this.startGroup === -1)
+        return;
+      this.currentColumn = this.getColumnIndex(o, s), this.currentGroup = this.getGroupIndex(o), this.groupPanelDivElement && this.startGroup >= 0 && (this.currentGroup = Math.min(this.currentGroup, this.groupPanelDivElement.children.length - 2));
+      const i = !this.isValid();
+      i && (this.currentColumn = -1, this.currentGroup = -1);
+      const l = this.currentColumn >= 0 ? s.children[this.columns[this.currentColumn].index] : this.groupPanelDivElement && this.groupPanelDivElement.children[this.currentGroup];
+      this.updateDragElementClue(o, s, l, i), this.updateDropElementClue(o, s, l, i);
+    }, this.releaseHandler = (o) => {
+      const s = this.startColumn, i = this.currentColumn, l = this.startGroup, c = this.currentGroup;
+      this.dropElementClue && this.dropElementClue.setState({ visible: !1 }), this.dragElementClue && this.dragElementClue.setState({ visible: !1 });
+      const u = this.isValid();
+      this.startColumn = this.startGroup = this.currentColumn = this.currentGroup = -1, u && (s >= 0 && i >= 0 ? this.columnReorder(s, i, o.originalEvent) : l >= 0 && c >= 0 ? this.groupReorder(l, c, o.originalEvent) : s >= 0 && c >= 0 && this.columnToGroup(s, c, o.originalEvent));
+    }, this.columnReorder = t, this.groupReorder = r, this.columnToGroup = n;
+  }
+  getColumnIndex(t, r) {
+    if (!r || r.parentElement === this.groupPanelDivElement)
+      return -1;
+    const n = Tt(t, r);
+    if (n === -1)
+      return -1;
+    for (let o = 0; o < r.parentNode.children.length; o++)
+      if (r.parentNode.children[o] === r)
+        return this.columns.findIndex((s) => s.index === n && s.depth === o);
+    return -1;
+  }
+  getGroupIndex(t) {
+    return Tt(t, this.groupPanelDivElement);
+  }
+  isValid() {
+    return this.startGroup >= 0 ? this.currentGroup >= 0 && this.currentGroup !== this.startGroup : this.startColumn === -1 ? !1 : this.currentGroup >= 0 ? this.columns[this.startColumn].groupable === !0 && this.groupable === !0 : this.reorderable === !0 && this.currentColumn >= 0 && this.currentColumn !== this.startColumn && this.columns[this.startColumn].reorderable === !0 && this.columns[this.currentColumn].parentIndex === this.columns[this.startColumn].parentIndex;
+  }
+  updateDragElementClue(t, r, n, o) {
+    if (!this.dragElementClue)
+      return;
+    const s = this.startColumn >= 0 ? r.children[this.columns[this.startColumn].index].innerText : r.innerText;
+    this.dragElementClue.setState({
+      visible: !0,
+      top: t.pageY + 10,
+      left: t.pageX,
+      innerText: s,
+      status: o || !n ? "k-i-cancel" : "k-i-plus"
+    });
+  }
+  updateDropElementClue(t, r, n, o) {
+    if (!this.dropElementClue)
+      return;
+    if (o || !n) {
+      this.dropElementClue.setState({ visible: !1 });
+      return;
+    }
+    const s = n.getBoundingClientRect();
+    let i = s.left + t.pageX - t.clientX - 6;
+    (this.currentColumn > this.startColumn || this.currentGroup > this.startGroup && this.startGroup !== -1) && (i += s.width);
+    const l = s.top + t.pageY - t.clientY;
+    this.dropElementClue.setState({
+      visible: !0,
+      top: l,
+      left: i,
+      height: this.currentColumn >= 0 ? r.clientHeight : s.height
+    });
+  }
+}
+class fs extends a.PureComponent {
+  constructor(t) {
+    super(t), this.elementRef = a.createRef(), this.state = {
+      visible: !1,
+      top: 0,
+      left: 0,
+      innerText: "",
+      status: "k-i-cancel"
+    }, this.hiddenElementRef = a.createRef();
+  }
+  get element() {
+    return this.elementRef.current;
+  }
+  render() {
+    const t = this.hiddenElementRef.current, { status: r } = this.state, n = this.state.visible && $t && Jt(
+      /* @__PURE__ */ a.createElement(
+        "div",
+        {
+          ref: this.elementRef,
+          className: "k-header k-drag-clue",
+          style: {
+            display: "block",
+            position: "absolute",
+            zIndex: 2e4,
+            padding: "8px 12px",
+            top: this.state.top + "px",
+            left: this.state.left + "px"
+          }
+        },
+        /* @__PURE__ */ a.createElement(Re, { className: "k-drag-status", name: r, icon: r === "k-i-cancel" ? vn : En }),
+        this.state.innerText
+      ),
+      t && t.ownerDocument ? t.ownerDocument.body : document.body
+    );
+    return /* @__PURE__ */ a.createElement(a.Fragment, null, n, /* @__PURE__ */ a.createElement("div", { ref: this.hiddenElementRef, style: { display: "none" } }));
+  }
+}
+class ms extends a.PureComponent {
+  constructor(t) {
+    super(t), this.state = {
+      height: 0,
+      visible: !1,
+      left: 0,
+      top: 0
+    }, this.hiddenElementRef = a.createRef();
+  }
+  render() {
+    const t = this.hiddenElementRef.current, r = this.state.visible && $t && Jt(
+      /* @__PURE__ */ a.createElement(
+        "div",
+        {
+          className: "k-grouping-dropclue",
+          style: {
+            zIndex: 1e4,
+            display: "block",
+            top: this.state.top + "px",
+            left: this.state.left + "px",
+            height: this.state.height + "px"
+          }
+        }
+      ),
+      t && t.ownerDocument ? t.ownerDocument.body : document.body
+    );
+    return /* @__PURE__ */ a.createElement(a.Fragment, null, r, /* @__PURE__ */ a.createElement("div", { ref: this.hiddenElementRef, style: { display: "none" } }));
+  }
+}
+class Yr extends a.Component {
+  constructor() {
+    super(...arguments), this.onChange = (t) => {
+      this.props.onFilterChange.call(void 0, {
+        nextFilter: { ...this.props.filter, value: t.value }
+      });
+    };
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const t = q(this), { ariaLabel: r = t.toLanguageString(et, v[et]) } = this.props;
+    return /* @__PURE__ */ a.createElement(
+      gn,
+      {
+        value: this.props.filter.value || "",
+        onChange: this.onChange,
+        "aria-label": r
+      }
+    );
+  }
+}
+Yr.propTypes = {
+  filter: d.object.isRequired,
+  onFilterChange: d.func.isRequired,
+  ariaLabel: d.string
+};
+$(Yr);
+class Xr extends a.Component {
+  constructor() {
+    super(...arguments), this.onChange = (t) => {
+      this.props.onFilterChange.call(void 0, {
+        nextFilter: { ...this.props.filter, value: t.value }
+      });
+    };
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const t = q(this), {
+      min: r,
+      max: n,
+      filter: o,
+      ariaLabel: s = t.toLanguageString(Qe, v[Qe])
+    } = this.props;
+    return /* @__PURE__ */ a.createElement(
+      Me,
+      {
+        value: typeof o.value == "number" ? o.value : null,
+        onChange: this.onChange,
+        ariaLabel: s,
+        "aria-valuemin": r,
+        "aria-valuemax": n,
+        min: r,
+        max: n
+      }
+    );
+  }
+}
+Xr.propTypes = {
+  filter: d.object.isRequired,
+  onFilterChange: d.func.isRequired
+};
+$(Xr);
+class uo extends a.Component {
+  constructor() {
+    super(...arguments), this.onChange = (t) => {
+      this.props.onFilterChange.call(void 0, {
+        nextFilter: { ...this.props.filter, value: t.value }
+      });
+    };
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const t = this.props.filter;
+    return /* @__PURE__ */ a.createElement(
+      ft,
+      {
+        value: t.value || null,
+        onChange: this.onChange,
+        ariaLabel: this.props.ariaLabel
+      }
+    );
+  }
+}
+uo.propTypes = {
+  filter: d.object.isRequired,
+  onFilterChange: d.func.isRequired,
+  ariaLabel: d.string
+};
+class bt extends a.Component {
+  constructor() {
+    super(...arguments), this.onChange = (t) => {
+      this.props.onFilterChange.call(void 0, {
+        nextFilter: { ...this.props.filter, value: t.value.value }
+      });
+    };
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    const t = q(this), {
+      filter: r,
+      data: n = [],
+      defaultItem: o,
+      ariaLabel: s = t.toLanguageString(Je, v[Je])
+    } = this.props, i = n.map((l) => ({
+      ...l,
+      text: t.toLanguageString(l.text, v[l.text] || l.text)
+    }));
+    return /* @__PURE__ */ a.createElement(
+      G,
+      {
+        value: i.find((l) => l.value === r.value) || null,
+        onChange: this.onChange,
+        defaultItem: o,
+        data: i,
+        textField: "text",
+        ariaLabel: s
+      }
+    );
+  }
+}
+bt.propTypes = {
+  filter: d.object.isRequired,
+  onFilterChange: d.func.isRequired,
+  data: d.arrayOf(d.shape({ text: d.string, value: d.any })),
+  defaultItem: d.any,
+  ariaLabel: d.string
+};
+$(bt);
+class po extends a.Component {
+  constructor() {
+    super(...arguments), this.data = [{ text: pr, value: !0 }, { text: dr, value: !1 }];
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    return /* @__PURE__ */ a.createElement(
+      bt,
+      {
+        filter: this.props.filter,
+        onFilterChange: this.props.onFilterChange,
+        data: this.props.data || this.data,
+        defaultItem: this.props.defaultItem,
+        ariaLabel: this.props.ariaLabel
+      }
+    );
+  }
+}
+po.propTypes = {
+  filter: d.object.isRequired,
+  onFilterChange: d.func.isRequired,
+  data: d.arrayOf(d.shape({ text: d.string, value: d.any })),
+  ariaLabel: d.string,
+  defaultItem: d.any
+};
+const ho = [
+  { text: or, operator: "contains" },
+  { text: sr, operator: "doesnotcontain" },
+  { text: ie, operator: "eq" },
+  { text: le, operator: "neq" },
+  { text: nr, operator: "startswith" },
+  { text: ar, operator: "endswith" },
+  { text: Le, operator: "isnull" },
+  { text: De, operator: "isnotnull" },
+  { text: tr, operator: "isempty" },
+  { text: rr, operator: "isnotempty" }
+], go = [
+  { text: ie, operator: "eq" },
+  { text: le, operator: "neq" },
+  { text: ir, operator: "gte" },
+  { text: lr, operator: "gt" },
+  { text: cr, operator: "lte" },
+  { text: ur, operator: "lt" },
+  { text: Le, operator: "isnull" },
+  { text: De, operator: "isnotnull" }
+], fo = [
+  { text: ie, operator: "eq" },
+  { text: le, operator: "neq" },
+  { text: hr, operator: "gte" },
+  { text: gr, operator: "gt" },
+  { text: fr, operator: "lt" },
+  { text: mr, operator: "lte" },
+  { text: Le, operator: "isnull" },
+  { text: De, operator: "isnotnull" }
+], mo = [
+  { text: ie, operator: "eq" },
+  { text: le, operator: "neq" }
+];
+class vs {
+  /**
+   * An array containing the operators for the TextFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'filter.containsOperator', operator: 'contains' }
+   * - { text: 'filter.notContainsOperator', operator: 'doesnotcontain' }
+   * - { text: 'filter.eqOperator', operator: 'eq' }
+   * - { text: 'filter.notEqOperator', operator: 'neq' }
+   * - { text: 'filter.startsWithOperator', operator: 'startswith' }
+   * - { text: 'filter.endsWithOperator', operator: 'endswith' }
+   * - { text: 'filter.isNullOperator', operator: 'isnull' }
+   * - { text: 'filter.isNotNullOperator', operator: 'isnotnull' }
+   * - { text: 'filter.isEmptyOperator', operator: 'isempty' }
+   * - { text: 'filter.isNotEmptyOperator', operator: 'isnotempty' }
+   */
+  static get text() {
+    return [...ho];
+  }
+  /**
+   * An array containing the operators for the NumericFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'filter.eqOperator', operator: 'eq' }
+   * - { text: 'filter.notEqOperator', operator: 'neq' }
+   * - { text: 'filter.gteOperator', operator: 'gte' }
+   * - { text: 'filter.gtOperator', operator: 'gt' }
+   * - { text: 'filter.lteOperator', operator: 'lte' }
+   * - { text: 'filter.ltOperator', operator: 'lt' }
+   * - { text: 'filter.isNullOperator', operator: 'isnull' }
+   * - { text: 'filter.isNotNullOperator', operator: 'isnotnull' }
+   */
+  static get numeric() {
+    return [...go];
+  }
+  /**
+   * An array containing the operators for the DateFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'filter.eqOperator', operator: 'eq' }
+   * - { text: 'filter.notEqOperator', operator: 'neq' }
+   * - { text: 'filter.afterOrEqualOperator', operator: 'gte' }
+   * - { text: 'filter.afterOperator', operator: 'gt' }
+   * - { text: 'filter.beforeOperator', operator: 'lt' }
+   * - { text: 'filter.beforeOrEqualOperator', operator: 'lte' }
+   * - { text: 'filter.isNullOperator', operator: 'isnull' }
+   * - { text: 'filter.isNotNullOperator', operator: 'isnotnull' }
+   */
+  static get date() {
+    return [...fo];
+  }
+  /**
+   * An array containing the operators for the BooleanFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'filter.eqOperator', operator: 'eq' }
+   * - { text: 'filter.notEqOperator', operator: 'neq' }
+   */
+  static get boolean() {
+    return [...mo];
+  }
+}
+const Ur = (e) => e === "contains" || e === "doesnotcontain" || e === "startswith" || e === "endswith", ut = (e) => e === "isnull" || e === "isnotnull" || e === "isempty" || e === "isnotempty", Bt = (e) => {
+  e.value === void 0 && !ut(e.operator) && (e.value = Ur(e.operator) ? "" : null);
+};
+class yt extends a.Component {
+  constructor() {
+    super(...arguments), this.onFieldChange = (t) => {
+      const r = t.value.name, n = this.props.fields.find((l) => l.name === r), o = this.props.filter, s = n && !n.operators.some((l) => l.operator === o.operator) ? n.operators[0].operator : o.operator, i = {
+        field: r,
+        operator: s
+      };
+      Bt(i), this.triggerOnFilterChange(o, i, t);
+    }, this.onOperatorChange = (t) => {
+      const r = t.value.operator, n = this.props.filter;
+      let o;
+      if (ut(r)) {
+        let { value: s, ...i } = n;
+        o = { ...i, operator: r };
+      } else
+        o = { ...n, operator: r };
+      Bt(o), this.triggerOnFilterChange(n, o, t);
+    }, this.onInputChange = (t) => {
+      const r = this.props.filter;
+      let n = t.nextFilter;
+      if (ut(n.operator)) {
+        const o = this.props.fields.find((s) => s.name === n.field);
+        n = { ...n, operator: o && o.operators[0].operator || n.operator };
+      }
+      this.triggerOnFilterChange(r, n, t);
+    }, this.triggerOnFilterChange = (t, r, n) => {
+      const o = {
+        prevFilter: t,
+        nextFilter: r,
+        syntheticEvent: n.syntheticEvent,
+        nativeEvent: n.nativeEvent,
+        target: this
+      };
+      this.props.onChange.call(void 0, o);
+    }, this.onFilterRemove = (t) => {
+      const r = {
+        filter: this.props.filter,
+        syntheticEvent: t.syntheticEvent,
+        nativeEvent: t.nativeEvent,
+        target: this
+      };
+      this.props.onRemove.call(void 0, r);
+    };
+  }
+  render() {
+    const t = q(this), {
+      fields: r,
+      filter: n,
+      ariaLabel: o = t.toLanguageString(Ue, v[Ue])
+    } = this.props, s = r.find((l) => l.name === n.field), i = (s && s.operators || []).map((l) => ({ ...l, text: t.toLanguageString(l.text, v[l.text] || l.text) }));
+    return /* @__PURE__ */ a.createElement("div", { className: "k-filter-toolbar" }, /* @__PURE__ */ a.createElement(Ht, { keyboardNavigation: !1, role: "toolbar", ariaLabel: o }, /* @__PURE__ */ a.createElement(We, { className: "k-filter-field" }, /* @__PURE__ */ a.createElement(
+      G,
+      {
+        className: "k-filter-dropdown",
+        data: r,
+        textField: "label",
+        value: r.find((l) => l.name === n.field),
+        onChange: this.onFieldChange,
+        ariaLabel: t.toLanguageString(je, v[je])
+      }
+    )), /* @__PURE__ */ a.createElement(We, { className: "k-filter-operator" }, /* @__PURE__ */ a.createElement(
+      G,
+      {
+        data: i,
+        textField: "text",
+        value: i.find((l) => l.operator === n.operator),
+        onChange: this.onOperatorChange,
+        ariaLabel: t.toLanguageString(Ze, v[Ze])
+      }
+    )), /* @__PURE__ */ a.createElement(We, { className: "k-filter-value" }, s && /* @__PURE__ */ a.createElement(s.filter, { filter: n, onFilterChange: this.onInputChange, min: s.min, max: s.max })), /* @__PURE__ */ a.createElement(
+      K,
+      {
+        className: "k-toolbar-button",
+        title: t.toLanguageString(oe, v[oe]),
+        icon: "x",
+        svgIcon: Zt,
+        fillMode: "flat",
+        type: "button",
+        onClick: this.onFilterRemove
+      }
+    )));
+  }
+}
+yt.propTypes = {
+  filter: d.object.isRequired,
+  fields: d.array.isRequired,
+  ariaLabel: d.string,
+  onChange: d.func.isRequired,
+  onRemove: d.func.isRequired
+};
+$(yt);
+const jr = class extends a.Component {
+  constructor() {
+    super(...arguments), this.onGroupRemove = (e) => {
+      const t = {
+        filter: this.props.filter,
+        target: this,
+        syntheticEvent: e,
+        nativeEvent: e.nativeEvent
+      };
+      this.props.onRemove.call(void 0, t);
+    }, this.onAddExpression = (e) => {
+      const t = this.props.filter, r = this.props.fields[0], n = { field: r.name, operator: r.operators[0].operator };
+      n.value = Ur(n.operator) ? "" : null;
+      const o = {
+        nextFilter: {
+          ...t,
+          filters: [...t.filters, n]
+        },
+        prevFilter: t,
+        target: this,
+        syntheticEvent: e,
+        nativeEvent: e.nativeEvent
+      };
+      this.props.onChange.call(void 0, o);
+    }, this.onAddGroup = (e) => {
+      const t = this.props.filter, r = {
+        nextFilter: { ...t, filters: [...t.filters, { ...this.props.defaultGroupFilter }] },
+        prevFilter: t,
+        target: this,
+        syntheticEvent: e,
+        nativeEvent: e.nativeEvent
+      };
+      this.props.onChange.call(void 0, r);
+    }, this.onLogicAnd = (e) => this.changeLogic("and", e), this.onLogicOr = (e) => this.changeLogic("or", e), this.changeLogic = (e, t) => {
+      const r = this.props.filter;
+      if (r.logic !== e) {
+        const n = {
+          nextFilter: { ...r, logic: e },
+          prevFilter: r,
+          target: this,
+          syntheticEvent: t,
+          nativeEvent: t.nativeEvent
+        };
+        this.props.onChange.call(void 0, n);
+      }
+    }, this.replaceFilter = (e, t) => {
+      const r = this.props.filter, n = r.filters.map((o) => o === e ? t : o);
+      return { ...r, filters: n };
+    }, this.onChange = (e) => {
+      const r = {
+        nextFilter: this.replaceFilter(e.prevFilter, e.nextFilter),
+        prevFilter: this.props.filter,
+        syntheticEvent: e.syntheticEvent,
+        nativeEvent: e.nativeEvent,
+        target: this
+      };
+      this.props.onChange.call(void 0, r);
+    }, this.onRemove = (e) => {
+      const t = this.props.filter, r = t.filters.filter((o) => o !== e.filter), n = {
+        nextFilter: { ...t, filters: r },
+        prevFilter: t,
+        syntheticEvent: e.syntheticEvent,
+        nativeEvent: e.nativeEvent,
+        target: this
+      };
+      this.props.onChange.call(void 0, n);
+    };
+  }
+  render() {
+    const e = q(this), {
+      fields: t,
+      filter: r,
+      ariaLabel: n = e.toLanguageString(Xe, v[Xe])
+    } = this.props;
+    return /* @__PURE__ */ a.createElement(a.Fragment, null, /* @__PURE__ */ a.createElement("div", { className: "k-filter-toolbar" }, /* @__PURE__ */ a.createElement(Ht, { keyboardNavigation: !1, role: "toolbar", ariaLabel: n }, /* @__PURE__ */ a.createElement(dn, { className: "k-toolbar-button-group" }, /* @__PURE__ */ a.createElement(K, { className: "k-toolbar-button", togglable: !0, onClick: this.onLogicAnd, selected: r.logic === "and", type: "button" }, e.toLanguageString(Ve, v[Ve])), /* @__PURE__ */ a.createElement(K, { className: "k-toolbar-button", togglable: !0, onClick: this.onLogicOr, selected: r.logic === "or", type: "button" }, e.toLanguageString(Ye, v[Ye]))), /* @__PURE__ */ a.createElement(
+      K,
+      {
+        className: "k-toolbar-button",
+        title: e.toLanguageString(te, v[te]),
+        icon: "filter-add-expression",
+        svgIcon: Cn,
+        type: "button",
+        onClick: this.onAddExpression
+      },
+      e.toLanguageString(te, v[te])
+    ), /* @__PURE__ */ a.createElement(
+      K,
+      {
+        className: "k-toolbar-button",
+        title: e.toLanguageString(re, v[re]),
+        icon: "filter-add-group",
+        svgIcon: xn,
+        type: "button",
+        onClick: this.onAddGroup
+      },
+      e.toLanguageString(re, v[re])
+    ), /* @__PURE__ */ a.createElement(
+      K,
+      {
+        className: "k-toolbar-button",
+        title: e.toLanguageString(oe, v[oe]),
+        icon: "x",
+        svgIcon: Zt,
+        fillMode: "flat",
+        type: "button",
+        onClick: this.onGroupRemove
+      }
+    ))), r.filters.length > 0 && /* @__PURE__ */ a.createElement("ul", { role: "group", className: "k-filter-lines" }, r.filters.map(
+      (o, s) => /* @__PURE__ */ a.createElement("li", { role: "treeitem", key: s, className: "k-filter-item" }, Qt(o) ? /* @__PURE__ */ a.createElement(
+        jr,
+        {
+          filter: o,
+          fields: t,
+          onChange: this.onChange,
+          onRemove: this.onRemove,
+          defaultGroupFilter: this.props.defaultGroupFilter,
+          ariaLabel: this.props.ariaLabel,
+          ariaLabelExpression: this.props.ariaLabelExpression
+        }
+      ) : /* @__PURE__ */ a.createElement(
+        yt,
+        {
+          filter: o,
+          fields: t,
+          ariaLabel: this.props.ariaLabelExpression,
+          onChange: this.onChange,
+          onRemove: this.onRemove
+        }
+      ))
+    )));
+  }
+};
+let It = jr;
+It.propTypes = {
+  filter: d.object.isRequired,
+  fields: d.array.isRequired,
+  ariaLabel: d.string,
+  ariaLabelExpression: d.string,
+  onChange: d.func.isRequired,
+  onRemove: d.func.isRequired,
+  defaultGroupFilter: d.object.isRequired
+};
+$(It);
+class vo extends a.Component {
+  constructor(t) {
+    super(t), this.onFilterChange = (r) => {
+      const n = {
+        filter: r.nextFilter,
+        syntheticEvent: r.syntheticEvent,
+        nativeEvent: r.nativeEvent,
+        target: this
+      };
+      this.props.onChange.call(void 0, n);
+    }, this.onGroupRemove = (r) => {
+      const n = {
+        filter: { ...this.props.value, filters: [] },
+        syntheticEvent: r.syntheticEvent,
+        nativeEvent: r.nativeEvent,
+        target: this
+      };
+      this.props.onChange.call(void 0, n);
+    }, dt(mt);
+  }
+  /**
+   * @hidden
+   */
+  render() {
+    return /* @__PURE__ */ a.createElement(
+      "div",
+      {
+        className: _(
+          "k-filter",
+          this.props.className
+        ),
+        style: this.props.style
+      },
+      /* @__PURE__ */ a.createElement("ul", { role: "tree", className: "k-filter-container", "aria-label": this.props.ariaLabel }, /* @__PURE__ */ a.createElement("li", { role: "treeitem", className: "k-filter-group-main" }, /* @__PURE__ */ a.createElement(
+        It,
+        {
+          filter: this.props.value,
+          fields: this.props.fields,
+          ariaLabel: this.props.ariaLabelGroup,
+          ariaLabelExpression: this.props.ariaLabelExpression,
+          onChange: this.onFilterChange,
+          onRemove: this.onGroupRemove,
+          defaultGroupFilter: this.props.defaultGroupFilter || { logic: "and", filters: [] }
+        }
+      )))
+    );
+  }
+}
+vo.propTypes = {
+  className: d.string,
+  style: d.object,
+  fields: function(e, t) {
+    const r = e[t];
+    if (r === void 0)
+      return new Error(`Property '${t}' is missing.`);
+    if (Array.isArray(r)) {
+      if (Object.keys(r.reduce((n, o) => ({ ...n, [o.name]: 1 }), {})).length !== r.length)
+        return new Error(`Property '${t}' needs to contain objects with unique 'name' field.`);
+    } else
+      return new Error(`Property '${t}' needs to be Array<FieldSettings>.`);
+    return null;
+  },
+  ariaLabelGroup: d.string,
+  ariaLabelExpression: d.string,
+  value: d.object.isRequired,
+  onChange: d.func.isRequired
+};
+const He = (e) => /* @__PURE__ */ a.createElement(
+  "div",
+  {
+    onClick: e.onClick,
+    className: _(
+      "k-columnmenu-item",
+      { "k-selected": e.selected },
+      { "k-disabled": e.disabled }
+    )
+  },
+  (e.iconClass || e.svgIcon) && /* @__PURE__ */ a.createElement(Re, { name: e.iconClass ? sn(e.iconClass) : void 0, icon: e.svgIcon }),
+  e.title
+), Eo = [
+  { text: xr, operator: "contains" },
+  { text: br, operator: "doesnotcontain" },
+  { text: we, operator: "eq" },
+  { text: Oe, operator: "neq" },
+  { text: Cr, operator: "startswith" },
+  { text: yr, operator: "endswith" },
+  { text: Ne, operator: "isnull" },
+  { text: Ae, operator: "isnotnull" },
+  { text: vr, operator: "isempty" },
+  { text: Er, operator: "isnotempty" }
+], Co = [
+  { text: we, operator: "eq" },
+  { text: Oe, operator: "neq" },
+  { text: Ir, operator: "gte" },
+  { text: kr, operator: "gt" },
+  { text: Sr, operator: "lte" },
+  { text: Fr, operator: "lt" },
+  { text: Ne, operator: "isnull" },
+  { text: Ae, operator: "isnotnull" }
+], xo = [
+  { text: we, operator: "eq" },
+  { text: Oe, operator: "neq" },
+  { text: Mr, operator: "gte" },
+  { text: Lr, operator: "gt" },
+  { text: Dr, operator: "lt" },
+  { text: wr, operator: "lte" },
+  { text: Ne, operator: "isnull" },
+  { text: Ae, operator: "isnotnull" }
+], bo = [
+  { text: Rr, operator: "" }
+];
+class Ke {
+  /**
+   * An array containing the operators for the ColumnMenuTextFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'columnMenu.filterContainsOperator', operator: 'contains' }
+   * - { text: 'columnMenu.filterNotContainsOperator', operator: 'doesnotcontain' }
+   * - { text: 'columnMenu.filterEqOperator', operator: 'eq' }
+   * - { text: 'columnMenu.filterNotEqOperator', operator: 'neq' }
+   * - { text: 'columnMenu.filterStartsWithOperator', operator: 'startswith' }
+   * - { text: 'columnMenu.filterEndsWithOperator', operator: 'endswith' }
+   * - { text: 'columnMenu.filterIsNullOperator', operator: 'isnull' }
+   * - { text: 'columnMenu.filterIsNotNullOperator', operator: 'isnotnull' }
+   * - { text: 'columnMenu.filterIsEmptyOperator', operator: 'isempty' }
+   * - { text: 'columnMenu.filterIsNotEmptyOperator', operator: 'isnotempty' }
+   */
+  static get text() {
+    return [...Eo];
+  }
+  /**
+   * An array containing the operators for the ColumnMenuNumericFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'columnMenu.filterEqOperator', operator: 'eq' }
+   * - { text: 'columnMenu.filterNotEqOperator', operator: 'neq' }
+   * - { text: 'columnMenu.filterGteOperator', operator: 'gte' }
+   * - { text: 'columnMenu.filterGtOperator', operator: 'gt' }
+   * - { text: 'columnMenu.filterLteOperator', operator: 'lte' }
+   * - { text: 'columnMenu.filterLtOperator', operator: 'lt' }
+   * - { text: 'columnMenu.filterIsNullOperator', operator: 'isnull' }
+   * - { text: 'columnMenu.filterIsNotNullOperator', operator: 'isnotnull' }
+   */
+  static get numeric() {
+    return [...Co];
+  }
+  /**
+   * An array containing the operators for the ColumnMenuDateFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'columnMenu.filterEqOperator', operator: 'eq' }
+   * - { text: 'columnMenu.filterNotEqOperator', operator: 'neq' }
+   * - { text: 'columnMenu.filterAfterOrEqualOperator', operator: 'gte' }
+   * - { text: 'columnMenu.filterAfterOperator', operator: 'gt' }
+   * - { text: 'columnMenu.filterBeforeOperator', operator: 'lt' }
+   * - { text: 'columnMenu.filterBeforeOrEqualOperator', operator: 'lte' }
+   * - { text: 'columnMenu.filterIsNullOperator', operator: 'isnull' }
+   * - { text: 'columnMenu.filterIsNotNullOperator', operator: 'isnotnull' }
+   */
+  static get date() {
+    return [...xo];
+  }
+  /**
+   * An array containing the operators for the ColumnMenuBooleanFilter component.
+   *
+   * The operators are:
+   *
+   * - { text: 'columnMenu.filterIsTrue', operator: '' }
+   */
+  static get boolean() {
+    return [...bo];
+  }
+}
+const kt = (e) => {
+  const { filter: t, onFilterChange: r, operators: n, initialFilter: o } = e, s = a.useCallback(
+    (u) => {
+      const p = t, f = u.target.value.operator, m = p ? { ...p, operator: f } : { value: o.value, operator: f };
+      r.call(void 0, u.syntheticEvent, m, p);
+    },
+    [t, r, o]
+  ), i = a.useCallback(
+    (u) => {
+      const p = u.target.value, f = t, m = f ? { ...f, value: p } : { value: p, operator: n[0].operator };
+      r.call(void 0, u, m, f);
+    },
+    [t, r, n]
+  ), l = Y(), c = n.map((u) => ({ ...u, text: l.toLanguageString(u.text, v[u.text]) }));
+  return /* @__PURE__ */ a.createElement(a.Fragment, null, /* @__PURE__ */ a.createElement(
+    G,
+    {
+      value: c.find((u) => u.operator === t.operator) || null,
+      onChange: s,
+      data: c,
+      textField: "text"
+    }
+  ), /* @__PURE__ */ a.createElement(
+    e.input,
+    {
+      value: t.value,
+      onChange: i
+    }
+  ));
+}, yo = (e) => {
+  const { filter: t, onFilterChange: r } = e, n = a.useCallback(
+    (s) => r.call(void 0, s.syntheticEvent, { ...t, value: s.value }, t),
+    [t, r]
+  ), o = Ke.boolean[0].text;
+  return /* @__PURE__ */ a.createElement(
+    fn,
+    {
+      onChange: n,
+      checked: t.value,
+      label: Y().toLanguageString(o, v[o]),
+      labelPlacement: "after"
+    }
+  );
+}, Kt = (e) => {
+  const t = a.useCallback((o) => /* @__PURE__ */ a.createElement(Yt, { ...o, value: o.value || "" }), []), r = a.useRef(Ke.text), n = a.useRef({ operator: "", value: "" });
+  return /* @__PURE__ */ a.createElement(
+    kt,
+    {
+      initialFilter: n.current,
+      input: t,
+      operators: e.operators || r.current,
+      ...e
+    }
+  );
+}, qt = (e) => {
+  const t = a.useCallback((o) => /* @__PURE__ */ a.createElement(Me, { ...o, value: o.value || null }), []), r = a.useRef(Ke.numeric), n = a.useRef({ operator: "", value: null });
+  return /* @__PURE__ */ a.createElement(
+    kt,
+    {
+      initialFilter: n.current,
+      input: t,
+      operators: e.operators || r.current,
+      ...e
+    }
+  );
+}, zt = (e) => {
+  const t = a.useCallback((o) => /* @__PURE__ */ a.createElement(ft, { ...o, value: o.value || null }), []), r = a.useRef(Ke.date), n = a.useRef({ operator: "", value: null });
+  return /* @__PURE__ */ a.createElement(
+    kt,
+    {
+      initialFilter: n.current,
+      input: t,
+      operators: e.operators || r.current,
+      ...e
+    }
+  );
+}, Io = [{ text: Or, logic: "and" }, { text: Nr, logic: "or" }], St = (e) => {
+  const t = Y(), r = (e.data || Io).map((n) => ({ ...n, text: t.toLanguageString(n.text, v[n.text]) }));
+  return /* @__PURE__ */ a.createElement(
+    G,
+    {
+      onChange: e.onChange,
+      className: "k-filter-and",
+      textField: "text",
+      ...e,
+      data: r,
+      value: r.find((n) => n.logic === e.value)
+    }
+  );
+}, ko = (e) => /* @__PURE__ */ a.createElement("div", { className: "k-columnmenu-item-content" }, /* @__PURE__ */ a.createElement(Sn, { style: { position: "relative", display: "block" } }, e.show && /* @__PURE__ */ a.createElement("div", { className: "kendo-grid-filter-menu-container" }, /* @__PURE__ */ a.createElement(
+  "form",
+  {
+    className: "k-filter-menu k-group k-reset k-state-border-up",
+    onSubmit: e.onSubmit,
+    onReset: e.onReset
+  },
+  /* @__PURE__ */ a.createElement("div", { className: "k-filter-menu-container" }, e.children, /* @__PURE__ */ a.createElement("div", { className: "k-actions k-hstack k-justify-content-stretch" }, e.actions))
+)))), So = (e) => {
+  const t = Y();
+  return /* @__PURE__ */ a.createElement(
+    ko,
+    {
+      ...e,
+      actions: /* @__PURE__ */ a.createElement(a.Fragment, null, /* @__PURE__ */ a.createElement(
+        K,
+        {
+          type: "reset"
+        },
+        t.toLanguageString(tt, v[tt])
+      ), /* @__PURE__ */ a.createElement(
+        K,
+        {
+          themeColor: "primary"
+        },
+        t.toLanguageString(rt, v[rt])
+      ))
+    }
+  );
+}, qe = (e) => {
+  dt(mt);
+  const t = a.useRef([]), {
+    field: r,
+    filter: n,
+    sort: o = t.current,
+    onSortChange: s,
+    onFilterChange: i,
+    initialFilter: l,
+    sortAsc: c = !1,
+    sortDesc: u = !1,
+    filterContent: p = [],
+    expandFilters: f = !1
+  } = e, [m, h] = a.useState(!1), [C, b] = a.useState(f), [x, g] = a.useState(r && l ? l(r) : null), I = a.useRef(null), F = a.useRef(null), k = a.useRef(null), E = a.useRef(!1), y = a.useCallback(
+    () => (n || []).find((R) => R.filters.every((D) => !Qt(D) && D.field === r)),
+    [n, r]
+  ), S = a.useCallback(
+    () => {
+      h(!1);
+    },
+    []
+  ), w = a.useCallback(
+    () => {
+      if (E.current) {
+        E.current = !1;
+        return;
+      }
+      clearTimeout(k.current), k.current = window.setTimeout(() => {
+        S();
+      });
+    },
+    [S]
+  ), P = a.useCallback(
+    () => clearTimeout(k.current),
+    []
+  ), T = a.useCallback((R) => {
+    E.current = m && R.currentTarget === I.current;
+  }, [m]), z = a.useCallback(
+    () => {
+      h(!m), r && l && (b(m ? !1 : f), g(m ? x : y() || l(r)));
+    },
+    [y, r, m, x, l, f]
+  );
+  a.useEffect(
+    () => {
+      m && F.current && F.current.focus();
+    },
+    [m]
+  );
+  const L = a.useCallback(
+    () => b(!C),
+    [C]
+  ), O = a.useCallback(
+    (R, D) => {
+      const N = [...o], A = N.findIndex((on) => on.field === r), ee = { field: r, dir: D };
+      A >= 0 ? N[A].dir !== ee.dir ? N.splice(A, 1, ee) : N.splice(A, 1) : N.push(ee), S(), s && s.call(void 0, R, N, r);
+    },
+    [o, r, s, S]
+  ), U = a.useCallback(
+    (R, D, N) => {
+      const A = { ...x, filters: [...x.filters] }, ee = A.filters.indexOf(N);
+      A.filters.splice(ee, 1, D), g(A);
+    },
+    [x]
+  ), ce = a.useCallback(
+    (R) => {
+      R.preventDefault();
+      const D = (n || []).slice(), N = y(), A = N ? D.indexOf(N) : -1;
+      A >= 0 ? D.splice(A, 1, x) : D.push(x), S(), i && i.call(void 0, R, D, r);
+    },
+    [n, x, r, i, S, y]
+  ), ue = a.useCallback(
+    (R) => {
+      const D = (n || []).slice(), N = y(), A = N ? D.indexOf(N) : -1;
+      A >= 0 && D.splice(A, 1), l && g(l(r)), S(), i && i.call(void 0, R, D, r);
+    },
+    [n, r, i, l, S, y]
+  ), ze = a.useCallback((R) => O(R, "asc"), [O]), pe = a.useCallback((R) => O(R, "desc"), [O]), Ge = a.useCallback(
+    (R) => x && g({ ...x, logic: R.value.logic }),
+    [x]
+  ), j = o.find((R) => R.field === r) || { dir: "" }, [
+    Z,
+    J,
+    Q
+  ] = p, _e = Y(), en = c || u ? /* @__PURE__ */ a.createElement("div", { className: "k-columnmenu-item-wrapper", key: "sorting" }, c && /* @__PURE__ */ a.createElement(
+    He,
+    {
+      title: _e.toLanguageString(ot, v[ot]),
+      iconClass: "k-i-sort-asc-small",
+      svgIcon: Ut,
+      selected: j.dir === "asc",
+      onClick: ze
+    }
+  ), u && /* @__PURE__ */ a.createElement(
+    He,
+    {
+      title: _e.toLanguageString(st, v[st]),
+      iconClass: "k-i-sort-desc-small",
+      svgIcon: jt,
+      selected: j.dir === "desc",
+      onClick: pe
+    }
+  )) : null, tn = x && p.length > 0 ? /* @__PURE__ */ a.createElement("div", { className: "k-columnmenu-item-wrapper", key: "filtering" }, /* @__PURE__ */ a.createElement(
+    He,
+    {
+      iconClass: "k-i-filter",
+      svgIcon: Xt,
+      title: _e.toLanguageString(nt, v[nt]),
+      onClick: L
+    }
+  ), /* @__PURE__ */ a.createElement(
+    So,
+    {
+      show: C,
+      onSubmit: ce,
+      onReset: ue
+    },
+    Z && /* @__PURE__ */ a.createElement(Z, { filter: x.filters[0], onFilterChange: U }),
+    J && /* @__PURE__ */ a.createElement(J, { value: x.logic, onChange: Ge }),
+    Q && /* @__PURE__ */ a.createElement(Q, { filter: x.filters[1], onFilterChange: U })
+  )) : null, Rt = [en, tn], rn = /* @__PURE__ */ a.createElement(
+    "span",
+    {
+      ref: I,
+      onClick: z,
+      onMouseDown: T,
+      className: "k-grid-header-menu k-grid-column-menu" + (y() ? " k-active" : ""),
+      key: "button"
+    },
+    /* @__PURE__ */ a.createElement(Re, { name: "more-vertical", icon: bn })
+  ), nn = /* @__PURE__ */ a.createElement(
+    kn,
+    {
+      anchor: I.current,
+      show: m,
+      key: "popup"
+    },
+    /* @__PURE__ */ a.createElement(
+      "div",
+      {
+        className: "k-grid-columnmenu-popup",
+        ref: F,
+        tabIndex: 0,
+        onBlur: w,
+        onFocus: P,
+        style: { outline: "none" }
+      },
+      e.itemsRender ? e.itemsRender.call(void 0, Rt, { closeMenu: S, field: r }) : Rt
+    )
+  ), Mt = [rn, nn];
+  return /* @__PURE__ */ a.createElement(a.Fragment, null, e.render ? e.render.call(void 0, Mt) : Mt);
+}, Es = (e) => {
+  const { field: t, ...r } = e, n = a.useCallback(
+    (i) => ({ logic: "and", filters: [{ operator: "contains", field: i, value: "" }, { operator: "contains", field: i, value: "" }] }),
+    []
+  ), o = !!e.field, s = o ? [
+    Kt,
+    St,
+    Kt
+  ] : [];
+  return /* @__PURE__ */ a.createElement(
+    qe,
+    {
+      sortAsc: o,
+      sortDesc: o,
+      filterContent: s,
+      initialFilter: o ? n : void 0,
+      field: t,
+      ...r
+    }
+  );
+}, Cs = (e) => {
+  const { field: t, ...r } = e, n = a.useCallback(
+    (i) => ({ logic: "or", filters: [{ operator: "eq", field: i, value: null }, { operator: "eq", field: i, value: null }] }),
+    []
+  ), o = !!e.field, s = o ? [
+    qt,
+    St,
+    qt
+  ] : [];
+  return /* @__PURE__ */ a.createElement(
+    qe,
+    {
+      sortAsc: o,
+      sortDesc: o,
+      filterContent: s,
+      initialFilter: o ? n : void 0,
+      field: t,
+      ...r
+    }
+  );
+}, xs = (e) => {
+  const { field: t, ...r } = e, n = a.useCallback(
+    (i) => ({ logic: "or", filters: [{ operator: "eq", field: i, value: null }, { operator: "eq", field: i, value: null }] }),
+    []
+  ), o = !!e.field, s = o ? [
+    zt,
+    St,
+    zt
+  ] : [];
+  return /* @__PURE__ */ a.createElement(
+    qe,
+    {
+      sortAsc: o,
+      sortDesc: o,
+      filterContent: s,
+      initialFilter: o ? n : void 0,
+      field: t,
+      ...r
+    }
+  );
+}, bs = (e) => {
+  const { field: t, ...r } = e, n = a.useCallback(
+    (i) => ({ logic: "and", filters: [{ operator: "eq", field: i, value: !1 }] }),
+    []
+  ), o = !!e.field, s = o ? [
+    yo
+  ] : [];
+  return /* @__PURE__ */ a.createElement(
+    qe,
+    {
+      sortAsc: o,
+      sortDesc: o,
+      filterContent: s,
+      initialFilter: o ? n : void 0,
+      field: t,
+      ...r
+    }
+  );
+};
+function ne(e, t, r) {
+  return r ? { ...e, [t]: r.length ? [...r] : void 0 } : e && e[t] ? [...e[t]] : [];
+}
+function Zr(e, t, r) {
+  if (e[r]) {
+    let n = ne(e, r, er(ne(e, r), t)), o = ne(n, r).map((s) => Zr(s, t, r));
+    return { ...n, [r]: o };
+  }
+  return e;
+}
+function ys(e, t, r) {
+  let n = er(e, t);
+  return n = n.map((o) => Zr(o, t, r)), n;
+}
+function Jr(e, t, r) {
+  let n = ne(e, r);
+  if (n && n.length) {
+    n = n.map((l) => Jr(l, t, r));
+    const i = In(n, {
+      filters: [
+        { filters: t, logic: "and" },
+        { operator: (l) => !!(l[r] || []).length }
+      ],
+      logic: "or"
+    });
+    return ne(e, r, i);
+  }
+  return e;
+}
+function Is(e, t, r) {
+  let n = { [r]: [...e] };
+  return n = Jr(n, t, r), n[r] || [];
+}
+function ks(e, t, r) {
+  let n = [];
+  const o = [];
+  for (let s = e.length - 1; s >= 0; s--) {
+    const i = e[s];
+    n.push({
+      root: i,
+      data: t(i),
+      level: [s],
+      levelCount: e.length
+    });
+  }
+  for (; n.length > 0; ) {
+    let s = n.pop();
+    if (o.push({
+      dataItem: s.root,
+      level: [...s.level],
+      ...r(s.root),
+      levelCount: s.levelCount
+    }), s.data.length)
+      for (let i = s.data.length - 1; i >= 0; i--) {
+        const l = s.data[i];
+        n.push({
+          root: l,
+          data: t(l),
+          level: [...s.level, i],
+          levelCount: s.data.length
+        });
+      }
+  }
+  return o;
+}
+const Ss = (e, t, r) => {
+  const n = (c) => !!$e(t, c), o = (c) => !!$e(r, c), s = (c) => {
+    const u = [];
+    return n(c) && o(c) && u.push(...$e(r, c)), u;
+  }, i = (c, u, p) => {
+    u.push({ ...c, level: p }), s(c).forEach((f) => i(f, u, p + 1));
+  }, l = [];
+  return e.forEach((c) => i(c, l, 0)), l;
+}, Fs = (e, t, r, n) => {
+  let o = {}, s = [], i;
+  return e.forEach((l) => o[t(l)] = { ...l }), e.forEach((l) => {
+    i = o[r(l)], i ? (i[n] = i[n] || [], i[n].push(o[t(l)])) : s.push(o[t(l)]);
+  }), s;
+}, Rs = (e, t, r) => gt(e, t, r), Ms = (e, t, r) => [...ae(
+  [{ [t]: [...e] }],
+  t,
+  (o) => Fo(o, r, t)
+)[0][t]], Fo = (e, t, r) => {
+  const n = e[r] || [], o = n.findIndex(t);
+  if (o !== -1) {
+    const s = [...n];
+    return s.splice(o, 1), {
+      ...e,
+      [r]: s
+    };
+  }
+  return e;
+}, Ls = (e, t, r, n) => ae(
+  e,
+  t,
+  (o) => r(o) ? { ...o, [t]: n(o[t] || []) } : o
+), Gt = (e, t, r) => an(e, t, r), Ds = (e, t, r, n) => {
+  const o = [...e], s = Gt(o, t, n), i = s.pop(), l = s.pop(), c = t[t.length - 1];
+  if (r) {
+    const p = Gt(o, r, n).pop();
+    (l ? l[n] : o).splice(c, 1), p[n] = p[n] || [], p[n].push(i);
+  } else
+    (l ? l[n] : o).splice(c, 1), o.push(i);
+  return o;
+}, se = "groupId", pt = "items", Qr = (e, t, r) => {
+  e.items && (e[se] = `${r}${r && "_"}${e.value}${e.field}`, t > 1 && e.items.forEach((n) => Qr(n, t - 1, e[se])));
+}, ws = (e) => {
+  const { group: t } = e;
+  if (t && t.length && e.data)
+    return e.data.forEach((r) => Qr(r, t.length, ""));
+}, Os = (e) => {
+  const t = [];
+  return ae(e.data, pt, (r) => {
+    r[se] && t.push(r[se]);
+  }), t;
+}, Ns = (e) => ae(
+  e.data,
+  pt,
+  (t) => gt(t, pt, {
+    expanded: !e.collapsedIds.some((r) => r === t[se])
+  })
+), Ro = (e) => {
+  const { navigatable: t, contextStateRef: r, navigationStateRef: n, idPrefix: o } = e;
+  t && (r.current = {
+    activeId: "",
+    level: 0
+  }, n.current = {
+    activeElementIsFocused: !1,
+    prevNavigationIndexes: void 0,
+    idPrefix: o || ln(),
+    navigationMatrix: [],
+    lastHeaderIndex: -1
+  });
+}, Mo = (e) => {
+  const { scope: t, contextStateRef: r, navigationStateRef: n } = e;
+  if (r.current && n.current && t) {
+    Ft(e);
+    const o = n.current.navigationMatrix[0][0], s = M.getActiveElement(t, o);
+    o && s && (r.current.activeId = o, s.setAttribute("tabIndex", "0"));
+  }
+}, Lo = (e) => {
+  const { contextStateRef: t, navigationStateRef: r, document: n } = e;
+  if (t.current && r.current && n) {
+    const o = cn(n), s = M.getNavigatableId(o);
+    s && s === t.current.activeId && (r.current.activeElementIsFocused = !0);
+  }
+}, Do = (e) => {
+  const { scope: t, contextStateRef: r, navigationStateRef: n } = e;
+  if (Ft(e), r.current && n.current && t) {
+    if (!M.getActiveElement(t, r.current.activeId)) {
+      const s = n.current.navigationMatrix[0][0], i = M.getActiveElement(t, s);
+      s && i && (r.current.activeId = s, i.setAttribute("tabIndex", "0"), n.current.activeElementIsFocused && i.focus());
+    }
+    n.current.activeElementIsFocused = !1;
+  }
+}, wo = (e, t) => {
+  const { contextStateRef: r } = t;
+  if (e.isDefaultPrevented() || !r.current)
+    return;
+  const n = e.target, o = M.getNavigatableId(n);
+  if (o && o !== r.current.activeId) {
+    const s = M.getClosestScope(n);
+    if (!s)
+      return;
+    const i = M.getActiveElement(s, r.current.activeId);
+    i && i.setAttribute("tabIndex", "-1"), n.setAttribute("tabIndex", "0"), r.current.activeId = o;
+  }
+}, Oo = (e, t) => {
+  const {
+    contextStateRef: r,
+    navigationStateRef: n,
+    onNavigationAction: o
+  } = t;
+  if (e.isDefaultPrevented() || !r.current || !n.current)
+    return;
+  if (e.keyCode === B.esc) {
+    const p = M.getClosestNavigatableElement(e.target);
+    M.focusElement({ elementForFocus: p, event: e, contextStateRef: r });
+    return;
+  }
+  const s = e.target, i = M.getNavigatableId(s), l = M.getNavigatableLevel(s), c = M.getClosestScope(s), u = n.current.navigationMatrix;
+  if (l !== void 0 && c) {
+    if (e.keyCode === B.enter) {
+      const p = M.getNavigatableElement(s, { level: l + 1 });
+      if (p) {
+        M.focusElement({
+          elementForFocus: p,
+          event: e,
+          contextStateRef: r,
+          prevElement: s
+        });
+        return;
+      } else {
+        const f = M.getFocusableElements(s)[0];
+        M.focusElement({ elementForFocus: f, event: e, contextStateRef: r, prevElement: s });
+        return;
+      }
+    }
+    if (e.keyCode === B.up || e.keyCode === B.down || e.keyCode === B.left || e.keyCode === B.right) {
+      const p = e.keyCode === B.up || e.keyCode === B.left, f = e.keyCode === B.up || e.keyCode === B.down;
+      let m;
+      if (n.current && n.current.prevNavigationIndexes) {
+        const [h, C] = n.current.prevNavigationIndexes;
+        u[h][C] === i ? m = n.current.prevNavigationIndexes : m = ct(u, i);
+      } else
+        m = ct(u, i);
+      if (m) {
+        const [h, C] = m, [b, x] = f ? Wr(h, C, i, u, p) : Hr(h, C, i, u, p);
+        if (b) {
+          const g = M.getActiveElement(c, b);
+          M.focusElement({ elementForFocus: g, event: e, contextStateRef: r, prevElement: s }), n.current.prevNavigationIndexes = x, o && o({ focusElement: g, event: e });
+        }
+      }
+    }
+  }
+}, Ft = (e) => {
+  const { navigationStateRef: t, scope: r } = e;
+  if (!t.current || !r)
+    return;
+  const n = [], o = _r(r), s = $r(r);
+  if (!o || !s)
+    return;
+  const i = Array.from(o.children), l = Array.from(s.children);
+  [...i, ...l].forEach((c, u) => {
+    Array.from(c.children).forEach((p) => {
+      const f = Ct(p);
+      if (!f)
+        return;
+      const m = p.rowSpan || 1, h = p.colSpan || 1;
+      let C;
+      for (let b = u, x = u + m; b < x; b++) {
+        if (n[b] || (n[b] = []), C === void 0) {
+          const g = n[b].findIndex((I) => !I);
+          C = g > -1 ? g : n[b].length;
+        }
+        n[b][C] = f || "";
+      }
+      for (let b = C + 1, x = C + h; b < x; b++)
+        n[u][b] = f || "";
+    });
+  }), t.current.navigationMatrix = n.filter((c) => !!c), t.current.lastHeaderIndex = i.length - 1;
+}, As = {
+  onConstructor: Ro,
+  onComponentDidMount: Mo,
+  onGetSnapshotBeforeUpdate: Lo,
+  onComponentDidUpdate: Do,
+  onFocus: wo,
+  onKeyDown: Oo,
+  generateMatrix: Ft
+}, No = "data-grid-row-index", Ao = "data-grid-col-index", Po = "data-prevent-selection", To = "items", H = {}, Bo = (e, t) => !e || Array.isArray(e) && e.length === 0 ? [t] : e.findIndex((n) => n === t) > -1 ? e.filter((n) => n !== t) : [...e, t], W = (e, t) => {
+  let r = e;
+  for (; r; ) {
+    if (r.tagName === t)
+      return r;
+    if (r.tagName === "TABLE")
+      return null;
+    r = r.parentElement;
+  }
+  return null;
+}, Se = (e) => {
+  if (!e)
+    return;
+  const t = e.getAttribute(No);
+  return t ? parseInt(t, 10) : void 0;
+}, Fe = (e) => {
+  if (!e)
+    return;
+  const t = e.getAttribute(Ao);
+  return t ? parseInt(t, 10) : void 0;
+}, Ps = (e) => {
+  const t = e.subItemsField || To, r = Wt(e.dataItemKey);
+  return ae(
+    e.data,
+    t,
+    (n) => gt(n, t, {
+      [e.selectedField]: e.selectedState[r(n)]
+    })
+  );
+}, Ts = (e) => {
+  const { event: t, dataItemKey: r, selectedState: n } = e, { syntheticEvent: o, nativeEvent: s, dataItems: i, componentId: l, mode: c, cell: u, selectedField: p } = t, { target: f, ctrlKey: m, metaKey: h, altKey: C, shiftKey: b } = s;
+  if (o.isDefaultPrevented() || s.keyCode !== B.enter)
+    return n;
+  const x = W(f, "TD"), g = W(f, "TR"), I = Fe(x), F = Se(g);
+  let k = {};
+  return x && g && F !== void 0 && I !== void 0 && (k = Ko({
+    selectedState: n,
+    dataItemKey: r,
+    event: {
+      ctrlKey: m,
+      metaKey: h,
+      altKey: C,
+      shiftKey: b,
+      dataItems: i,
+      cell: u,
+      mode: c,
+      selectedField: p,
+      componentId: l,
+      startColIndex: I,
+      endColIndex: I,
+      startRowIndex: F,
+      endRowIndex: F,
+      isDrag: !1,
+      syntheticEvent: o,
+      nativeEvent: s,
+      target: t.target,
+      dataItem: null
+    }
+  })), k;
+}, Ko = (e) => {
+  const { event: t, dataItemKey: r, selectedState: n } = e, {
+    dataItems: o,
+    startRowIndex: s,
+    endRowIndex: i,
+    startColIndex: l,
+    endColIndex: c,
+    cell: u,
+    isDrag: p,
+    ctrlKey: f,
+    shiftKey: m,
+    metaKey: h,
+    componentId: C,
+    mode: b,
+    dataItem: x
+  } = t, g = Wt(r);
+  let I = {};
+  const F = x !== null;
+  if (b === "single") {
+    const k = o.slice(s, s + 1)[0], E = g(k);
+    H[C] = {
+      rowIndex: s,
+      colIndex: l
+    }, I[E] = u ? [l] : !0;
+  } else if (p || !m && !f && !h && !F) {
+    p || (H[C] = {
+      rowIndex: s,
+      colIndex: l
+    });
+    const k = [];
+    for (let y = l; y <= c; y++)
+      k.push(y);
+    o.slice(s, i + 1).forEach((y) => {
+      const S = g(y);
+      I[S] = u ? [...k] : !0;
+    });
+  } else if (f || h || F) {
+    H[C] = {
+      rowIndex: s,
+      colIndex: l
+    };
+    const E = o.slice(s, i + 1)[0], y = g(E);
+    I = { ...n }, I[y] = u && !F ? Bo(I[y], l) : !I[y];
+  } else if (m) {
+    const k = H[C] && H[C].rowIndex || 0, E = H[C] && H[C].colIndex || 0, y = Math.min(k, s, i), S = Math.max(k, s, i), w = Math.min(E, l, c), P = Math.max(E, l, c), T = [];
+    for (let L = w; L <= P; L++)
+      T.push(L);
+    o.slice(y, S + 1).forEach((L) => {
+      const O = g(L);
+      I[O] = u ? [...T] : !0;
+    });
+  }
+  return I;
+}, qo = un(), zo = (e) => {
+  if (!e || !qo)
+    return null;
+  let t = e.parentElement;
+  for (; t; ) {
+    if (window.getComputedStyle(t).transform !== "none")
+      return t;
+    t = t.parentElement;
+  }
+}, Go = (e) => {
+  if (e && e.ownerDocument && e !== e.ownerDocument.body) {
+    const t = e.getBoundingClientRect();
+    return {
+      left: t.left - e.scrollLeft,
+      top: t.top - e.scrollTop
+    };
+  }
+  return { left: 0, top: 0 };
+}, _o = (e) => {
+  const t = e ? typeof e.enabled == "boolean" ? e.enabled : !0 : !1, r = e ? !!e.drag : !1, n = e && e.mode ? e.mode : "multiple", o = !!(e && e.cell);
+  return { enabled: t, drag: r, mode: n, cell: o };
+}, Bs = (e) => {
+  var F;
+  const { onRelease: t, childRef: r } = e, {
+    enabled: n,
+    drag: o,
+    mode: s,
+    cell: i
+  } = _o(e.selectable), l = a.useRef(null), c = a.useRef(null), u = a.useRef({ clientX: 0, clientY: 0 }), [p, f] = a.useState(null), m = a.useRef(), h = a.useRef(!1), C = a.useRef(!1), b = a.useCallback(
+    (k) => {
+      const { event: E } = k;
+      C.current = E.originalEvent.target.hasAttribute(Po), !(C.current || !l.current) && (m.current = zo(l.current.element), u.current = {
+        clientY: E.clientY,
+        clientX: E.clientX
+      });
+    },
+    []
+  ), x = a.useCallback(
+    (k) => {
+      const { event: E } = k, { clientX: y, clientY: S } = u.current;
+      if (!C.current && !(!o || s === "single") && ((Math.abs(S - E.clientY) > 5 || Math.abs(y - E.clientX) > 5) && (h.current = !0), h.current)) {
+        const w = Go(m.current);
+        f({
+          top: Math.min(S, E.clientY) - w.top,
+          left: Math.min(y, E.clientX) - w.left,
+          width: Math.abs(E.clientX - y),
+          height: Math.abs(E.clientY - S)
+        });
+      }
+    },
+    [f, o, s]
+  ), g = a.useCallback(
+    (k) => {
+      const { event: E } = k, { clientX: y, clientY: S } = u.current;
+      if (C.current || !l.current)
+        return;
+      const w = l.current.element && l.current.element.ownerDocument;
+      if (w) {
+        if (h.current) {
+          const P = Math.min(S, E.clientY), T = Math.min(y, E.clientX), z = Math.max(S, E.clientY), L = Math.max(y, E.clientX), O = c.current;
+          if (!O)
+            return;
+          O.style.visibility = "hidden";
+          const U = w.elementFromPoint(T, P), ce = w.elementFromPoint(L, z);
+          if (O.style.visibility = "", !U || !ce)
+            return;
+          const ue = W(U, "TD"), ze = W(ue, "TR"), pe = W(ce, "TD"), Ge = W(pe, "TR"), j = Fe(ue), Z = Se(ze), J = Fe(pe), Q = Se(Ge);
+          j !== void 0 && Z !== void 0 && J !== void 0 && Q !== void 0 && t({
+            nativeEvent: E.originalEvent,
+            startRowIndex: Z,
+            startColIndex: j,
+            endRowIndex: Q,
+            endColIndex: J,
+            altKey: E.altKey,
+            shiftKey: E.shiftKey,
+            ctrlKey: E.ctrlKey,
+            metaKey: E.metaKey,
+            mode: s,
+            cell: i,
+            isDrag: !0
+          });
+        } else {
+          const P = w.elementFromPoint(y, S);
+          if (!P)
+            return;
+          const T = W(P, "TD"), z = W(P, "TR"), L = Fe(T), O = Se(z);
+          T && z && O !== void 0 && L !== void 0 && t({
+            nativeEvent: E.originalEvent,
+            startRowIndex: O,
+            startColIndex: L,
+            endRowIndex: O,
+            endColIndex: L,
+            altKey: E.altKey,
+            shiftKey: E.shiftKey,
+            ctrlKey: E.ctrlKey,
+            metaKey: E.metaKey,
+            mode: s,
+            cell: i,
+            isDrag: !1
+          });
+        }
+        f(null), h.current = !1, u.current = { clientX: 0, clientY: 0 };
+      }
+    },
+    [f, s, i, t]
+  ), I = pn(c);
+  return n ? /* @__PURE__ */ a.createElement(a.Fragment, null, /* @__PURE__ */ a.createElement(
+    ht,
+    {
+      onPress: b,
+      onDrag: x,
+      onRelease: g,
+      ref: l,
+      childRef: r
+    },
+    e.children
+  ), p && yn.createPortal(
+    /* @__PURE__ */ a.createElement(
+      "div",
+      {
+        ref: c,
+        style: { ...p, position: "fixed" },
+        className: "k-marquee k-marquee-color"
+      }
+    ),
+    (F = I()) == null ? void 0 : F.body
+  )) : a.cloneElement(a.Children.only(e.children), { ref: r });
+};
+export {
+  po as BooleanFilter,
+  ts as BooleanFilterCell,
+  An as ColumnDefaultProps,
+  bs as ColumnMenuBooleanColumn,
+  yo as ColumnMenuBooleanFilter,
+  xs as ColumnMenuDateColumn,
+  zt as ColumnMenuDateFilter,
+  So as ColumnMenuFilterForm,
+  St as ColumnMenuFilterLogic,
+  ko as ColumnMenuForm,
+  He as ColumnMenuItem,
+  Cs as ColumnMenuNumericColumn,
+  qt as ColumnMenuNumericFilter,
+  Ke as ColumnMenuOperators,
+  Es as ColumnMenuTextColumn,
+  Kt as ColumnMenuTextFilter,
+  hs as ColumnResize,
+  so as ColumnResizer,
+  gs as CommonDragLogic,
+  uo as DateFilter,
+  rs as DateFilterCell,
+  fs as DragClue,
+  ms as DropClue,
+  bt as EnumFilter,
+  yt as Expression,
+  jn as FILTER_ROW_CLASS,
+  vt as FOCUSABLE_ELEMENTS,
+  vo as Filter,
+  ls as FilterRow,
+  It as Group,
+  us as Header,
+  no as HeaderCell,
+  co as HeaderRow,
+  ps as HeaderSelectionCell,
+  Et as HeaderThElement,
+  Kr as KEYBOARD_NAV_DATA_BODY,
+  Br as KEYBOARD_NAV_DATA_HEADER,
+  Be as KEYBOARD_NAV_DATA_ID,
+  X as KEYBOARD_NAV_DATA_LEVEL,
+  Tr as KEYBOARD_NAV_DATA_SCOPE,
+  ss as KEYBOARD_NAV_DATA_ZONE,
+  Pn as KEYBOARD_NAV_FILTER_COL_SUFFIX,
+  Xr as NumericFilter,
+  ns as NumericFilterCell,
+  vs as Operators,
+  Pe as Pager,
+  Tn as TABBABLE_ELEMENTS,
+  Ao as TABLE_COL_INDEX_ATTRIBUTE,
+  Po as TABLE_PREVENT_SELECTION_ELEMENT,
+  No as TABLE_ROW_INDEX_ATTRIBUTE,
+  zr as TableKeyboardNavigationContext,
+  Bs as TableSelection,
+  Yr as TextFilter,
+  os as TextFilterCell,
+  W as closestTagName,
+  Fs as createDataTree,
+  Te as createFilterComponent,
+  Rs as extendDataItem,
+  Is as filterBy,
+  ks as flatData,
+  Fe as getColumnIndex,
+  Os as getGroupIds,
+  Tt as getIndex,
+  Gt as getItemPath,
+  Go as getOffset,
+  Se as getRowIndex,
+  Ko as getSelectedState,
+  Ts as getSelectedStateFromKeyDown,
+  _o as getSelectionOptions,
+  ro as isRtl,
+  cs as mapColumns,
+  Ls as modifySubItems,
+  Ds as moveTreeItem,
+  Jn as nextColumn,
+  oo as normalize,
+  ys as orderBy,
+  to as readColumns,
+  zo as relativeContextElement,
+  Ms as removeItems,
+  Ns as setExpandedState,
+  ws as setGroupIds,
+  Ps as setSelectedState,
+  Ur as stringOperator,
+  ds as tableColumnsVirtualization,
+  As as tableKeyboardNavigation,
+  is as tableKeyboardNavigationBodyAttributes,
+  Bn as tableKeyboardNavigationHeaderAttributes,
+  as as tableKeyboardNavigationScopeAttributes,
+  M as tableKeyboardNavigationTools,
+  Ss as treeToFlat,
+  ut as unaryOperator,
+  Qn as updateLeft,
+  eo as updateRight,
+  Kn as useTableKeyboardNavigation
+};