@dlh.io/bideux 0.1.0

package/dist/element/revo-grid.entry-7FHEBN3O.js

@@ -0,0 +1,4817 @@
+import { getPropertyFromEvent, calculateRowHeaderSize, ViewportStore } from './chunk-H5IFOSQP.js';
+import { timeout, getScrollbarSize } from './chunk-LXR3CLCN.js';
+import { ON_COLUMN_CLICK, dispatch } from './chunk-B67SYRQP.js';
+import { FILTER_PROP, isFilterBtn } from './chunk-WDTTBY3S.js';
+import { getColumnByProp, getColumns, rowTypes, HEADER_SLOT, DATA_SLOT, GROUPING_ROW_TYPE, isGrouping, getSource, getExpanded, PSEUDO_GROUP_COLUMN, columnTypes, gatherGrouping, GROUP_EXPAND_EVENT, isGroupingColumn, getColumnType, reduce, getCellDataParsed, isColGrouping, getColumnSizes, getScrollDimension, cropCellToMax, nextCell, isRowType, viewportDataPartition, FOOTER_SLOT, CONTENT_SLOT, getParsedGroup, PSEUDO_GROUP_ITEM_ID, GROUP_EXPANDED, isSameGroup, GROUP_DEPTH, PSEUDO_GROUP_ITEM_VALUE, baseEach, getGroupingName, GROUP_COLUMN_PROP, getRange, toInteger, getCellRaw } from './chunk-TXSK3CIN.js';
+import { getVisibleSourceItem, getPhysical, setItems, getSourceItem, getItemByPosition, RESIZE_INTERVAL, gatherTrimmedItems, getItemByIndex, DataStore, getSourceItemVirtualIndexByProp, setSourceByPhysicalIndex, setSourceByVirtualIndex, isArray, createStore, setStore, calculateDimensionData, identity } from './chunk-AOKCBPMV.js';
+import { debounce } from './chunk-TFV4CJR4.js';
+import { registerInstance, createEvent, h, Host, getElement } from './chunk-G3C722QP.js';
+
+// ../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/column.drag.plugin-DKgC_0I1.js
+var themeTokenCssVariables = {
+  primary: "--revo-grid-primary",
+  primaryTransparent: "--revo-grid-primary-transparent",
+  background: "--revo-grid-background",
+  foreground: "--revo-grid-foreground",
+  divider: "--revo-grid-divider",
+  shadow: "--revo-grid-shadow",
+  text: "--revo-grid-text",
+  border: "--revo-grid-border",
+  headerBg: "--revo-grid-header-bg",
+  headerColor: "--revo-grid-header-color",
+  headerBorder: "--revo-grid-header-border",
+  headerFocusedBg: "--revo-grid-header-focused-bg",
+  headerHoverBg: "--revo-grid-header-hover-bg",
+  cellBorder: "--revo-grid-cell-border",
+  cellVerticalBorder: "--revo-grid-cell-vertical-border",
+  focusedBg: "--revo-grid-focused-bg",
+  rowHover: "--revo-grid-row-hover",
+  rowHeadersBg: "--revo-grid-row-headers-bg",
+  rowHeadersColor: "--revo-grid-row-headers-color",
+  cellDisabledBg: "--revo-grid-cell-disabled-bg",
+  filterPanelBg: "--revo-grid-filter-panel-bg",
+  filterPanelBorder: "--revo-grid-filter-panel-border",
+  filterPanelShadow: "--revo-grid-filter-panel-shadow",
+  filterPanelInputBg: "--revo-grid-filter-panel-input-bg",
+  filterPanelDivider: "--revo-grid-filter-panel-divider",
+  filterPanelSelectBorder: "--revo-grid-filter-panel-select-border",
+  filterPanelSelectBorderHover: "--revo-grid-filter-panel-select-border-hover",
+  filterPanelReorderAccent: "--revo-grid-filter-panel-reorder-accent",
+  filterPanelReorderColor: "--revo-grid-filter-panel-reorder-color",
+  filterPanelText: "--revo-grid-filter-panel-text",
+  filterPanelMutedText: "--revo-grid-filter-panel-muted-text",
+  filterPanelFocusRing: "--revo-grid-filter-panel-focus-ring",
+  filterPanelIcon: "--revo-grid-filter-panel-icon",
+  filterPanelIconActive: "--revo-grid-filter-panel-icon-active",
+  filterPanelSelectArrow: "--revo-grid-filter-panel-select-arrow",
+  filterPanelSelectArrowDisabled: "--revo-grid-filter-panel-select-arrow-disabled",
+  fontFamily: "--revo-grid-font-family",
+  fontSize: "--revo-grid-font-size",
+  headerHeight: "--revo-grid-header-height",
+  headerFontSize: "--revo-grid-header-font-size",
+  headerFontWeight: "--revo-grid-header-font-weight",
+  headerTextTransform: "--revo-grid-header-text-transform",
+  headerTextAlign: "--revo-grid-header-text-align",
+  cellTextAlign: "--revo-grid-cell-text-align",
+  headerPadding: "--revo-grid-header-padding",
+  cellPadding: "--revo-grid-cell-padding",
+  selectionBorder: "--revo-grid-selection-border",
+  selectionBg: "--revo-grid-selection-bg",
+  autofillHandleBg: "--revo-grid-autofill-handle-bg",
+  autofillHandleBorder: "--revo-grid-autofill-handle-border",
+  rangeHandleBg: "--revo-grid-range-handle-bg",
+  temporaryRangeBorder: "--revo-grid-temporary-range-border",
+  temporarySelectionBorder: "--revo-grid-temporary-selection-border",
+  headerResizeHover: "--revo-grid-header-resize-hover",
+  buttonText: "--revo-grid-button-text",
+  buttonBg: "--revo-grid-button-bg",
+  buttonSuccessBg: "--revo-grid-button-success-bg",
+  buttonDangerBg: "--revo-grid-button-danger-bg",
+  buttonOutlineBorder: "--revo-grid-button-outline-border",
+  buttonOutlineText: "--revo-grid-button-outline-text"
+};
+function calculateRealSize({ count, originItemSize, sizes }) {
+  const safeCount = Math.max(0, count);
+  let realSize = safeCount * originItemSize;
+  for (let index in sizes) {
+    const itemIndex = Number(index);
+    if (!Number.isInteger(itemIndex) || itemIndex < 0 || itemIndex >= safeCount || String(itemIndex) !== index) {
+      continue;
+    }
+    realSize += sizes[index] - originItemSize;
+  }
+  return realSize;
+}
+var recalculateRealSizePlugin = (storeService) => {
+  return {
+    /**
+     * Reacts on changes of count, sizes and originItemSize
+     */
+    set(k) {
+      switch (k) {
+        case "count":
+        case "sizes":
+        case "originItemSize": {
+          storeService.setStore({
+            realSize: calculateRealSize({
+              count: storeService.store.get("count"),
+              sizes: storeService.store.get("sizes"),
+              originItemSize: storeService.store.get("originItemSize")
+            })
+          });
+          break;
+        }
+      }
+    }
+  };
+};
+var trimmedPlugin = (storeService) => {
+  let trimmingObject = null;
+  let trimmedPreviousSizes = null;
+  return {
+    set(key, val) {
+      switch (key) {
+        case "sizes": {
+          if (trimmingObject && trimmingObject === val) {
+            trimmingObject = null;
+            return;
+          }
+          trimmedPreviousSizes = null;
+          break;
+        }
+        case "trimmed": {
+          const trim = val;
+          if (!trimmedPreviousSizes) {
+            trimmedPreviousSizes = storeService.store.get("sizes");
+          }
+          trimmingObject = removeMultipleAndShift(trimmedPreviousSizes, trim || {});
+          storeService.setSizes(trimmingObject);
+          break;
+        }
+      }
+    }
+  };
+};
+function removeMultipleAndShift(items, toRemove) {
+  const newItems = {};
+  const sortedIndexes = Object.keys(items || {}).map(Number).sort((a, b) => a - b);
+  const lastIndex = sortedIndexes[sortedIndexes.length - 1];
+  let shift = 0;
+  for (let i = 0; i <= lastIndex; i++) {
+    if (toRemove[i] !== void 0) {
+      shift++;
+      if (items[i] !== void 0) {
+        continue;
+      }
+    }
+    if (items[i] !== void 0) {
+      newItems[i - shift] = items[i];
+    }
+  }
+  return newItems;
+}
+function initialBase() {
+  return {
+    indexes: [],
+    count: 0,
+    // hidden items
+    trimmed: null,
+    // virtual item index to size
+    sizes: {},
+    // order in indexes[] to coordinate
+    positionIndexToItem: {},
+    // initial element to coordinate ^
+    indexToItem: {},
+    positionIndexes: []
+  };
+}
+function initialState() {
+  return Object.assign(Object.assign({}, initialBase()), {
+    // size which all items can take
+    realSize: 0,
+    // initial item size if it wasn't changed
+    originItemSize: 0,
+    // logical-to-physical render offset used when scroll space is compressed
+    renderOffset: 0
+  });
+}
+var DimensionStore = class {
+  constructor(type) {
+    this.type = type;
+    this.store = createStore(initialState());
+    this.store.use(trimmedPlugin({
+      store: this.store,
+      setSizes: this.setDimensionSize.bind(this)
+    }));
+    this.store.use(recalculateRealSizePlugin({
+      store: this.store,
+      setStore: this.setStore.bind(this)
+    }));
+  }
+  getCurrentState() {
+    const state = initialState();
+    const keys = Object.keys(state);
+    return reduce(keys, (r, k) => {
+      const data = this.store.get(k);
+      r[k] = data;
+      return r;
+    }, state);
+  }
+  dispose() {
+    setStore(this.store, initialState());
+  }
+  setStore(data) {
+    setStore(this.store, data);
+  }
+  drop() {
+    setStore(this.store, Object.assign(Object.assign({}, initialBase()), { renderOffset: 0 }));
+  }
+  /**
+   * Set custom dimension sizes and overwrite old
+   * Generates new indexes based on sizes
+   * @param sizes - sizes to set
+   */
+  setDimensionSize(sizes = {}) {
+    const dimensionData = calculateDimensionData(this.store.get("originItemSize"), sizes);
+    setStore(this.store, Object.assign(Object.assign({}, dimensionData), { sizes }));
+  }
+  updateSizesPositionByIndexes(newItemsOrder, prevItemsOrder = []) {
+    const customSizes = Object.assign({}, this.store.get("sizes"));
+    if (!Object.keys(customSizes).length) {
+      return;
+    }
+    const originalIndices = {};
+    prevItemsOrder.forEach((physIndex, virtIndex) => {
+      if (!originalIndices[physIndex]) {
+        originalIndices[physIndex] = [];
+      }
+      originalIndices[physIndex].push(virtIndex);
+    });
+    const newSizes = {};
+    newItemsOrder.forEach((physIndex, virtIndex) => {
+      const indices = originalIndices[physIndex];
+      if (indices && indices.length > 0) {
+        const originalIndex = indices.shift();
+        if (originalIndex !== void 0 && originalIndex !== virtIndex && typeof customSizes[originalIndex] === "number") {
+          newSizes[virtIndex] = customSizes[originalIndex];
+          delete customSizes[originalIndex];
+        }
+      }
+    });
+    if (Object.keys(newSizes).length) {
+      this.setDimensionSize(Object.assign(Object.assign({}, customSizes), newSizes));
+    }
+  }
+};
+function defaultState() {
+  return {
+    range: null,
+    tempRange: null,
+    tempRangeType: null,
+    focus: null,
+    edit: null,
+    lastCell: null,
+    nextFocus: null
+  };
+}
+var SelectionStore = class {
+  constructor() {
+    this.unsubscribe = [];
+    this.store = createStore(defaultState());
+    this.store.on("set", (key, newVal) => {
+      if (key === "tempRange" && !newVal) {
+        this.store.set("tempRangeType", null);
+      }
+    });
+  }
+  onChange(propName, cb) {
+    this.unsubscribe.push(this.store.onChange(propName, cb));
+  }
+  clearFocus() {
+    setStore(this.store, { focus: null, range: null, edit: null, tempRange: null });
+  }
+  setFocus(focus, end) {
+    if (!end) {
+      setStore(this.store, { focus });
+    } else {
+      setStore(this.store, {
+        focus,
+        range: getRange(focus, end),
+        edit: null,
+        tempRange: null
+      });
+    }
+  }
+  setNextFocus(focus) {
+    setStore(this.store, { nextFocus: focus });
+  }
+  setTempArea(range) {
+    setStore(this.store, { tempRange: range === null || range === void 0 ? void 0 : range.area, tempRangeType: range === null || range === void 0 ? void 0 : range.type, edit: null });
+  }
+  clearTemp() {
+    setStore(this.store, { tempRange: null });
+  }
+  /** Can be applied from selection change or from simple keyboard change clicks */
+  setRangeArea(range) {
+    setStore(this.store, { range, edit: null, tempRange: null });
+  }
+  setRange(start, end) {
+    const range = getRange(start, end);
+    this.setRangeArea(range);
+  }
+  setLastCell(lastCell) {
+    setStore(this.store, { lastCell });
+  }
+  setEdit(val) {
+    const focus = this.store.get("focus");
+    if (focus && typeof val === "string") {
+      setStore(this.store, {
+        edit: { x: focus.x, y: focus.y, val }
+      });
+      return;
+    }
+    setStore(this.store, { edit: null });
+  }
+  dispose() {
+    this.unsubscribe.forEach((f) => f());
+    this.store.dispose();
+  }
+};
+var BasePlugin = class {
+  constructor(revogrid, providers) {
+    this.revogrid = revogrid;
+    this.providers = providers;
+    this.h = h;
+    this.subscriptions = {};
+  }
+  /**
+   *
+   * @param eventName - event name to subscribe to in revo-grid component (e.g. 'beforeheaderclick')
+   * @param callback - callback function for event
+   */
+  addEventListener(eventName, callback) {
+    this.revogrid.addEventListener(eventName, callback);
+    this.subscriptions[eventName] = callback;
+  }
+  /**
+   * Subscribe to property change in revo-grid component
+   * You can return false in callback to prevent default value set
+   *
+   * @param prop - property name
+   * @param callback - callback function
+   * @param immediate - trigger callback immediately with current value
+   */
+  watch(prop, callback, { immediate } = { immediate: false }) {
+    var _a;
+    const nativeValueDesc = Object.getOwnPropertyDescriptor(this.revogrid, prop) || Object.getOwnPropertyDescriptor(this.revogrid.constructor.prototype, prop);
+    Object.defineProperty(this.revogrid, prop, {
+      configurable: true,
+      enumerable: (_a = nativeValueDesc === null || nativeValueDesc === void 0 ? void 0 : nativeValueDesc.enumerable) !== null && _a !== void 0 ? _a : true,
+      set(val) {
+        var _a2;
+        const keepDefault = callback(val);
+        if (keepDefault === false) {
+          return;
+        }
+        return (_a2 = nativeValueDesc === null || nativeValueDesc === void 0 ? void 0 : nativeValueDesc.set) === null || _a2 === void 0 ? void 0 : _a2.call(this, val);
+      },
+      get() {
+        var _a2;
+        return (_a2 = nativeValueDesc === null || nativeValueDesc === void 0 ? void 0 : nativeValueDesc.get) === null || _a2 === void 0 ? void 0 : _a2.call(this);
+      }
+    });
+    if (immediate) {
+      callback((nativeValueDesc === null || nativeValueDesc === void 0 ? void 0 : nativeValueDesc.get) ? nativeValueDesc.get.call(this.revogrid) : nativeValueDesc === null || nativeValueDesc === void 0 ? void 0 : nativeValueDesc.value);
+    }
+  }
+  /**
+   * Remove event listener
+   * @param eventName
+   */
+  removeEventListener(eventName) {
+    this.revogrid.removeEventListener(eventName, this.subscriptions[eventName]);
+    delete this.subscriptions[eventName];
+  }
+  /**
+   * Emit event from revo-grid component
+   * Event can be cancelled by calling event.preventDefault() in callback
+   */
+  emit(eventName, detail) {
+    const event = new CustomEvent(eventName, { detail, cancelable: true });
+    this.revogrid.dispatchEvent(event);
+    return event;
+  }
+  /**
+   * Clear all subscriptions
+   */
+  clearSubscriptions() {
+    for (let type in this.subscriptions) {
+      this.removeEventListener(type);
+    }
+  }
+  /**
+   * Destroy plugin and clear all subscriptions
+   */
+  destroy() {
+    this.clearSubscriptions();
+  }
+};
+function arrayEach(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+function castFunction(value) {
+  return typeof value == "function" ? value : identity;
+}
+function forEach(collection, iteratee) {
+  var func = isArray(collection) ? arrayEach : baseEach;
+  return func(collection, castFunction(iteratee));
+}
+var LETTER_BLOCK_SIZE = 7;
+var ColumnAutoSizeMode;
+(function(ColumnAutoSizeMode2) {
+  ColumnAutoSizeMode2["headerClickAutosize"] = "headerClickAutoSize";
+  ColumnAutoSizeMode2["autoSizeOnTextOverlap"] = "autoSizeOnTextOverlap";
+  ColumnAutoSizeMode2["autoSizeAll"] = "autoSizeAll";
+})(ColumnAutoSizeMode || (ColumnAutoSizeMode = {}));
+var AutoSizeColumnPlugin = class extends BasePlugin {
+  constructor(revogrid, providers, config) {
+    super(revogrid, providers);
+    this.providers = providers;
+    this.config = config;
+    this.autoSizeColumns = null;
+    this.dataResolve = null;
+    this.dataReject = null;
+    this.letterBlockSize = (config === null || config === void 0 ? void 0 : config.letterBlockSize) || LETTER_BLOCK_SIZE;
+    if (config === null || config === void 0 ? void 0 : config.preciseSize) {
+      this.precsizeCalculationArea = this.initiatePresizeElement();
+      revogrid.appendChild(this.precsizeCalculationArea);
+    }
+    const aftersourceset = ({ detail: { source } }) => {
+      this.setSource(source);
+    };
+    const beforecolumnsset = ({ detail: { columns } }) => {
+      this.columnSet(columns);
+    };
+    this.addEventListener("beforecolumnsset", beforecolumnsset);
+    switch (config === null || config === void 0 ? void 0 : config.mode) {
+      case ColumnAutoSizeMode.autoSizeOnTextOverlap:
+        this.addEventListener("aftersourceset", aftersourceset);
+        this.addEventListener("afteredit", ({ detail }) => {
+          this.afteredit(detail);
+        });
+        break;
+      case ColumnAutoSizeMode.autoSizeAll:
+        this.addEventListener("aftersourceset", aftersourceset);
+        this.addEventListener("afteredit", ({ detail }) => {
+          this.afterEditAll(detail);
+        });
+        break;
+      default:
+        this.addEventListener("headerdblclick", ({ detail }) => {
+          const type = getColumnType(detail.column);
+          const size = this.getColumnSize(detail.index, type);
+          if (size) {
+            this.providers.dimension.setCustomSizes(type, {
+              [detail.index]: size
+            }, true);
+          }
+        });
+        break;
+    }
+  }
+  async setSource(source) {
+    let autoSize = this.autoSizeColumns;
+    if (this.dataReject) {
+      this.dataReject();
+      this.clearPromise();
+    }
+    if (!autoSize) {
+      const request = new Promise((resolve, reject) => {
+        this.dataResolve = resolve;
+        this.dataReject = reject;
+      });
+      try {
+        autoSize = await request;
+      } catch (e) {
+        return;
+      }
+    }
+    forEach(autoSize, (_v, type) => {
+      const sizes = {};
+      forEach(autoSize[type], (rgCol) => {
+        rgCol.size = sizes[rgCol.index] = source.reduce((prev, rgRow) => Math.max(prev, this.getLength(rgRow[rgCol.prop])), this.getLength(rgCol.name || ""));
+      });
+      this.providers.dimension.setCustomSizes(type, sizes, true);
+    });
+  }
+  getLength(len) {
+    var _a;
+    const padding = 15;
+    if (!len) {
+      return 0;
+    }
+    try {
+      const str = len.toString();
+      if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.preciseSize) {
+        this.precsizeCalculationArea.innerText = str;
+        return this.precsizeCalculationArea.scrollWidth + padding * 2;
+      }
+      return str.length * this.letterBlockSize + padding * 2;
+    } catch (e) {
+      return 0;
+    }
+  }
+  afteredit(e) {
+    let data;
+    if (this.isRangeEdit(e)) {
+      data = e.data;
+    } else {
+      data = { 0: { [e.prop]: e.val } };
+    }
+    forEach(this.autoSizeColumns, (columns, type) => {
+      const sizes = {};
+      forEach(columns, (rgCol) => {
+        var _a;
+        const size = reduce(data, (prev, rgRow) => {
+          if (typeof rgRow[rgCol.prop] === "undefined") {
+            return prev;
+          }
+          return Math.max(prev || 0, this.getLength(rgRow[rgCol.prop]));
+        }, void 0);
+        if (size && ((_a = rgCol.size) !== null && _a !== void 0 ? _a : 0) < size) {
+          rgCol.size = sizes[rgCol.index] = size;
+        }
+      });
+      this.providers.dimension.setCustomSizes(type, sizes, true);
+    });
+  }
+  afterEditAll(e) {
+    const props = {};
+    if (this.isRangeEdit(e)) {
+      forEach(e.data, (r) => forEach(r, (_v, p) => props[p] = true));
+    } else {
+      props[e.prop] = true;
+    }
+    forEach(this.autoSizeColumns, (columns, type) => {
+      const sizes = {};
+      forEach(columns, (rgCol) => {
+        if (props[rgCol.prop]) {
+          const size = this.getColumnSize(rgCol.index, type);
+          if (size) {
+            sizes[rgCol.index] = size;
+          }
+        }
+      });
+      this.providers.dimension.setCustomSizes(type, sizes, true);
+    });
+  }
+  getColumnSize(index, type) {
+    var _a, _b;
+    const rgCol = (_b = (_a = this.autoSizeColumns) === null || _a === void 0 ? void 0 : _a[type]) === null || _b === void 0 ? void 0 : _b[index];
+    if (!rgCol) {
+      return 0;
+    }
+    return reduce(this.providers.data.stores, (r, s) => {
+      const perStore = reduce(s.store.get("items"), (prev, _row, i) => {
+        const item = getSourceItem(s.store, i);
+        return Math.max(prev || 0, this.getLength(item === null || item === void 0 ? void 0 : item[rgCol.prop]));
+      }, 0);
+      return Math.max(r, perStore);
+    }, rgCol.size || 0);
+  }
+  columnSet(columns) {
+    var _a;
+    for (let t of columnTypes) {
+      const type = t;
+      const cols = columns[type];
+      for (let i in cols) {
+        if (cols[i].autoSize || ((_a = this.config) === null || _a === void 0 ? void 0 : _a.allColumns)) {
+          if (!this.autoSizeColumns) {
+            this.autoSizeColumns = {};
+          }
+          if (!this.autoSizeColumns[type]) {
+            this.autoSizeColumns[type] = {};
+          }
+          this.autoSizeColumns[type][i] = Object.assign(Object.assign({}, cols[i]), { index: parseInt(i, 10) });
+        }
+      }
+    }
+    if (this.dataResolve) {
+      this.dataResolve(this.autoSizeColumns || {});
+      this.clearPromise();
+    }
+  }
+  clearPromise() {
+    this.dataResolve = null;
+    this.dataReject = null;
+  }
+  isRangeEdit(e) {
+    return !!e.data;
+  }
+  initiatePresizeElement() {
+    var _a;
+    const styleForFontTest = {
+      position: "absolute",
+      fontSize: "14px",
+      height: "0",
+      width: "0",
+      whiteSpace: "nowrap",
+      top: "0",
+      overflowX: "scroll",
+      display: "block"
+    };
+    const el = document.createElement("div");
+    for (let s in styleForFontTest) {
+      el.style[s] = (_a = styleForFontTest[s]) !== null && _a !== void 0 ? _a : "";
+    }
+    el.classList.add("revo-test-container");
+    return el;
+  }
+  destroy() {
+    var _a;
+    super.destroy();
+    (_a = this.precsizeCalculationArea) === null || _a === void 0 ? void 0 : _a.remove();
+  }
+};
+var StretchColumn = class extends BasePlugin {
+  constructor(revogrid, providers) {
+    super(revogrid, providers);
+    this.providers = providers;
+    this.stretchedColumn = null;
+    this.scrollSize = getScrollbarSize(document);
+    const beforecolumnapplied = ({ detail: { columns } }) => this.applyStretch(columns);
+    this.addEventListener("beforecolumnapplied", beforecolumnapplied);
+  }
+  setScroll({ type, hasScroll }) {
+    var _a;
+    if (type === "rgRow" && this.stretchedColumn && ((_a = this.stretchedColumn) === null || _a === void 0 ? void 0 : _a.initialSize) === this.stretchedColumn.size) {
+      if (hasScroll) {
+        this.stretchedColumn.size -= this.scrollSize;
+        this.apply();
+        this.dropChanges();
+      }
+    }
+  }
+  activateChanges() {
+    const setScroll = ({ detail }) => this.setScroll(detail);
+    this.addEventListener("scrollchange", setScroll);
+  }
+  dropChanges() {
+    this.stretchedColumn = null;
+    this.removeEventListener("scrollchange");
+  }
+  apply() {
+    if (!this.stretchedColumn) {
+      return;
+    }
+    const type = "rgCol";
+    const sizes = this.providers.dimension.stores[type].store.get("sizes");
+    this.providers.dimension.setCustomSizes(type, Object.assign(Object.assign({}, sizes), { [this.stretchedColumn.index]: this.stretchedColumn.size }), true);
+  }
+  /**
+   * Apply stretch changes
+   */
+  applyStretch(columns) {
+    this.dropChanges();
+    let sizeDifference = this.revogrid.clientWidth - 1;
+    forEach(columns, (_, type) => {
+      const realSize = this.providers.dimension.stores[type].store.get("realSize");
+      sizeDifference -= realSize;
+    });
+    if (this.revogrid.rowHeaders) {
+      const itemsLength = this.providers.data.stores.rgRow.store.get("source").length;
+      const header = this.revogrid.rowHeaders;
+      const rowHeaderSize = calculateRowHeaderSize(itemsLength, typeof header === "object" ? header : void 0);
+      if (rowHeaderSize) {
+        sizeDifference -= rowHeaderSize;
+      }
+    }
+    if (sizeDifference > 0) {
+      const index = columns.rgCol.length - 1;
+      const last = columns.rgCol[index];
+      const colSize = (last === null || last === void 0 ? void 0 : last.size) || this.revogrid.colSize || 0;
+      const size = sizeDifference + colSize - 1;
+      if (last && !last.autoSize && colSize < size) {
+        this.stretchedColumn = {
+          initialSize: size,
+          index,
+          size
+        };
+        this.apply();
+        this.activateChanges();
+      }
+    }
+  }
+};
+function isStretchPlugin(plugin) {
+  return !!plugin.applyStretch;
+}
+function baseClamp(number, lower, upper) {
+  if (number === number) {
+    {
+      number = number <= upper ? number : upper;
+    }
+    {
+      number = number >= lower ? number : lower;
+    }
+  }
+  return number;
+}
+var MAX_ARRAY_LENGTH = 4294967295;
+function toLength(value) {
+  return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
+}
+function baseFill(array, value, start, end) {
+  var length = array.length;
+  start = toInteger(start);
+  if (start < 0) {
+    start = -start > length ? 0 : length + start;
+  }
+  end = end === void 0 || end > length ? length : toInteger(end);
+  if (end < 0) {
+    end += length;
+  }
+  end = start > end ? 0 : toLength(end);
+  while (start < end) {
+    array[start++] = value;
+  }
+  return array;
+}
+function fill(array, value, start, end) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return [];
+  }
+  return baseFill(array, value, start, end);
+}
+var INITIAL = {
+  mime: "text/csv",
+  fileKind: "csv",
+  // BOM signature
+  bom: true,
+  columnDelimiter: ",",
+  rowDelimiter: "\r\n",
+  encoding: ""
+};
+var CARRIAGE_RETURN = String.fromCharCode(13);
+var LINE_FEED = String.fromCharCode(10);
+var DOUBLE_QT = String.fromCharCode(34);
+var NO_BREAK_SPACE = String.fromCharCode(65279);
+var escapeRegex = new RegExp('"', "g");
+var ExportCsv = class {
+  constructor(options = {}) {
+    this.options = Object.assign(Object.assign({}, INITIAL), options);
+  }
+  doExport({ data, headers, props }) {
+    let result = this.options.bom ? NO_BREAK_SPACE : "";
+    if ((headers === null || headers === void 0 ? void 0 : headers.length) > 0) {
+      headers.forEach((header) => {
+        if (!header.length) {
+          return;
+        }
+        result += this.prepareHeader(header, this.options.columnDelimiter);
+        result += this.options.rowDelimiter;
+      });
+    }
+    data.forEach((rgRow, index) => {
+      if (index > 0) {
+        result += this.options.rowDelimiter;
+      }
+      if (isGrouping(rgRow)) {
+        result += this.parseCell(getGroupingName(rgRow), this.options.columnDelimiter);
+        return;
+      }
+      result += props.map((p) => this.parseCell(rgRow[p], this.options.columnDelimiter)).join(this.options.columnDelimiter);
+    });
+    return result;
+  }
+  prepareHeader(columnHeaders, columnDelimiter) {
+    let result = "";
+    const newColumnHeaders = columnHeaders.map((v) => this.parseCell(v, columnDelimiter, true));
+    result += newColumnHeaders.join(columnDelimiter);
+    return result;
+  }
+  parseCell(value, columnDelimiter, force = false) {
+    let escape = value;
+    if (typeof value !== "string") {
+      escape = JSON.stringify(value);
+    }
+    const toEscape = [CARRIAGE_RETURN, DOUBLE_QT, LINE_FEED, columnDelimiter];
+    if (typeof escape === "undefined") {
+      return "";
+    }
+    if (escape !== "" && (force || toEscape.some((i) => escape.indexOf(i) >= 0))) {
+      return `"${escape.replace(escapeRegex, '""')}"`;
+    }
+    return escape;
+  }
+};
+var ExportTypes;
+(function(ExportTypes2) {
+  ExportTypes2["csv"] = "csv";
+})(ExportTypes || (ExportTypes = {}));
+var ExportFilePlugin = class extends BasePlugin {
+  /** Exports string */
+  async exportString(options = {}, t = ExportTypes.csv) {
+    const data = await this.beforeexport();
+    if (!data) {
+      return null;
+    }
+    return this.formatter(t, options).doExport(data);
+  }
+  /** Exports Blob */
+  async exportBlob(options = {}, t = ExportTypes.csv) {
+    return await this.getBlob(this.formatter(t, options));
+  }
+  /** Export file */
+  async exportFile(options = {}, t = ExportTypes.csv) {
+    const formatter = this.formatter(t, options);
+    const URL = window.URL || window.webkitURL;
+    const a = document.createElement("a");
+    const { filename, fileKind } = formatter.options;
+    const name = `${filename}.${fileKind}`;
+    const blob = await this.getBlob(formatter);
+    const url = blob ? URL.createObjectURL(blob) : "";
+    a.style.display = "none";
+    a.setAttribute("href", url);
+    a.setAttribute("download", name);
+    this.revogrid.appendChild(a);
+    a.dispatchEvent(new MouseEvent("click"));
+    this.revogrid.removeChild(a);
+    await timeout(120);
+    URL.revokeObjectURL(url);
+  }
+  /** Blob object */
+  async getBlob(formatter) {
+    const type = `${formatter.options.mime};charset=${formatter.options.encoding}`;
+    if (typeof Blob !== "undefined") {
+      const data = await this.beforeexport();
+      if (!data) {
+        return null;
+      }
+      return new Blob([formatter.doExport(data)], { type });
+    }
+    return null;
+  }
+  // before event
+  async beforeexport() {
+    let data = await this.getData();
+    const event = this.emit("beforeexport", { data });
+    if (event.defaultPrevented) {
+      return null;
+    }
+    return event.detail.data;
+  }
+  async getData() {
+    const data = await this.getSource();
+    const colSource = [];
+    const colPromises = [];
+    columnTypes.forEach((t, i) => {
+      colPromises.push(this.getColPerSource(t).then((s) => colSource[i] = s));
+    });
+    await Promise.all(colPromises);
+    const columns = {
+      headers: [],
+      props: []
+    };
+    for (let source of colSource) {
+      source.headers.forEach((h2, i) => {
+        if (!columns.headers[i]) {
+          columns.headers[i] = [];
+        }
+        columns.headers[i].push(...h2);
+      });
+      columns.props.push(...source.props);
+    }
+    return Object.assign({ data }, columns);
+  }
+  async getColPerSource(t) {
+    const store = await this.revogrid.getColumnStore(t);
+    const source = store.get("source");
+    const virtualIndexes = store.get("items");
+    const depth = store.get("groupingDepth");
+    const groups = store.get("groups");
+    const colNames = [];
+    const colProps = [];
+    virtualIndexes.forEach((v) => {
+      const prop = source[v].prop;
+      colNames.push(source[v].name || "");
+      colProps.push(prop);
+    });
+    const rows = this.getGroupHeaders(depth, groups, virtualIndexes);
+    rows.push(colNames);
+    return {
+      headers: rows,
+      props: colProps
+    };
+  }
+  getGroupHeaders(depth, groups, items) {
+    const rows = [];
+    const template = fill(new Array(items.length), "");
+    for (let d = 0; d < depth; d++) {
+      const rgRow = [...template];
+      rows.push(rgRow);
+      if (!groups[d]) {
+        continue;
+      }
+      const levelGroups = groups[d];
+      levelGroups.forEach((group) => {
+        const minIndex = group.indexes[0];
+        if (typeof minIndex === "number") {
+          rgRow[minIndex] = group.name;
+        }
+      });
+    }
+    return rows;
+  }
+  async getSource() {
+    const data = [];
+    const promisesData = [];
+    rowTypes.forEach((t) => {
+      const dataPart = [];
+      data.push(dataPart);
+      const promise = this.revogrid.getVisibleSource(t).then((d) => dataPart.push(...d));
+      promisesData.push(promise);
+    });
+    await Promise.all(promisesData);
+    return data.reduce((r, v) => {
+      r.push(...v);
+      return r;
+    }, []);
+  }
+  // get correct class for future multiple types support
+  formatter(type, options = {}) {
+    switch (type) {
+      case ExportTypes.csv:
+        return new ExportCsv(options);
+      default:
+        throw new Error("Unknown format");
+    }
+  }
+};
+var eq = (value, extra) => {
+  if (typeof value === "undefined" || value === null && !extra) {
+    return true;
+  }
+  if (typeof value !== "string") {
+    value = JSON.stringify(value);
+  }
+  const filterVal = extra === null || extra === void 0 ? void 0 : extra.toString().toLocaleLowerCase();
+  if ((filterVal === null || filterVal === void 0 ? void 0 : filterVal.length) === 0) {
+    return true;
+  }
+  return value.toLocaleLowerCase() === filterVal;
+};
+var notEq = (value, extra) => !eq(value, extra);
+notEq.extra = "input";
+eq.extra = "input";
+var gtThan = function(value, extra) {
+  let conditionValue;
+  if (typeof value === "number" && typeof extra !== "undefined" && extra !== null) {
+    conditionValue = parseFloat(extra === null || extra === void 0 ? void 0 : extra.toString());
+    return value > conditionValue;
+  }
+  return false;
+};
+gtThan.extra = "input";
+var gtThanEq = function(value, extra) {
+  return eq(value, extra) || gtThan(value, extra);
+};
+gtThanEq.extra = "input";
+var lt = function(value, extra) {
+  let conditionValue;
+  if (typeof value === "number" && typeof extra !== "undefined" && extra !== null) {
+    conditionValue = parseFloat(extra.toString());
+    return value < conditionValue;
+  } else {
+    return false;
+  }
+};
+lt.extra = "input";
+var lsEq = function(value, extra) {
+  return eq(value, extra) || lt(value, extra);
+};
+lsEq.extra = "input";
+var set = (value) => !(value === "" || value === null || value === void 0);
+var notSet = (value) => !set(value);
+var beginsWith = (value, extra) => {
+  if (!value) {
+    return false;
+  }
+  if (!extra) {
+    return true;
+  }
+  if (typeof value !== "string") {
+    value = JSON.stringify(value);
+  }
+  if (typeof extra !== "string") {
+    extra = JSON.stringify(extra);
+  }
+  return value.toLocaleLowerCase().indexOf(extra.toLocaleLowerCase()) === 0;
+};
+beginsWith.extra = "input";
+var contains = (value, extra) => {
+  if (!extra) {
+    return true;
+  }
+  if (!value) {
+    return false;
+  }
+  if (extra) {
+    if (typeof value !== "string") {
+      value = JSON.stringify(value);
+    }
+    return value.toLocaleLowerCase().indexOf(extra.toString().toLowerCase()) > -1;
+  }
+  return true;
+};
+var notContains = (value, extra) => {
+  return !contains(value, extra);
+};
+notContains.extra = "input";
+contains.extra = "input";
+var filterCoreFunctionsIndexedByType = {
+  none: () => true,
+  empty: notSet,
+  notEmpty: set,
+  eq,
+  notEq,
+  begins: beginsWith,
+  contains,
+  notContains,
+  eqN: eq,
+  neqN: notEq,
+  gt: gtThan,
+  gte: gtThanEq,
+  lt,
+  lte: lsEq
+};
+var filterTypes = {
+  string: ["notEmpty", "empty", "eq", "notEq", "begins", "contains", "notContains"],
+  number: ["notEmpty", "empty", "eqN", "neqN", "gt", "gte", "lt", "lte"]
+};
+var filterNames = {
+  none: "None",
+  empty: "Not set",
+  notEmpty: "Set",
+  eq: "Equal",
+  notEq: "Not equal",
+  begins: "Begins with",
+  contains: "Contains",
+  notContains: "Does not contain",
+  eqN: "=",
+  neqN: "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+var FILTER_TRIMMED_TYPE = "filter";
+var FILTER_CONFIG_CHANGED_EVENT = "filterconfigchanged";
+var FILTE_PANEL = "revogr-filter-panel";
+var FilterPlugin = class extends BasePlugin {
+  constructor(revogrid, providers, config) {
+    var _a;
+    super(revogrid, providers);
+    this.revogrid = revogrid;
+    this.config = config;
+    this.filterCollection = {};
+    this.multiFilterItems = {};
+    this.filterByType = Object.assign({}, filterTypes);
+    this.filterNameIndexByType = Object.assign({}, filterNames);
+    this.filterFunctionsIndexedByType = Object.assign({}, filterCoreFunctionsIndexedByType);
+    this.filterProp = FILTER_PROP;
+    this.allowDuplicateOperators = true;
+    if (config) {
+      this.initConfig(config);
+    }
+    const existingNodes = this.revogrid.registerVNode.filter((n) => typeof n === "object" && n.$tag$ !== FILTE_PANEL);
+    this.revogrid.registerVNode = [
+      ...existingNodes,
+      h("revogr-filter-panel", { filterNames: this.filterNameIndexByType, filterEntities: this.filterFunctionsIndexedByType, filterCaptions: (_a = config === null || config === void 0 ? void 0 : config.localization) === null || _a === void 0 ? void 0 : _a.captions, onFilterChange: (e) => this.onFilterChange(e.detail), onResetChange: (e) => this.onFilterReset(e.detail), disableDynamicFiltering: config === null || config === void 0 ? void 0 : config.disableDynamicFiltering, closeOnOutsideClick: config === null || config === void 0 ? void 0 : config.closeFilterPanelOnOutsideClick, allowDuplicateOperators: this.allowDuplicateOperators, ref: (e) => this.pop = e }, " ", this.extraContent())
+    ];
+    const aftersourceset = async () => {
+      const filterCollectionProps = Object.keys(this.filterCollection);
+      if (filterCollectionProps.length > 0) {
+        filterCollectionProps.forEach((prop, index) => {
+          if (!this.multiFilterItems[prop]) {
+            this.multiFilterItems[prop] = [
+              {
+                id: index,
+                type: this.filterCollection[prop].type,
+                value: this.filterCollection[prop].value,
+                relation: "and"
+              }
+            ];
+          }
+        });
+      }
+      if (Object.keys(this.multiFilterItems).length === 0) {
+        return;
+      }
+      await timeout();
+      await this.runFiltering(this.multiFilterItems);
+    };
+    this.addEventListener("headerclick", (e) => this.headerclick(e));
+    this.addEventListener(FILTER_CONFIG_CHANGED_EVENT, ({ detail }) => {
+      if (!detail) {
+        this.clearFiltering();
+        return;
+      }
+      if (typeof detail === "object") {
+        const detailKeys = Object.keys(detail);
+        const preserveCurrentFilters = !detailKeys.includes("multiFilterItems") && detailKeys.includes("allowDuplicateOperators");
+        this.initConfig(preserveCurrentFilters ? Object.assign(Object.assign({}, detail), { multiFilterItems: this.multiFilterItems }) : detail);
+        if (!detail.multiFilterItems || !Object.keys(detail.multiFilterItems).length) {
+          if (preserveCurrentFilters) {
+            aftersourceset();
+            return;
+          }
+          this.clearFiltering();
+          return;
+        }
+      }
+      aftersourceset();
+    });
+    this.addEventListener("aftersourceset", aftersourceset);
+    this.addEventListener("filter", ({ detail }) => this.onFilterChange(detail));
+  }
+  beforeshow(_) {
+  }
+  extraContent() {
+    return null;
+  }
+  initConfig(config) {
+    var _a;
+    this.allowDuplicateOperators = (_a = config.allowDuplicateOperators) !== null && _a !== void 0 ? _a : true;
+    if (this.pop) {
+      this.pop.allowDuplicateOperators = this.allowDuplicateOperators;
+    }
+    if (config.multiFilterItems) {
+      this.multiFilterItems = Object.assign({}, config.multiFilterItems);
+    } else {
+      this.multiFilterItems = {};
+    }
+    if (config.customFilters) {
+      for (let customFilterType in config.customFilters) {
+        const cFilter = config.customFilters[customFilterType];
+        if (!this.filterByType[cFilter.columnFilterType]) {
+          this.filterByType[cFilter.columnFilterType] = [];
+        }
+        this.filterByType[cFilter.columnFilterType].push(customFilterType);
+        this.filterFunctionsIndexedByType[customFilterType] = cFilter.func;
+        this.filterNameIndexByType[customFilterType] = cFilter.name;
+      }
+    }
+    if (config.filterProp) {
+      this.filterProp = config.filterProp;
+    }
+    const cfgInlcude = config.include;
+    if (cfgInlcude) {
+      const filters = {};
+      for (let t in this.filterByType) {
+        const newTypes = this.filterByType[t].filter((f) => cfgInlcude.indexOf(f) > -1);
+        if (newTypes.length) {
+          filters[t] = newTypes;
+        }
+      }
+      if (Object.keys(filters).length > 0) {
+        this.filterByType = filters;
+      }
+    }
+    if (config.collection) {
+      const filterCollection = {};
+      for (const prop of Object.keys(config.collection)) {
+        const item = config.collection[prop];
+        if (this.filterFunctionsIndexedByType[item.type]) {
+          filterCollection[prop] = item;
+        }
+      }
+      this.filterCollection = filterCollection;
+    } else {
+      this.filterCollection = {};
+    }
+    if (config.localization) {
+      if (config.localization.filterNames) {
+        const filterNames2 = config.localization.filterNames;
+        Object.keys(filterNames2).forEach((k) => {
+          if (this.filterNameIndexByType[k] != void 0) {
+            this.filterNameIndexByType[k] = filterNames2[k];
+          }
+        });
+      }
+    }
+  }
+  async headerclick(e) {
+    var _a, _b;
+    const el = (_a = e.detail.originalEvent) === null || _a === void 0 ? void 0 : _a.target;
+    const filterButton = isFilterBtn(el);
+    if (!filterButton) {
+      return;
+    }
+    e.preventDefault();
+    if (!this.pop) {
+      return;
+    }
+    const prop = e.detail.prop;
+    const currentPanel = await this.pop.getChanges();
+    if ((currentPanel === null || currentPanel === void 0 ? void 0 : currentPanel.prop) === prop) {
+      await this.pop.show();
+      return;
+    }
+    const buttonPos = (filterButton instanceof HTMLElement ? filterButton : el).getBoundingClientRect();
+    const data = Object.assign(Object.assign(Object.assign({}, e.detail), this.filterCollection[prop]), { x: buttonPos.x, y: buttonPos.y + buttonPos.height, anchorY: buttonPos.y, autoCorrect: true, filterTypes: this.getColumnFilter(e.detail.filter), filterItems: this.multiFilterItems, extraContent: this.extraHyperContent, extraBottomContent: this.extraBottomHyperContent });
+    (_b = this.beforeshow) === null || _b === void 0 ? void 0 : _b.call(this, data);
+    this.pop.show(data);
+  }
+  getColumnFilter(type) {
+    let filterType = "string";
+    if (!type) {
+      return { [filterType]: this.filterByType[filterType] };
+    }
+    if (this.isValidType(type)) {
+      filterType = type;
+    } else if (typeof type === "object" && type.length) {
+      return type.reduce((r, multiType) => {
+        if (this.isValidType(multiType)) {
+          r[multiType] = this.filterByType[multiType];
+        }
+        return r;
+      }, {});
+    }
+    return { [filterType]: this.filterByType[filterType] };
+  }
+  isValidType(type) {
+    return !!(typeof type === "string" && this.filterByType[type]);
+  }
+  /**
+   * Called on internal component change
+   */
+  async onFilterChange(filterItems) {
+    this.multiFilterItems = filterItems;
+    this.runFiltering(this.multiFilterItems);
+  }
+  onFilterReset(prop) {
+    delete this.multiFilterItems[prop !== null && prop !== void 0 ? prop : ""];
+    this.onFilterChange(this.multiFilterItems);
+  }
+  /**
+   * Triggers grid filtering
+   */
+  async doFiltering(collection, source, columns, filterItems) {
+    const columnsToUpdate = [];
+    const columnByProp = {};
+    columns.forEach((rgCol) => {
+      const column = Object.assign({}, rgCol);
+      const hasFilter = filterItems[column.prop];
+      columnByProp[column.prop] = column;
+      if (column[this.filterProp] && !hasFilter) {
+        delete column[this.filterProp];
+        columnsToUpdate.push(column);
+      }
+      if (!column[this.filterProp] && hasFilter) {
+        columnsToUpdate.push(column);
+        column[this.filterProp] = true;
+      }
+    });
+    const itemsToTrim = this.getRowFilter(source, filterItems, columnByProp);
+    const { defaultPrevented, detail } = this.emit("beforefiltertrimmed", {
+      collection,
+      itemsToFilter: itemsToTrim,
+      source,
+      filterItems
+    });
+    if (defaultPrevented) {
+      return;
+    }
+    this.providers.data.setTrimmed({ [FILTER_TRIMMED_TYPE]: detail.itemsToFilter });
+    this.providers.column.updateColumns(columnsToUpdate);
+    this.emit("afterfilterapply", {
+      multiFilterItems: filterItems,
+      source,
+      collection
+    });
+  }
+  async clearFiltering() {
+    this.multiFilterItems = {};
+    await this.runFiltering(this.multiFilterItems);
+  }
+  async runFiltering(multiFilterItems) {
+    const collection = {};
+    const filterProps = Object.keys(multiFilterItems);
+    for (const prop of filterProps) {
+      if (multiFilterItems[prop].length > 0) {
+        const firstFilterItem = multiFilterItems[prop][0];
+        collection[prop] = {
+          type: firstFilterItem.type,
+          value: firstFilterItem.value
+        };
+      }
+    }
+    this.filterCollection = collection;
+    const columns = this.providers.column.getColumns();
+    const source = this.providers.data.stores["rgRow"].store.get("source");
+    const { defaultPrevented, detail } = this.emit("beforefilterapply", {
+      collection: this.filterCollection,
+      source,
+      columns,
+      filterItems: this.multiFilterItems
+    });
+    if (defaultPrevented) {
+      return;
+    }
+    this.doFiltering(detail.collection, detail.source, detail.columns, detail.filterItems);
+  }
+  /**
+   * Get trimmed rows based on filter
+   */
+  getRowFilter(rows, filterItems, columnByProp) {
+    const propKeys = Object.keys(filterItems);
+    const trimmed = {};
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+      for (const prop of propKeys) {
+        if (this.shouldTrimRow(filterItems[prop], prop, columnByProp[prop], rows[rowIndex])) {
+          trimmed[rowIndex] = true;
+        }
+      }
+    }
+    return trimmed;
+  }
+  shouldTrimRow(propFilters, prop, column, model = {}) {
+    let propFilterSatisfiedCount = 0;
+    let lastFilterResults = [];
+    for (const [filterIndex, filterData] of propFilters.entries()) {
+      const filterFunc = this.filterFunctionsIndexedByType[filterData.type];
+      const value = column ? getCellDataParsed(model, column) : model[prop];
+      if (filterData.relation === "or") {
+        lastFilterResults = [];
+        if (filterFunc(value, filterData.value)) {
+          continue;
+        }
+        propFilterSatisfiedCount++;
+      } else {
+        lastFilterResults.push(!filterFunc(value, filterData.value));
+        if (isFinalAndFilter(filterIndex, propFilters)) {
+          if (allAndConditionsSatisfied(lastFilterResults)) {
+            lastFilterResults = [];
+            continue;
+          }
+          propFilterSatisfiedCount += lastFilterResults.length;
+          lastFilterResults = [];
+        }
+      }
+    }
+    return propFilterSatisfiedCount === propFilters.length;
+  }
+};
+function isFinalAndFilter(index, filters) {
+  const nextFilter = filters[index + 1];
+  return !nextFilter || !!nextFilter.relation && nextFilter.relation !== "and";
+}
+function allAndConditionsSatisfied(pendingResults) {
+  return !pendingResults.includes(true);
+}
+function hasActiveSorting(sorting) {
+  for (const prop of Object.keys(sorting || {})) {
+    if (sorting === null || sorting === void 0 ? void 0 : sorting[prop]) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSameColumnProp(a, b) {
+  return String(a) === String(b);
+}
+function getActiveSortingProps(sorting, sortingOrder) {
+  const activeProps = [];
+  const add = (prop) => {
+    if ((sorting === null || sorting === void 0 ? void 0 : sorting[prop]) && !activeProps.some((active) => isSameColumnProp(active, prop))) {
+      activeProps.push(prop);
+    }
+  };
+  sortingOrder === null || sortingOrder === void 0 ? void 0 : sortingOrder.forEach(add);
+  Object.keys(sorting || {}).forEach(add);
+  return activeProps;
+}
+function getSortingIndex(sorting, prop, sortingOrder) {
+  const activeProps = getActiveSortingProps(sorting, sortingOrder);
+  if (activeProps.length <= 1) {
+    return void 0;
+  }
+  const index = activeProps.findIndex((active) => isSameColumnProp(active, prop));
+  return index >= 0 ? index + 1 : void 0;
+}
+function activeSortingEntries(sortingFunc = {}, sortingOrder) {
+  const entries = [];
+  const add = (prop) => {
+    const cmp = sortingFunc[prop];
+    if (typeof cmp === "function" && !entries.some(([active]) => isSameColumnProp(active, prop))) {
+      entries.push([prop, cmp]);
+    }
+  };
+  sortingOrder === null || sortingOrder === void 0 ? void 0 : sortingOrder.forEach(add);
+  Object.keys(sortingFunc).forEach(add);
+  return entries;
+}
+function getDefaultCompareValue(item, prop, column) {
+  const aRaw = column ? getCellRaw(item, column) : item === null || item === void 0 ? void 0 : item[prop];
+  return typeof aRaw === "number" ? aRaw : aRaw === null || aRaw === void 0 ? void 0 : aRaw.toString().toLowerCase();
+}
+function isEmptyCompareValue(value) {
+  return value === "" || value === null || value === void 0;
+}
+function compareValues(av, bv) {
+  if (av === bv) {
+    return 0;
+  }
+  const aEmpty = isEmptyCompareValue(av);
+  const bEmpty = isEmptyCompareValue(bv);
+  if (aEmpty || bEmpty) {
+    if (aEmpty && bEmpty) {
+      return 0;
+    }
+    return aEmpty ? -1 : 1;
+  }
+  if (av > bv) {
+    return 1;
+  }
+  return -1;
+}
+function sortIndexByDefaultComparers(indexes, source, entries, sorting, sortingColumns) {
+  const prepared = entries.map(([prop]) => {
+    const values = [];
+    const column = sortingColumns[prop];
+    for (const index of indexes) {
+      values[index] = getDefaultCompareValue(source[index], prop, column);
+    }
+    return {
+      order: sorting[prop],
+      values
+    };
+  });
+  return indexes.sort((a, b) => {
+    for (const { order, values } of prepared) {
+      const sorted = compareValues(values[a], values[b]);
+      if (sorted) {
+        return order === "desc" ? -sorted : sorted;
+      }
+    }
+    return 0;
+  });
+}
+function canUseDefaultCompareFastPath(entries, indexes, source, sorting, sortingColumns) {
+  return !indexes.some((index) => isGrouping(source[index])) && !!sorting && !!sortingColumns && entries.every(([prop]) => {
+    const order = sorting[prop];
+    const column = sortingColumns[prop];
+    return !!order && !(column === null || column === void 0 ? void 0 : column.cellCompare);
+  });
+}
+function hasGroupingRowsForOtherSorting(entries, indexes, source) {
+  return indexes.some((index) => {
+    const item = source[index];
+    return isGrouping(item) && !entries.some(([prop]) => isSameColumnProp(item[GROUP_COLUMN_PROP], prop));
+  });
+}
+function sortIndexByItems(indexes, source, sortingFunc = {}, sorting, sortingColumns, sortingOrder) {
+  const hasSortingKeys = Object.keys(sortingFunc).length > 0;
+  const sortingEntries = activeSortingEntries(sortingFunc, sortingOrder);
+  if (sortingEntries.length === 0) {
+    return hasSortingKeys ? indexes : [...new Array(indexes.length).keys()];
+  }
+  if (hasGroupingRowsForOtherSorting(sortingEntries, indexes, source)) {
+    return indexes;
+  }
+  if (canUseDefaultCompareFastPath(sortingEntries, indexes, source, sorting, sortingColumns)) {
+    return sortIndexByDefaultComparers(indexes, source, sortingEntries, sorting, sortingColumns);
+  }
+  return indexes.sort((a, b) => {
+    const itemA = source[a];
+    const itemB = source[b];
+    for (const [prop, cmp] of sortingEntries) {
+      if (isGrouping(itemA)) {
+        if (!isSameColumnProp(itemA[GROUP_COLUMN_PROP], prop)) {
+          return a - b;
+        }
+      }
+      if (isGrouping(itemB)) {
+        if (!isSameColumnProp(itemB[GROUP_COLUMN_PROP], prop)) {
+          return a - b;
+        }
+      }
+      const sorted = cmp === null || cmp === void 0 ? void 0 : cmp(prop, itemA, itemB);
+      if (sorted) {
+        return sorted;
+      }
+    }
+    return 0;
+  });
+}
+function defaultCellCompare(prop, a, b) {
+  const aRaw = this.column ? getCellRaw(a, this.column) : a === null || a === void 0 ? void 0 : a[prop];
+  const bRaw = this.column ? getCellRaw(b, this.column) : b === null || b === void 0 ? void 0 : b[prop];
+  const av = typeof aRaw === "number" ? aRaw : aRaw === null || aRaw === void 0 ? void 0 : aRaw.toString().toLowerCase();
+  const bv = typeof bRaw === "number" ? bRaw : bRaw === null || bRaw === void 0 ? void 0 : bRaw.toString().toLowerCase();
+  return compareValues(av, bv);
+}
+function descCellCompare(cmp) {
+  return (prop, a, b) => {
+    return -1 * cmp(prop, a, b);
+  };
+}
+function getNextOrder(currentOrder) {
+  switch (currentOrder) {
+    case void 0:
+      return "asc";
+    case "asc":
+      return "desc";
+    case "desc":
+      return void 0;
+  }
+}
+function getComparer(column, order) {
+  var _a;
+  const cellCmp = ((_a = column === null || column === void 0 ? void 0 : column.cellCompare) === null || _a === void 0 ? void 0 : _a.bind({ order })) || (defaultCellCompare === null || defaultCellCompare === void 0 ? void 0 : defaultCellCompare.bind({ column, order }));
+  if (order == "asc") {
+    return cellCmp;
+  }
+  if (order == "desc") {
+    return descCellCompare(cellCmp);
+  }
+  return void 0;
+}
+function getSortableRowIndexes(indexes, source) {
+  return indexes.filter((index) => !isGrouping(source[index]));
+}
+function mergeSortedRowsWithGroups(indexes, source, sortedRows) {
+  if (sortedRows.length === indexes.length) {
+    return sortedRows;
+  }
+  let rowIndex = 0;
+  return indexes.map((index) => {
+    if (isGrouping(source[index])) {
+      return index;
+    }
+    return sortedRows[rowIndex++];
+  });
+}
+var SortingPlugin = class extends BasePlugin {
+  constructor(revogrid, providers, config) {
+    super(revogrid, providers);
+    this.revogrid = revogrid;
+    this.sortingPromise = null;
+    this.postponeSort = debounce((order, comparison, sortingColumns, sortingOrder, ignoreViewportUpdate) => this.runSorting(order, comparison, sortingColumns, sortingOrder, ignoreViewportUpdate), 50);
+    this.applySortingConfig(config);
+    this.addEventListener("sortingconfigchanged", ({ detail }) => {
+      config = detail;
+      this.applySortingConfig(detail);
+      this.startSorting(this.sorting, this.sortingFunc, this.sortingColumns, this.sortingOrder);
+    });
+    this.addEventListener("beforeheaderrender", ({ detail }) => {
+      var _a;
+      const { data: column } = detail;
+      if (column.sortable) {
+        detail.data = Object.assign(Object.assign({}, column), { order: (_a = this.sorting) === null || _a === void 0 ? void 0 : _a[column.prop], sortIndex: getSortingIndex(this.sorting, column.prop, this.sortingOrder) });
+      }
+    });
+    this.addEventListener("beforeanysource", ({ detail: { type } }) => {
+      if (hasActiveSorting(this.sorting) && this.sortingFunc) {
+        const event = this.emit("beforesourcesortingapply", { type, sorting: this.sorting });
+        if (event.defaultPrevented) {
+          return;
+        }
+        this.startSorting(this.sorting, this.sortingFunc, this.sortingColumns, this.sortingOrder);
+      }
+    });
+    this.addEventListener("aftercolumnsset", ({ detail: { order } }) => {
+      if (config) {
+        return;
+      }
+      const columns = this.providers.column.getColumns();
+      const sortingFunc = {};
+      const sortingColumns = {};
+      const sortingOrder = [];
+      const sorting = {};
+      for (let prop in order) {
+        if (order[prop]) {
+          const column = getColumnByProp(columns, prop);
+          const cmp = getComparer(column, order[prop]);
+          sorting[prop] = order[prop];
+          sortingFunc[prop] = cmp;
+          sortingColumns[prop] = column;
+          sortingOrder.push(prop);
+        }
+      }
+      this.sorting = hasActiveSorting(sorting) ? sorting : void 0;
+      this.sortingFunc = this.sorting ? sortingFunc : void 0;
+      this.sortingColumns = this.sorting ? sortingColumns : void 0;
+      this.sortingOrder = this.sorting ? sortingOrder : void 0;
+    });
+    this.addEventListener("beforeheaderclick", (e) => {
+      var _a, _b, _c, _d;
+      if (e.defaultPrevented) {
+        return;
+      }
+      if (!((_b = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.column) === null || _b === void 0 ? void 0 : _b.sortable)) {
+        return;
+      }
+      this.headerclick(e.detail.column, (_d = (_c = e.detail) === null || _c === void 0 ? void 0 : _c.originalEvent) === null || _d === void 0 ? void 0 : _d.shiftKey);
+    });
+  }
+  /**
+   * Creates mutable sorting maps from current state when additive sorting is requested.
+   */
+  createSortingState(additive) {
+    var _a;
+    return {
+      sorting: additive ? Object.assign({}, this.sorting) : {},
+      sortingFunc: additive ? Object.assign({}, this.sortingFunc) : {},
+      sortingColumns: additive ? Object.assign({}, this.sortingColumns) : {},
+      sortingOrder: additive ? [...(_a = this.sortingOrder) !== null && _a !== void 0 ? _a : []] : []
+    };
+  }
+  /**
+   * Stores normalized sorting state, clearing inactive empty maps.
+   */
+  setSortingState({ sorting, sortingFunc, sortingColumns, sortingOrder }) {
+    this.sorting = hasActiveSorting(sorting) ? sorting : void 0;
+    this.sortingFunc = this.sorting ? sortingFunc : void 0;
+    this.sortingColumns = this.sorting ? sortingColumns : void 0;
+    this.sortingOrder = this.sorting ? sortingOrder : void 0;
+  }
+  /**
+   * Adds or replaces a column in a sorting state.
+   */
+  setColumnSorting(state, prop, order, cmp, column) {
+    state.sorting[prop] = order;
+    state.sortingFunc[prop] = cmp;
+    state.sortingColumns[prop] = column;
+    if (!state.sortingOrder.some((sortingProp) => String(sortingProp) === String(prop))) {
+      state.sortingOrder.push(prop);
+    }
+  }
+  /**
+   * Removes a column from a sorting state.
+   */
+  clearColumnSorting(state, prop) {
+    delete state.sorting[prop];
+    delete state.sortingFunc[prop];
+    delete state.sortingColumns[prop];
+    const index = state.sortingOrder.findIndex((sortingProp) => String(sortingProp) === String(prop));
+    if (index >= 0) {
+      state.sortingOrder.splice(index, 1);
+    }
+  }
+  /**
+   * Normalizes external sorting configuration into internal order,
+   * comparator, and column metadata maps.
+   */
+  applySortingConfig(cfg) {
+    var _a;
+    if (!cfg) {
+      return;
+    }
+    const state = this.createSortingState(cfg.additive);
+    (_a = cfg.columns) === null || _a === void 0 ? void 0 : _a.forEach((col) => {
+      if (col.order) {
+        this.setColumnSorting(state, col.prop, col.order, getComparer(col, col.order), col);
+        return;
+      }
+      this.clearColumnSorting(state, col.prop);
+    });
+    this.setSortingState(state);
+  }
+  resetSortingForStore(type) {
+    const storeService = this.providers.data.stores[type];
+    const source = storeService.store.get("source");
+    const proxyItems = storeService.store.get("proxyItems");
+    const newItemsOrder = Array.from({ length: source.length }, (_, i) => i);
+    this.providers.dimension.updateSizesPositionByNewDataIndexes(type, newItemsOrder, proxyItems);
+    storeService.setData({ proxyItems: newItemsOrder });
+  }
+  applySortingForStore(type, sorting, sortingFunc, sortingColumns, sortingOrder, ignoreViewportUpdate) {
+    const storeService = this.providers.data.stores[type];
+    const source = storeService.store.get("source");
+    const proxyItems = storeService.store.get("proxyItems");
+    const sortItems = getSortableRowIndexes(proxyItems, source);
+    const sortedItems = sortIndexByItems([...sortItems], source, sortingFunc, sorting, sortingColumns, sortingOrder);
+    const newItemsOrder = mergeSortedRowsWithGroups(proxyItems, source, sortedItems);
+    const prevItems = storeService.store.get("items");
+    storeService.setData({
+      proxyItems: newItemsOrder
+    });
+    const newItems = storeService.store.get("items");
+    if (!ignoreViewportUpdate) {
+      this.providers.dimension.updateSizesPositionByNewDataIndexes(type, newItems, prevItems);
+    }
+  }
+  startSorting(order, sortingFunc, sortingColumns, sortingOrder, ignoreViewportUpdate) {
+    if (!this.sortingPromise) {
+      this.revogrid.jobsBeforeRender.push(new Promise((resolve) => {
+        this.sortingPromise = resolve;
+      }));
+    }
+    if (typeof sortingColumns === "boolean") {
+      this.postponeSort(order, sortingFunc, void 0, void 0, sortingColumns);
+      return;
+    }
+    this.postponeSort(order, sortingFunc, sortingColumns, sortingOrder, ignoreViewportUpdate);
+  }
+  /**
+   * Applies sorting requested by a sortable header click.
+   *
+   * @param column - Column that initiated sorting.
+   * @param additive - If true, add/remove this column from the current multi-sort state.
+   */
+  headerclick(column, additive) {
+    var _a;
+    const columnProp = column.prop;
+    let order = getNextOrder((_a = this.sorting) === null || _a === void 0 ? void 0 : _a[columnProp]);
+    const beforeEvent = this.emit("beforesorting", { column, order, additive });
+    if (beforeEvent.defaultPrevented) {
+      return;
+    }
+    order = beforeEvent.detail.order;
+    const beforeApplyEvent = this.emit("beforesortingapply", {
+      column: beforeEvent.detail.column,
+      order,
+      additive
+    });
+    if (beforeApplyEvent.defaultPrevented) {
+      return;
+    }
+    const cmp = getComparer(beforeApplyEvent.detail.column, beforeApplyEvent.detail.order);
+    this.applyHeaderSorting(beforeApplyEvent.detail.column, beforeApplyEvent.detail.additive, order, cmp);
+    this.startSorting(this.sorting, this.sortingFunc, this.sortingColumns, this.sortingOrder);
+  }
+  /**
+   * Applies sorting state produced by a header click.
+   */
+  applyHeaderSorting(column, additive, order, cmp) {
+    if (!additive) {
+      this.setSortingState(order ? {
+        sorting: { [column.prop]: order },
+        sortingFunc: { [column.prop]: cmp },
+        sortingColumns: { [column.prop]: column },
+        sortingOrder: [column.prop]
+      } : this.createSortingState());
+      return;
+    }
+    const state = this.createSortingState(true);
+    if (order) {
+      this.setColumnSorting(state, column.prop, order, cmp, column);
+    } else {
+      this.clearColumnSorting(state, column.prop);
+    }
+    this.setSortingState(state);
+  }
+  runSorting(order, comparison, sortingColumns, sortingOrder, ignoreViewportUpdate) {
+    var _a, _b;
+    if (typeof sortingColumns === "boolean") {
+      this.sort(order, comparison, void 0, void 0, void 0, sortingColumns);
+      (_a = this.sortingPromise) === null || _a === void 0 ? void 0 : _a.call(this);
+      this.sortingPromise = null;
+      return;
+    }
+    this.sort(order, comparison, sortingColumns, sortingOrder, void 0, ignoreViewportUpdate);
+    (_b = this.sortingPromise) === null || _b === void 0 ? void 0 : _b.call(this);
+    this.sortingPromise = null;
+  }
+  sort(sorting, sortingFunc, sortingColumns, sortingOrder, types = rowTypes, ignoreViewportUpdate = false) {
+    let activeSortingColumns;
+    let activeSortingOrder;
+    let activeTypes = types;
+    let activeIgnoreViewportUpdate = ignoreViewportUpdate;
+    if (Array.isArray(sortingColumns)) {
+      activeTypes = sortingColumns;
+      activeIgnoreViewportUpdate = typeof sortingOrder === "boolean" ? sortingOrder : false;
+    } else {
+      activeSortingColumns = sortingColumns;
+      activeSortingOrder = Array.isArray(sortingOrder) ? sortingOrder : void 0;
+    }
+    if (!Object.keys(sorting || {}).length) {
+      for (let type of activeTypes) {
+        this.resetSortingForStore(type);
+      }
+    } else {
+      for (let type of activeTypes) {
+        this.applySortingForStore(type, sorting, sortingFunc, activeSortingColumns, activeSortingOrder, activeIgnoreViewportUpdate);
+      }
+    }
+    columnTypes.forEach((type) => {
+      this.providers.column.dataSources[type].refresh();
+    });
+    const afterSortingDetail = {
+      sorting: hasActiveSorting(sorting) ? sorting : void 0,
+      sortingColumns: activeSortingColumns,
+      sortingOrder: activeSortingOrder,
+      types: activeTypes
+    };
+    this.emit("aftersortingapply", afterSortingDetail);
+  }
+};
+function doCollapse(pIndex, source) {
+  const model = source[pIndex];
+  const collapseValue = model[PSEUDO_GROUP_ITEM_VALUE];
+  const trimmed = {};
+  let i = pIndex + 1;
+  const total = source.length;
+  while (i < total) {
+    const currentModel = source[i];
+    if (isGrouping(currentModel)) {
+      const currentValue = currentModel[PSEUDO_GROUP_ITEM_VALUE];
+      if (!currentValue.length || !currentValue.startsWith(collapseValue + ",")) {
+        break;
+      }
+      currentModel[GROUP_EXPANDED] = false;
+    }
+    trimmed[i++] = true;
+  }
+  model[GROUP_EXPANDED] = false;
+  return { trimmed };
+}
+function doExpand(vIndex, source, rowItemsIndexes) {
+  const physicalIndex = rowItemsIndexes[vIndex];
+  const model = source[physicalIndex];
+  const currentGroup = getParsedGroup(model[PSEUDO_GROUP_ITEM_ID]);
+  const trimmed = {};
+  if (!currentGroup) {
+    return { trimmed };
+  }
+  const groupItems = [];
+  model[GROUP_EXPANDED] = true;
+  let i = physicalIndex + 1;
+  const total = source.length;
+  let groupLevelOnly = 0;
+  while (i < total) {
+    const currentModel = source[i];
+    const isGroup = isGrouping(currentModel);
+    if (isGroup) {
+      if (!isSameGroup(currentGroup, model, currentModel)) {
+        break;
+      } else if (!groupLevelOnly) {
+        groupLevelOnly = currentModel[GROUP_DEPTH];
+      }
+    }
+    if (!groupLevelOnly || isGroup && groupLevelOnly === currentModel[GROUP_DEPTH]) {
+      trimmed[i] = false;
+      groupItems.push(i);
+    }
+    i++;
+  }
+  const result = {
+    trimmed
+  };
+  if (groupItems.length) {
+    const items = [...rowItemsIndexes];
+    items.splice(vIndex + 1, 0, ...groupItems);
+    result.items = items;
+  }
+  return result;
+}
+var TRIMMED_GROUPING = "grouping";
+function convertTrimmedIndex(initialIndex, firstLevelMap, secondLevelMap) {
+  const sourceIndex = Number.parseInt(initialIndex, 10);
+  const firstConversionIndex = firstLevelMap[sourceIndex];
+  if (!secondLevelMap) {
+    return firstConversionIndex;
+  }
+  const secondConversionKey = typeof firstConversionIndex === "number" ? firstConversionIndex : sourceIndex;
+  return secondLevelMap[secondConversionKey];
+}
+function processDoubleConversionTrimmed(initiallyTrimed, firstLevelMap, secondLevelMap) {
+  const trimemedOptionsToUpgrade = {};
+  for (let type in initiallyTrimed) {
+    if (type === TRIMMED_GROUPING) {
+      continue;
+    }
+    const items = initiallyTrimed[type];
+    const newItems = {};
+    for (let initialIndex in items) {
+      if (!items[initialIndex]) {
+        continue;
+      }
+      const newConversionIndex = convertTrimmedIndex(initialIndex, firstLevelMap, secondLevelMap);
+      if (typeof newConversionIndex !== "number") {
+        continue;
+      }
+      newItems[newConversionIndex] = true;
+    }
+    trimemedOptionsToUpgrade[type] = newItems;
+  }
+  return trimemedOptionsToUpgrade;
+}
+function hasVisibleGroupItems(source, trimmed, groupIndex) {
+  var _a;
+  const depth = (_a = source[groupIndex]) === null || _a === void 0 ? void 0 : _a[GROUP_DEPTH];
+  if (depth == null) {
+    return false;
+  }
+  for (let i = groupIndex + 1; i < source.length; i++) {
+    const model = source[i];
+    if (isGrouping(model)) {
+      if (model[GROUP_DEPTH] <= depth) {
+        break;
+      }
+      continue;
+    }
+    if (!trimmed[i]) {
+      return true;
+    }
+  }
+  return false;
+}
+function filterOutEmptyGroupRows(source, filterTrimmed) {
+  const trimmed = Object.assign({}, filterTrimmed);
+  source.forEach((model, index) => {
+    if (!isGrouping(model)) {
+      return;
+    }
+    if (hasVisibleGroupItems(source, trimmed, index)) {
+      delete trimmed[index];
+    } else {
+      trimmed[index] = true;
+    }
+  });
+  return trimmed;
+}
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s)
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+      t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+var GroupingRowPlugin = class extends BasePlugin {
+  getStore(type = GROUPING_ROW_TYPE) {
+    return this.providers.data.stores[type].store;
+  }
+  constructor(revogrid, providers) {
+    super(revogrid, providers);
+  }
+  // befoce cell focus
+  onFocus(e) {
+    if (isGrouping(e.detail.model)) {
+      e.preventDefault();
+    }
+  }
+  // expand event triggered
+  onExpand({ virtualIndex }) {
+    const { source } = getSource(this.getStore().get("source"), this.getStore().get("proxyItems"));
+    let newTrimmed = this.getStore().get("trimmed")[TRIMMED_GROUPING];
+    let i = getPhysical(this.getStore(), virtualIndex);
+    const isExpanded = getExpanded(source[i]);
+    if (!isExpanded) {
+      const { trimmed, items } = doExpand(virtualIndex, source, this.getStore().get("items"));
+      newTrimmed = Object.assign(Object.assign({}, newTrimmed), trimmed);
+      if (items) {
+        setItems(this.getStore(), items);
+      }
+    } else {
+      const { trimmed } = doCollapse(i, source);
+      newTrimmed = Object.assign(Object.assign({}, newTrimmed), trimmed);
+      this.revogrid.clearFocus();
+    }
+    this.getStore().set("source", source);
+    this.revogrid.addTrimmed(newTrimmed, TRIMMED_GROUPING);
+  }
+  setColumnGrouping(cols) {
+    if (cols === null || cols === void 0 ? void 0 : cols.length) {
+      cols[0][PSEUDO_GROUP_COLUMN] = true;
+      return true;
+    }
+    return false;
+  }
+  setColumns({ columns }) {
+    for (let type of columnTypes) {
+      if (this.setColumnGrouping(columns[type])) {
+        break;
+      }
+    }
+  }
+  // evaluate drag between groups
+  onDrag(e) {
+    const { from, to } = e.detail;
+    const isDown = to - from >= 0;
+    const { source } = getSource(this.getStore().get("source"), this.getStore().get("proxyItems"));
+    const items = this.getStore().get("items");
+    let i = isDown ? from : to;
+    const end = isDown ? to : from;
+    for (; i < end; i++) {
+      const model = source[items[i]];
+      const isGroup = isGrouping(model);
+      if (isGroup) {
+        e.preventDefault();
+        return;
+      }
+    }
+  }
+  beforeTrimmedApply(trimmed, type) {
+    if (type === FILTER_TRIMMED_TYPE) {
+      const source = this.getStore().get("source");
+      const updatedTrimmed = filterOutEmptyGroupRows(source, trimmed);
+      Object.keys(trimmed).forEach((index) => delete trimmed[Number.parseInt(index, 10)]);
+      Object.assign(trimmed, updatedTrimmed);
+    }
+  }
+  beforeFilterTrimmed(trimmed) {
+    const source = this.getStore().get("source");
+    return filterOutEmptyGroupRows(source, trimmed);
+  }
+  isSortingRunning() {
+    const sortingPlugin = this.providers.plugins.getByClass(SortingPlugin);
+    return !!(sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.sortingPromise);
+  }
+  /**
+   * Returns grouping options for regrouping that must preserve current UI state.
+   *
+   * `expandedAll` and config `prevExpanded` are initial/config instructions.
+   * Reusing them after sorting would reopen groups the user collapsed before
+   * sorting instead of using the current grouped source state.
+   */
+  getCurrentExpandedOptions() {
+    var _a;
+    const _b = (_a = this.options) !== null && _a !== void 0 ? _a : {}, options = __rest(_b, ["expandedAll", "prevExpanded"]);
+    return options;
+  }
+  /**
+   * Starts global source update with group clearing and applying new one
+   * Initiated when need to reapply grouping
+   */
+  doSourceUpdate(options) {
+    var _a, _b;
+    const store = this.getStore();
+    const { source, prevExpanded, oldNewIndexes } = getSource(store.get("source"), store.get("proxyItems"), true);
+    const expanded = Object.assign({ prevExpanded }, options);
+    const { sourceWithGroups, depth, trimmed, oldNewIndexMap } = gatherGrouping(source, (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.props) !== null && _b !== void 0 ? _b : [], expanded);
+    const customRenderer = options === null || options === void 0 ? void 0 : options.groupLabelTemplate;
+    const cellRenderer = options === null || options === void 0 ? void 0 : options.groupCellTemplate;
+    this.providers.data.setData(sourceWithGroups, GROUPING_ROW_TYPE, this.revogrid.disableVirtualY, { depth, customRenderer, cellRenderer }, true);
+    this.updateTrimmed(trimmed, oldNewIndexes !== null && oldNewIndexes !== void 0 ? oldNewIndexes : {}, oldNewIndexMap, sourceWithGroups);
+  }
+  /**
+   * Apply grouping on data set
+   * Clear grouping from source
+   * If source came from other plugin
+   */
+  onDataSet(data) {
+    var _a, _b, _c;
+    let preservedExpanded = {};
+    if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.preserveGroupingOnUpdate) !== false) {
+      let { prevExpanded } = getSource(this.getStore().get("source"), this.getStore().get("proxyItems"), true);
+      preservedExpanded = prevExpanded;
+    }
+    const source = data.source.filter((s) => !isGrouping(s));
+    const options = Object.assign(Object.assign({}, this.options), { prevExpanded: preservedExpanded });
+    const { sourceWithGroups, depth, trimmed, oldNewIndexMap } = gatherGrouping(source, (_c = (_b = this.options) === null || _b === void 0 ? void 0 : _b.props) !== null && _c !== void 0 ? _c : [], options);
+    data.source = sourceWithGroups;
+    this.providers.data.setGrouping({
+      depth,
+      customRenderer: options.groupLabelTemplate,
+      cellRenderer: options.groupCellTemplate
+    });
+    this.updateTrimmed(trimmed, oldNewIndexMap, void 0, sourceWithGroups);
+  }
+  /**
+   * External call to apply grouping. Called by revogrid when prop changed.
+   */
+  setGrouping(options) {
+    var _a, _b;
+    this.clearSubscriptions();
+    this.options = options;
+    if (!((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.length)) {
+      this.clearGrouping();
+      return;
+    }
+    const store = this.getStore();
+    const { source } = getSource(store.get("source"), store.get("proxyItems"));
+    if (source.length) {
+      this.doSourceUpdate(Object.assign({}, options));
+    }
+    for (let t of columnTypes) {
+      if (this.setColumnGrouping(this.providers.column.getColumns(t))) {
+        this.providers.column.refreshByType(t);
+        break;
+      }
+    }
+    this.addEventListener("beforesourceset", ({ detail }) => {
+      var _a2, _b2, _c;
+      if (!(((_b2 = (_a2 = this.options) === null || _a2 === void 0 ? void 0 : _a2.props) === null || _b2 === void 0 ? void 0 : _b2.length) && ((_c = detail === null || detail === void 0 ? void 0 : detail.source) === null || _c === void 0 ? void 0 : _c.length))) {
+        return;
+      }
+      if (this.isSortingRunning()) {
+        return;
+      }
+      this.onDataSet(detail);
+    });
+    this.addEventListener("beforecolumnsset", ({ detail }) => {
+      this.setColumns(detail);
+    });
+    this.addEventListener("beforetrimmed", ({ detail: { trimmed, trimmedType } }) => this.beforeTrimmedApply(trimmed, trimmedType));
+    this.addEventListener("beforefiltertrimmed", ({ detail }) => {
+      detail.itemsToFilter = this.beforeFilterTrimmed(detail.itemsToFilter);
+    });
+    this.addEventListener("aftersortingapply", () => {
+      var _a2, _b2;
+      if (!((_b2 = (_a2 = this.options) === null || _a2 === void 0 ? void 0 : _a2.props) === null || _b2 === void 0 ? void 0 : _b2.length)) {
+        return;
+      }
+      this.doSourceUpdate(this.getCurrentExpandedOptions());
+    });
+    this.addEventListener("beforecellfocus", (e) => this.onFocus(e));
+    this.addEventListener("roworderchanged", (e) => this.onDrag(e));
+    this.addEventListener(GROUP_EXPAND_EVENT, (e) => this.onExpand(e.detail));
+  }
+  // clear grouping
+  clearGrouping() {
+    columnTypes.forEach((t) => {
+      const cols = this.providers.column.getColumns(t);
+      let deleted = false;
+      cols.forEach((c) => {
+        if (isGroupingColumn(c)) {
+          delete c[PSEUDO_GROUP_COLUMN];
+          deleted = true;
+        }
+      });
+      if (deleted) {
+        this.providers.column.refreshByType(t);
+      }
+    });
+    const { source, oldNewIndexes } = getSource(this.getStore().get("source"), this.getStore().get("proxyItems"), true);
+    this.providers.data.setData(source, GROUPING_ROW_TYPE, this.revogrid.disableVirtualY, void 0, true);
+    this.updateTrimmed(void 0, void 0, oldNewIndexes, source);
+  }
+  updateTrimmed(trimmedGroup = {}, firstLevelMap = {}, secondLevelMap, source = this.getStore().get("source")) {
+    const trimemedOptionsToUpgrade = processDoubleConversionTrimmed(this.getStore().get("trimmed"), firstLevelMap, secondLevelMap);
+    for (let type in trimemedOptionsToUpgrade) {
+      if (type === FILTER_TRIMMED_TYPE) {
+        trimemedOptionsToUpgrade[type] = filterOutEmptyGroupRows(source, trimemedOptionsToUpgrade[type]);
+      }
+      this.revogrid.addTrimmed(trimemedOptionsToUpgrade[type], type);
+    }
+    this.revogrid.addTrimmed(Object.assign({}, trimmedGroup), TRIMMED_GROUPING);
+  }
+};
+var COLUMN_DRAG_CLASS = "column-drag-start";
+var ColumnOrderHandler = class {
+  constructor() {
+    this.offset = 0;
+  }
+  renderAutoscroll(_, parent) {
+    if (!parent) {
+      return;
+    }
+    this.autoscrollEl = document.createElement("div");
+    this.autoscrollEl.classList.add("drag-auto-scroll-y");
+    parent.appendChild(this.autoscrollEl);
+  }
+  autoscroll(pos, dataContainerSize, direction = "translateX") {
+    if (!this.autoscrollEl) {
+      return;
+    }
+    const helperOffset = 10;
+    const maxScroll = Math.min(pos + helperOffset, dataContainerSize - 3);
+    this.autoscrollEl.style.transform = `${direction}(${maxScroll}px)`;
+    this.autoscrollEl.scrollIntoView({
+      block: "nearest",
+      inline: "nearest"
+    });
+  }
+  start(e, { dataEl, gridRect, scrollEl, gridEl }, dir = "left") {
+    gridEl.classList.add(COLUMN_DRAG_CLASS);
+    const scrollContainerRect = scrollEl.getBoundingClientRect();
+    if (scrollContainerRect) {
+      this.offset = scrollContainerRect[dir] - gridRect[dir];
+    }
+    this.renderAutoscroll(e, dataEl);
+  }
+  stop(gridEl) {
+    var _a;
+    gridEl.classList.remove(COLUMN_DRAG_CLASS);
+    if (this.element) {
+      this.element.hidden = true;
+    }
+    this.offset = 0;
+    (_a = this.autoscrollEl) === null || _a === void 0 ? void 0 : _a.remove();
+    this.autoscrollEl = void 0;
+  }
+  showHandler(pos, size, direction = "translateX") {
+    if (!this.element) {
+      return;
+    }
+    if (this.offset) {
+      pos = Math.max(pos, this.offset);
+    }
+    pos = Math.min(pos, size);
+    this.element.style.transform = `${direction}(${pos}px)`;
+    this.element.hidden = false;
+  }
+  render() {
+    const el = this.element = document.createElement("div");
+    el.classList.add("drag-position-y");
+    el.hidden = true;
+    return el;
+  }
+};
+var COLUMN_CLICK = ON_COLUMN_CLICK;
+var COLUMN_DRAG_MOVE_EVENT = "columndragmousemove";
+var COLUMN_DRAG_END_EVENT = "columndragend";
+var BEFORE_COLUMN_DRAG_END_EVENT = "beforecolumndragend";
+var COLUMN_DRAG_START_EVENT = "columndragstart";
+var ColumnMovePlugin = class extends BasePlugin {
+  constructor(revogrid, providers) {
+    super(revogrid, providers);
+    this.moveFunc = debounce((e) => this.doMove(e), 5);
+    this.preventHeaderClickAfterDrag = (event) => {
+      if (!this.preventNextHeaderClick) {
+        return;
+      }
+      this.preventNextHeaderClick = false;
+      event.preventDefault();
+    };
+    this.staticDragData = null;
+    this.dragData = null;
+    this.columnDragMoved = false;
+    this.preventNextHeaderClick = false;
+    this.localSubscriptions = {};
+    this.orderUi = new ColumnOrderHandler();
+    revogrid.appendChild(this.orderUi.render());
+    revogrid.classList.add("column-draggable");
+    this.localSubscriptions["mouseleave"] = {
+      target: document,
+      callback: (e) => this.onMouseOut(e)
+    };
+    this.localSubscriptions["mouseup"] = {
+      target: document,
+      callback: (e) => this.onMouseUp(e)
+    };
+    this.localSubscriptions["mousemove"] = {
+      target: document,
+      callback: (e) => this.move(e)
+    };
+    this.addEventListener(COLUMN_CLICK, ({ detail }) => this.dragStart(detail));
+    this.revogrid.addEventListener("beforeheaderclick", this.preventHeaderClickAfterDrag, { capture: true });
+  }
+  dragStart({ event, data }) {
+    if (event.defaultPrevented) {
+      return;
+    }
+    this.preventNextHeaderClick = false;
+    const { defaultPrevented } = dispatch(this.revogrid, COLUMN_DRAG_START_EVENT, data);
+    if (defaultPrevented) {
+      return;
+    }
+    this.clearOrder();
+    const { mouseleave, mouseup, mousemove } = this.localSubscriptions;
+    mouseleave.target.addEventListener("mouseleave", mouseleave.callback);
+    mouseup.target.addEventListener("mouseup", mouseup.callback);
+    const dataEl = event.target.closest("revogr-header");
+    const scrollEl = event.target.closest("revogr-viewport-scroll");
+    if (!dataEl || !scrollEl) {
+      return;
+    }
+    if (isColGrouping(data) || data.providers.type === "rowHeaders") {
+      return;
+    }
+    const cols = this.getDimension(data.pin || "rgCol");
+    const gridRect = this.revogrid.getBoundingClientRect();
+    const elRect = dataEl.getBoundingClientRect();
+    const startItem = getItemByPosition(cols, getLeftRelative(event.x, gridRect.left, elRect.left - gridRect.left) + (cols.renderOffset || 0));
+    this.staticDragData = {
+      startPos: event.x,
+      startItem,
+      pin: data.pin,
+      dataEl,
+      scrollEl,
+      gridEl: this.revogrid,
+      cols
+    };
+    this.dragData = this.getData(this.staticDragData, []);
+    mousemove.target.addEventListener("mousemove", mousemove.callback);
+    this.orderUi.start(event, Object.assign(Object.assign({}, this.dragData), this.staticDragData));
+  }
+  doMove(e) {
+    if (!this.staticDragData) {
+      return;
+    }
+    const dragData = this.dragData = this.getData(this.staticDragData, []);
+    if (!dragData) {
+      return;
+    }
+    const start = this.staticDragData.startPos;
+    if (Math.abs(start - e.x) > 10) {
+      const x = getLeftRelative(e.x, this.dragData.gridRect.left, this.dragData.scrollOffset);
+      const rgCol = getItemByPosition(this.staticDragData.cols, x + (this.staticDragData.cols.renderOffset || 0));
+      this.orderUi.autoscroll(x, dragData.elRect.width);
+      if (rgCol.itemIndex >= this.staticDragData.cols.count) {
+        return;
+      }
+      this.orderUi.showHandler(getColumnDragPosition(rgCol, this.staticDragData.startItem, this.staticDragData.cols.renderOffset || 0, dragData.scrollOffset), dragData.gridRect.width);
+    }
+  }
+  move(e) {
+    if (this.staticDragData && Math.abs(this.staticDragData.startPos - e.x) > 10) {
+      this.columnDragMoved = true;
+    }
+    dispatch(this.revogrid, COLUMN_DRAG_MOVE_EVENT, e);
+    this.moveFunc(e);
+  }
+  onMouseOut(_) {
+    this.clearOrder();
+  }
+  onMouseUp(e) {
+    const suppressClick = this.columnDragMoved;
+    if (this.dragData && this.staticDragData) {
+      let relativePos = getLeftRelative(e.x, this.dragData.gridRect.left, this.dragData.scrollOffset);
+      if (relativePos < 0) {
+        relativePos = 0;
+      }
+      const newPosition = getItemByPosition(this.staticDragData.cols, relativePos + (this.staticDragData.cols.renderOffset || 0));
+      const store = this.providers.column.stores[this.dragData.type].store;
+      const source = store.get("source");
+      const newItems = [...store.get("items")];
+      const { defaultPrevented: stopDrag } = dispatch(this.revogrid, BEFORE_COLUMN_DRAG_END_EVENT, Object.assign(Object.assign({}, this.staticDragData), { startPosition: this.staticDragData.startItem, newPosition, newItem: source[newItems[this.staticDragData.startItem.itemIndex]] }));
+      if (!stopDrag) {
+        const prevItems = [...newItems];
+        const toMove = newItems.splice(this.staticDragData.startItem.itemIndex, 1);
+        newItems.splice(newPosition.itemIndex, 0, ...toMove);
+        store.set("items", newItems);
+        this.providers.dimension.updateSizesPositionByNewDataIndexes(this.dragData.type, newItems, prevItems);
+      }
+      dispatch(this.revogrid, COLUMN_DRAG_END_EVENT, this.getData(this.staticDragData, newItems, source));
+    }
+    if (suppressClick) {
+      this.preventNextHeaderClick = !!e.target.closest("revogr-header");
+    }
+    this.clearOrder();
+  }
+  clearLocalSubscriptions() {
+    forEach(this.localSubscriptions, ({ target, callback }, key) => target.removeEventListener(key, callback));
+  }
+  clearOrder() {
+    this.staticDragData = null;
+    this.dragData = null;
+    this.columnDragMoved = false;
+    this.clearLocalSubscriptions();
+    this.orderUi.stop(this.revogrid);
+  }
+  /**
+   * Clearing subscription
+   */
+  clearSubscriptions() {
+    super.clearSubscriptions();
+    this.clearLocalSubscriptions();
+    this.revogrid.removeEventListener("beforeheaderclick", this.preventHeaderClickAfterDrag, { capture: true });
+  }
+  getData({ gridEl, dataEl, pin }, order, source = []) {
+    const gridRect = gridEl.getBoundingClientRect();
+    const elRect = dataEl.getBoundingClientRect();
+    const scrollOffset = elRect.left - gridRect.left;
+    return {
+      columns: order.map((index) => source[index]).filter(Boolean),
+      elRect,
+      gridRect,
+      order,
+      type: pin || "rgCol",
+      scrollOffset
+    };
+  }
+  getDimension(type) {
+    return this.providers.dimension.stores[type].getCurrentState();
+  }
+};
+function getLeftRelative(absoluteX, gridPos, offset) {
+  return absoluteX - gridPos - offset;
+}
+function getColumnDragPosition(targetItem, startItem, renderOffset, scrollOffset) {
+  const insertionEdge = startItem.itemIndex > targetItem.itemIndex ? targetItem.start : targetItem.end;
+  return insertionEdge - renderOffset + scrollOffset;
+}
+
+// ../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/revo-grid.entry.js
+var ColumnDataProvider = class {
+  get stores() {
+    return this.dataSources;
+  }
+  constructor() {
+    this.collection = null;
+    this.dataSources = columnTypes.reduce((sources, k) => {
+      sources[k] = new DataStore(k);
+      return sources;
+    }, {});
+  }
+  column(c, type = "rgCol") {
+    return this.getColumn(c, type);
+  }
+  getColumn(virtualIndex, type) {
+    return getSourceItem(this.dataSources[type].store, virtualIndex);
+  }
+  getRawColumns() {
+    return reduce(this.dataSources, (result, item, type) => {
+      result[type] = item.store.get("source");
+      return result;
+    }, {
+      rgCol: [],
+      colPinStart: [],
+      colPinEnd: []
+    });
+  }
+  getColumns(type = "all") {
+    const columnsByType = this.getRawColumns();
+    if (type !== "all") {
+      return columnsByType[type];
+    }
+    return columnTypes.reduce((r, t) => [...r, ...columnsByType[t]], []);
+  }
+  getColumnIndexByProp(prop, type) {
+    return getSourceItemVirtualIndexByProp(this.dataSources[type].store, prop);
+  }
+  getColumnByProp(prop) {
+    var _a;
+    return (_a = this.collection) === null || _a === void 0 ? void 0 : _a.columnByProp[prop];
+  }
+  refreshByType(type) {
+    this.dataSources[type].refresh();
+  }
+  /**
+   * Main method to set columns
+   */
+  setColumns(data) {
+    columnTypes.forEach((k) => {
+      this.dataSources[k].updateData(data.columns[k], {
+        // max depth level
+        depth: data.maxLevel,
+        // groups
+        groups: data.columnGrouping[k].reduce((res, g) => {
+          if (!res[g.level]) {
+            res[g.level] = [];
+          }
+          res[g.level].push(g);
+          return res;
+        }, {})
+      });
+    });
+    this.collection = data;
+    return data;
+  }
+  /**
+   * Used in plugins
+   * Modify columns in store
+   */
+  updateColumns(updatedColumns) {
+    const columnByKey = updatedColumns.reduce((res, c) => {
+      const type = getColumnType(c);
+      if (!res[type]) {
+        res[type] = {};
+      }
+      res[type][c.prop] = c;
+      return res;
+    }, {});
+    const colByIndex = {};
+    for (const t in columnByKey) {
+      if (!columnByKey.hasOwnProperty(t)) {
+        continue;
+      }
+      const type = t;
+      const colsToUpdate = columnByKey[type];
+      const sourceItems = this.dataSources[type].store.get("source");
+      colByIndex[type] = {};
+      for (let i = 0; i < sourceItems.length; i++) {
+        const column = sourceItems[i];
+        const colToUpdateIfExists = colsToUpdate === null || colsToUpdate === void 0 ? void 0 : colsToUpdate[column.prop];
+        if (colToUpdateIfExists) {
+          colByIndex[type][i] = colToUpdateIfExists;
+        }
+      }
+    }
+    for (const t in colByIndex) {
+      if (!colByIndex.hasOwnProperty(t)) {
+        continue;
+      }
+      const type = t;
+      setSourceByPhysicalIndex(this.dataSources[type].store, colByIndex[type] || {});
+    }
+  }
+  updateColumn(column, index) {
+    const type = getColumnType(column);
+    setSourceByVirtualIndex(this.dataSources[type].store, { [index]: column });
+  }
+};
+var DataProvider = class {
+  constructor(dimensionProvider) {
+    this.dimensionProvider = dimensionProvider;
+    this.stores = reduce(rowTypes, (sources, k) => {
+      sources[k] = new DataStore(k);
+      return sources;
+    }, {});
+  }
+  /**
+   * Replaces the data source for a row type and synchronizes the related dimension metadata.
+   *
+   * `rgRow` updates also refresh the virtual row model unless `disableVirtualRows` is set.
+   * Pinned row types skip virtual row recalculation because they are rendered directly.
+   *
+   * @param data Full source data assigned to the target row store.
+   * @param type Row collection to update. Defaults to the main body rows.
+   * @param disableVirtualRows Prevents recalculating virtual rows for the main row store.
+   * @param grouping Optional grouping metadata applied together with the new data set.
+   * @param silent Preserves the current trimmed state instead of resetting it during the update.
+   * @param preserveTrimmed Re-applies current trimmed indexes after a silent update.
+   * @returns The same `data` array that was provided to the method.
+   */
+  setData(data, type = "rgRow", disableVirtualRows = false, grouping, silent = false, preserveTrimmed = false) {
+    this.stores[type].updateData([...data], grouping, silent, preserveTrimmed);
+    const noVirtual = type !== "rgRow" || disableVirtualRows;
+    this.dimensionProvider.setData(data.length, type, noVirtual);
+    return data;
+  }
+  getModel(virtualIndex, type = "rgRow") {
+    const store = this.stores[type].store;
+    return getSourceItem(store, virtualIndex);
+  }
+  changeOrder({ rowType = "rgRow", from, to }) {
+    const storeService = this.stores[rowType];
+    const newItemsOrder = [...storeService.store.get("proxyItems")];
+    const prevItems = storeService.store.get("items");
+    const toMove = newItemsOrder.splice(
+      newItemsOrder.indexOf(prevItems[from]),
+      // get index in proxy
+      1
+    );
+    const targetItem = prevItems[from < to ? to + 1 : to];
+    const targetIndex = targetItem === void 0 ? newItemsOrder.length : newItemsOrder.indexOf(targetItem);
+    newItemsOrder.splice(targetIndex, 0, ...toMove);
+    storeService.setData({
+      proxyItems: newItemsOrder
+    });
+    const newItems = storeService.store.get("items");
+    this.dimensionProvider.updateSizesPositionByNewDataIndexes(rowType, newItems, prevItems);
+  }
+  setCellData({ type, rowIndex, prop, val }, mutate = true) {
+    const model = this.getModel(rowIndex, type);
+    model[prop] = val;
+    this.stores[type].setSourceData({ [rowIndex]: model }, mutate);
+  }
+  setRangeData(data, type) {
+    const items = {};
+    for (let rowIndex in data) {
+      const oldModel = items[rowIndex] = getSourceItem(this.stores[type].store, parseInt(rowIndex, 10));
+      if (!oldModel) {
+        continue;
+      }
+      for (let prop in data[rowIndex]) {
+        oldModel[prop] = data[rowIndex][prop];
+      }
+    }
+    this.stores[type].setSourceData(items);
+  }
+  refresh(type = "all") {
+    if (isRowType(type)) {
+      this.refreshItems(type);
+    }
+    rowTypes.forEach((t) => this.refreshItems(t));
+  }
+  refreshItems(type = "rgRow") {
+    const items = this.stores[type].store.get("items");
+    this.stores[type].setData({ items: [...items] });
+  }
+  setGrouping({ depth, customRenderer, cellRenderer }, type = "rgRow") {
+    this.stores[type].setData({
+      groupingDepth: depth,
+      groupingCustomRenderer: customRenderer,
+      groupingCellRenderer: cellRenderer
+    });
+  }
+  setTrimmed(trimmed, type = "rgRow") {
+    const store = this.stores[type];
+    store.addTrimmed(trimmed);
+    this.dimensionProvider.setTrimmed(trimmed, type);
+    if (type === "rgRow") {
+      this.dimensionProvider.setData(getVisibleSourceItem(store.store).length, type);
+    }
+  }
+};
+var DEFAULT_VIRTUAL_X = ["rgCol"];
+function isVirtualXDimension(type, disableVirtualX = false, virtualX = DEFAULT_VIRTUAL_X) {
+  return !disableVirtualX && virtualX.includes(type);
+}
+var DimensionProvider = class {
+  constructor(viewports, config) {
+    this.viewports = viewports;
+    const sizeChanged = debounce((k) => config.realSizeChanged(k), RESIZE_INTERVAL);
+    this.stores = [...rowTypes, ...columnTypes].reduce((sources, t) => {
+      sources[t] = new DimensionStore(t);
+      sources[t].store.onChange("realSize", () => sizeChanged(t));
+      return sources;
+    }, {});
+  }
+  /**
+   * Clear old sizes from dimension and viewports
+   * @param type - dimension type
+   * @param count - count of items
+   */
+  clearSize(t, count) {
+    this.stores[t].drop();
+    this.viewports.stores[t].setOriginalSizes(this.stores[t].store.get("originItemSize"));
+    this.setItemCount(count, t);
+  }
+  /**
+   * Apply new custom sizes to dimension and view port
+   * @param type - dimension type
+   * @param sizes - new custom sizes
+   * @param keepOld - keep old sizes merge new with old
+   */
+  setCustomSizes(type, sizes, keepOld = false) {
+    let newSizes = sizes;
+    if (keepOld) {
+      const oldSizes = this.stores[type].store.get("sizes");
+      newSizes = Object.assign(Object.assign({}, oldSizes), sizes);
+    }
+    this.stores[type].setDimensionSize(newSizes);
+    this.setViewPortCoordinate({
+      type,
+      force: true
+    });
+  }
+  setItemCount(realCount, type) {
+    this.viewports.stores[type].setViewport({ realCount });
+    this.stores[type].setStore({ count: realCount });
+  }
+  /**
+   * Apply trimmed items
+   * @param trimmed - trimmed items
+   * @param type
+   */
+  setTrimmed(trimmed, type) {
+    const allTrimmed = gatherTrimmedItems(trimmed);
+    const dimStoreType = this.stores[type];
+    dimStoreType.setStore({ trimmed: allTrimmed });
+    this.setViewPortCoordinate({
+      type,
+      force: true
+    });
+  }
+  /**
+   * Sets dimension data and viewport coordinate
+   * @param itemCount
+   * @param type - dimension type
+   * @param noVirtual - disable virtual data
+   */
+  setData(itemCount, type, noVirtual = false) {
+    this.setItemCount(itemCount, type);
+    if (noVirtual) {
+      const dimension = this.stores[type].getCurrentState();
+      this.viewports.stores[type].setViewport({
+        virtualSize: dimension.realSize
+      });
+    }
+    this.setViewPortCoordinate({
+      type
+    });
+  }
+  /**
+   * Applies new columns to the dimension provider
+   * @param columns - new columns data
+   * @param disableVirtualX - disable virtual data for X axis
+   * @param virtualX - column dimensions that should use virtual data
+   */
+  applyNewColumns(columns, disableVirtualX, keepOld = false, virtualX = DEFAULT_VIRTUAL_X) {
+    for (let type of columnTypes) {
+      if (!keepOld) {
+        this.stores[type].drop();
+      }
+      const items = columns[type];
+      const noVirtual = !isVirtualXDimension(type, disableVirtualX, virtualX);
+      this.stores[type].setStore({ count: items.length });
+      const newSizes = getColumnSizes(items);
+      this.stores[type].setDimensionSize(newSizes);
+      const vpUpdate = {
+        // This triggers drop on realCount change
+        realCount: items.length
+      };
+      if (noVirtual) {
+        vpUpdate.virtualSize = this.stores[type].getCurrentState().realSize;
+      }
+      this.viewports.stores[type].setViewport(vpUpdate);
+      this.setViewPortCoordinate({
+        type
+      });
+    }
+  }
+  /**
+   * Gets the full size of the grid by summing up the sizes of all dimensions
+   * Goes through all dimensions columnTypes (x) and rowTypes (y) and sums up their sizes
+   */
+  getFullSize() {
+    var _a, _b;
+    let x = 0;
+    let y = 0;
+    for (let type of columnTypes) {
+      x += ((_a = this.stores[type]) === null || _a === void 0 ? void 0 : _a.store.get("realSize")) || 0;
+    }
+    for (let type of rowTypes) {
+      y += ((_b = this.stores[type]) === null || _b === void 0 ? void 0 : _b.store.get("realSize")) || 0;
+    }
+    return { y, x };
+  }
+  setViewPortCoordinate({ type, coordinate = this.viewports.stores[type].lastCoordinate, force = false }) {
+    const dimension = this.stores[type].getCurrentState();
+    const viewport = this.viewports.stores[type].store;
+    const clientSize = viewport.get("clientSize");
+    const viewportSize = viewport.get("virtualSize");
+    const scrollDimension = getScrollDimension({
+      contentSize: dimension.realSize,
+      clientSize,
+      virtualSize: viewportSize
+    });
+    const renderCoordinate = Math.min(
+      Math.max(0, coordinate),
+      // prevents negative scroll positions
+      scrollDimension.logicalScrollSize
+    );
+    const renderOffset = clientSize && viewportSize ? scrollDimension.getRenderOffset(renderCoordinate) : 0;
+    this.stores[type].setStore({ renderOffset });
+    this.viewports.stores[type].setViewport({ renderOffset });
+    this.viewports.stores[type].setViewPortCoordinate(coordinate, dimension, force);
+  }
+  getViewPortPos(e) {
+    const dimension = this.stores[e.dimension].getCurrentState();
+    const item = getItemByIndex(dimension, e.coordinate);
+    return item.start;
+  }
+  setSettings(data, dimensionType) {
+    let stores = [];
+    switch (dimensionType) {
+      case "rgCol":
+        stores = columnTypes;
+        break;
+      case "rgRow":
+        stores = rowTypes;
+        break;
+    }
+    for (let s of stores) {
+      this.stores[s].setStore(data);
+    }
+  }
+  updateSizesPositionByNewDataIndexes(type, newItemsOrder, prevItemsOrder = []) {
+    this.stores[type].updateSizesPositionByIndexes(newItemsOrder, prevItemsOrder);
+    this.setViewPortCoordinate({
+      type,
+      force: true
+    });
+  }
+};
+var ViewportProvider = class {
+  constructor() {
+    this.stores = reduce([...rowTypes, ...columnTypes], (sources, k) => {
+      sources[k] = new ViewportStore(k);
+      return sources;
+    }, {});
+  }
+  setViewport(type, data) {
+    this.stores[type].setViewport(data);
+  }
+};
+var DEFAULT_THEME = "default";
+var allowedThemes = [
+  DEFAULT_THEME,
+  "material",
+  "compact",
+  "darkMaterial",
+  "darkCompact"
+];
+var builtInThemeNames = new Set(allowedThemes);
+var builtInThemes = Object.freeze({
+  default: Object.freeze({
+    name: "default",
+    colorScheme: "light",
+    defaultRowSize: 27,
+    tokens: Object.freeze({}),
+    custom: false
+  }),
+  material: Object.freeze({
+    name: "material",
+    colorScheme: "light",
+    defaultRowSize: 42,
+    tokens: Object.freeze({}),
+    custom: false
+  }),
+  compact: Object.freeze({
+    name: "compact",
+    colorScheme: "light",
+    defaultRowSize: 32,
+    tokens: Object.freeze({}),
+    custom: false
+  }),
+  darkMaterial: Object.freeze({
+    name: "darkMaterial",
+    colorScheme: "dark",
+    defaultRowSize: 42,
+    tokens: Object.freeze({}),
+    custom: false
+  }),
+  darkCompact: Object.freeze({
+    name: "darkCompact",
+    colorScheme: "dark",
+    defaultRowSize: 32,
+    tokens: Object.freeze({}),
+    custom: false
+  })
+});
+function isBuiltInTheme(theme) {
+  return builtInThemeNames.has(theme);
+}
+function isPositiveSize(size) {
+  return typeof size === "number" && Number.isFinite(size) && size > 0;
+}
+function getColorScheme(scheme, fallback) {
+  return scheme === "light" || scheme === "dark" ? scheme : fallback;
+}
+function getCssOnlyThemeColorScheme(theme) {
+  return theme.includes("dark") ? "dark" : "light";
+}
+function getThemeTokens(tokens) {
+  if (!tokens || typeof tokens !== "object") {
+    return {};
+  }
+  const result = {};
+  for (const [name, value] of Object.entries(tokens)) {
+    if (Object.hasOwn(themeTokenCssVariables, name) && typeof value === "string" && value.trim()) {
+      result[name] = value;
+    }
+  }
+  return result;
+}
+var ThemeService = class {
+  get theme() {
+    return this.currentTheme;
+  }
+  get rowSize() {
+    return this.customRowSize || this.currentTheme.defaultRowSize;
+  }
+  set rowSize(size) {
+    this.customRowSize = isPositiveSize(size) ? size : 0;
+  }
+  constructor(cfg) {
+    this.currentTheme = Object.assign({}, builtInThemes.default);
+    this.customThemes = /* @__PURE__ */ new Map();
+    this.customRowSize = 0;
+    this.rowSize = cfg.rowSize;
+    this.register("default");
+  }
+  setDefinitions(definitions = []) {
+    const customThemes = /* @__PURE__ */ new Map();
+    if (Array.isArray(definitions)) {
+      for (const definition of definitions) {
+        if (!definition || typeof definition !== "object") {
+          continue;
+        }
+        if (typeof definition.name !== "string" || !definition.name.trim()) {
+          continue;
+        }
+        const name = getTheme(definition.name);
+        if (isBuiltInTheme(name)) {
+          continue;
+        }
+        customThemes.set(name, Object.assign(Object.assign({}, definition), { name }));
+      }
+    }
+    this.customThemes = customThemes;
+  }
+  register(theme) {
+    const name = getTheme(theme);
+    if (isBuiltInTheme(name)) {
+      this.currentTheme = Object.assign(Object.assign({}, builtInThemes[name]), { tokens: {} });
+      return this.currentTheme;
+    }
+    const definition = this.customThemes.get(name);
+    if (!definition) {
+      this.currentTheme = Object.assign(Object.assign({}, builtInThemes.default), { name, colorScheme: getCssOnlyThemeColorScheme(name), tokens: {}, custom: true });
+      return this.currentTheme;
+    }
+    this.currentTheme = this.resolveDefinition(name);
+    return this.currentTheme;
+  }
+  resolveDefinition(name) {
+    const chain = [];
+    const visited = /* @__PURE__ */ new Set();
+    let parentName = name;
+    let validChain = true;
+    while (!isBuiltInTheme(parentName)) {
+      if (visited.has(parentName)) {
+        validChain = false;
+        break;
+      }
+      visited.add(parentName);
+      const definition = this.customThemes.get(parentName);
+      if (!definition) {
+        validChain = false;
+        break;
+      }
+      chain.push(definition);
+      parentName = getTheme(definition.extends);
+    }
+    let resolved = Object.assign(Object.assign({}, validChain && isBuiltInTheme(parentName) ? builtInThemes[parentName] : builtInThemes.default), { tokens: {} });
+    if (validChain) {
+      chain.reverse();
+    }
+    const definitions = validChain ? chain : chain.slice(0, 1);
+    for (const definition of definitions) {
+      resolved = {
+        name: definition.name,
+        colorScheme: getColorScheme(definition.colorScheme, resolved.colorScheme),
+        defaultRowSize: isPositiveSize(definition.defaultRowSize) ? definition.defaultRowSize : resolved.defaultRowSize,
+        tokens: Object.assign(Object.assign({}, resolved.tokens), getThemeTokens(definition.tokens)),
+        custom: true
+      };
+    }
+    return resolved;
+  }
+};
+function getTheme(theme) {
+  const normalizedTheme = typeof theme === "string" ? theme.trim() : "";
+  return normalizedTheme || DEFAULT_THEME;
+}
+function getViewportResizeDimension(colType, dimension) {
+  return dimension === "rgCol" ? colType : dimension;
+}
+function gatherColumnData(data) {
+  const colDimension = data.dimensions[data.colType].store;
+  const realWidth = colDimension.get("realSize");
+  const prop = {
+    contentWidth: realWidth,
+    class: data.colType,
+    contentHeight: data.contentHeight,
+    key: data.colType,
+    colType: data.colType,
+    noHorizontalScrollTransfer: data.noHorizontalScrollTransfer,
+    onResizeviewport: data.onResizeviewport,
+    // set viewport size to real size
+    style: data.fixWidth ? { minWidth: `${realWidth}px` } : void 0
+  };
+  const headerProp = {
+    colData: getVisibleSourceItem(data.colStore),
+    dimensionCol: colDimension,
+    type: data.colType,
+    groups: data.colStore.get("groups"),
+    groupingDepth: data.colStore.get("groupingDepth"),
+    resizeHandler: data.colType === "colPinEnd" ? ["l"] : void 0,
+    onHeaderresize: data.onHeaderresize
+  };
+  return {
+    prop,
+    type: data.colType,
+    position: data.position,
+    headerProp,
+    viewportCol: data.viewports[data.colType].store
+  };
+}
+var ViewportService = class {
+  constructor(config, contentHeight) {
+    var _a;
+    this.config = config;
+    const columns = [];
+    let x = 0;
+    columnTypes.forEach((val) => {
+      const colStore = config.columnProvider.stores[val].store;
+      if (!colStore.get("items").length) {
+        return;
+      }
+      const column = {
+        colType: val,
+        position: { x, y: 1 },
+        contentHeight,
+        // only central column has dynamic width
+        fixWidth: val !== "rgCol",
+        viewports: config.viewportProvider.stores,
+        dimensions: config.dimensionProvider.stores,
+        rowStores: config.dataProvider.stores,
+        noHorizontalScrollTransfer: config.noHorizontalScrollTransfer,
+        colStore,
+        onHeaderresize: (e) => this.onColumnResize(val, e, colStore)
+      };
+      column.onResizeviewport = (e) => {
+        var _a2;
+        const vpState = {
+          clientSize: e.detail.size
+        };
+        const dimension = getViewportResizeDimension(val, e.detail.dimension);
+        const isVirtualColumn = columnTypes.includes(dimension) && isVirtualXDimension(dimension, config.disableVirtualX, config.virtualX);
+        if (dimension === "rgRow" && !config.disableVirtualY || isVirtualColumn) {
+          vpState.virtualSize = e.detail.size;
+        }
+        (_a2 = config.viewportProvider) === null || _a2 === void 0 ? void 0 : _a2.setViewport(dimension, vpState);
+      };
+      const colData = gatherColumnData(column);
+      const columnSelectionStore = this.registerCol(colData.position.x, val);
+      const dataPorts = this.dataViewPort(column).reduce((r, rgRow) => {
+        const segmentSelection = this.registerSegment(rgRow.position, rgRow.lastCell);
+        const rowSelectionStore = this.registerRow(rgRow.position.y, rgRow.type);
+        const rowDef = Object.assign(Object.assign({ colType: val }, rgRow), { rowSelectionStore, selectionStore: segmentSelection.store, onSetrange: (e) => {
+          segmentSelection.setRangeArea(e.detail);
+        }, onSettemprange: (e) => segmentSelection.setTempArea(e.detail), onFocuscell: (e) => {
+          segmentSelection.clearFocus();
+          config.selectionStoreConnector.focus(segmentSelection, e.detail);
+        } });
+        r.push(rowDef);
+        return r;
+      }, []);
+      columns.push(Object.assign(Object.assign({}, colData), {
+        columnSelectionStore,
+        dataPorts
+      }));
+      x++;
+    });
+    this.columns = columns;
+    (_a = this.config.scrollingService) === null || _a === void 0 ? void 0 : _a.unregister();
+  }
+  onColumnResize(type, { detail }, store) {
+    var _a;
+    (_a = this.config.dimensionProvider) === null || _a === void 0 ? void 0 : _a.setCustomSizes(type, detail, true);
+    const changedItems = {};
+    for (const i of Object.keys(detail || {})) {
+      const size = detail[i];
+      const virtualIndex = parseInt(i, 10);
+      const item = getSourceItem(store, virtualIndex);
+      if (item) {
+        changedItems[virtualIndex] = Object.assign(Object.assign({}, item), { size });
+      }
+    }
+    this.config.resize(changedItems);
+  }
+  /** register selection store for Segment */
+  registerSegment(position, lastCell) {
+    const store = this.config.selectionStoreConnector.register(position);
+    store.setLastCell(lastCell);
+    return store;
+  }
+  /** register selection store for Row */
+  registerRow(y, type) {
+    return this.config.selectionStoreConnector.registerRow(y, type).store;
+  }
+  /** register selection store for Column */
+  registerCol(x, type) {
+    return this.config.selectionStoreConnector.registerColumn(x, type).store;
+  }
+  /** Collect Row data */
+  dataViewPort(data) {
+    const slots = {
+      rowPinStart: HEADER_SLOT,
+      rgRow: CONTENT_SLOT,
+      rowPinEnd: FOOTER_SLOT
+    };
+    let y = 0;
+    return rowTypes.reduce((result, type) => {
+      const rgCol = Object.assign(Object.assign({}, data), { position: Object.assign(Object.assign({}, data.position), { y }) });
+      const partition = viewportDataPartition(rgCol, type, slots[type], type !== "rgRow");
+      result.push(partition);
+      y++;
+      return result;
+    }, []);
+  }
+  scrollToCell(cell) {
+    for (let key in cell) {
+      const coordinate = cell[key];
+      if (typeof coordinate === "number") {
+        this.config.scrollingService.proxyScroll({
+          dimension: key === "x" ? "rgCol" : "rgRow",
+          coordinate
+        });
+      }
+    }
+  }
+  /**
+   * Clear current grid focus
+   */
+  clearFocused() {
+    this.config.selectionStoreConnector.clearAll();
+  }
+  clearEdit() {
+    this.config.selectionStoreConnector.setEdit(false);
+  }
+  /**
+   * Collect focused element data
+   */
+  getFocused() {
+    const focused = this.config.selectionStoreConnector.focusedStore;
+    if (!focused) {
+      return null;
+    }
+    const colType = this.config.selectionStoreConnector.storesXToType[focused.position.x];
+    const column = this.config.columnProvider.getColumn(focused.cell.x, colType);
+    const rowType = this.config.selectionStoreConnector.storesYToType[focused.position.y];
+    const model = this.config.dataProvider.getModel(focused.cell.y, rowType);
+    return {
+      column,
+      model,
+      cell: focused.cell,
+      colType,
+      rowType
+    };
+  }
+  getStoreCoordinateByType(colType, rowType) {
+    const stores = this.config.selectionStoreConnector.storesByType;
+    if (typeof stores[colType] === "undefined" || typeof stores[rowType] === "undefined") {
+      return;
+    }
+    return {
+      x: stores[colType],
+      y: stores[rowType]
+    };
+  }
+  setFocus(colType, rowType, start, end) {
+    var _a;
+    const coordinate = this.getStoreCoordinateByType(colType, rowType);
+    if (coordinate) {
+      (_a = this.config.selectionStoreConnector) === null || _a === void 0 ? void 0 : _a.focusByCell(coordinate, start, end);
+    }
+  }
+  getSelectedRange() {
+    const focused = this.config.selectionStoreConnector.focusedStore;
+    if (!focused) {
+      return null;
+    }
+    const colType = this.config.selectionStoreConnector.storesXToType[focused.position.x];
+    const rowType = this.config.selectionStoreConnector.storesYToType[focused.position.y];
+    const range = focused.entity.store.get("range");
+    if (!range) {
+      return null;
+    }
+    return Object.assign(Object.assign({}, range), {
+      colType,
+      rowType
+    });
+  }
+  setEdit(rowIndex, colIndex, colType, rowType) {
+    var _a;
+    const coordinate = this.getStoreCoordinateByType(colType, rowType);
+    if (coordinate) {
+      (_a = this.config.selectionStoreConnector) === null || _a === void 0 ? void 0 : _a.setEditByCell(coordinate, { x: colIndex, y: rowIndex });
+    }
+  }
+};
+var GridScrollingService = class {
+  constructor(setViewport) {
+    this.setViewport = setViewport;
+    this.elements = {};
+  }
+  async proxyScroll(e, key, skipEvent) {
+    var _a;
+    let newEventPromise;
+    let event = e;
+    for (let elKey in skipEvent ? {} : this.elements) {
+      if (e.dimension === "rgCol" && elKey === "headerRow") {
+        continue;
+      } else if (this.isPinnedColumn(key) && e.dimension === "rgCol") {
+        if (elKey === key || !e.delta) {
+          continue;
+        }
+        for (let el of this.elements[elKey]) {
+          if (el.changeScroll) {
+            newEventPromise = el.changeScroll(e);
+          }
+        }
+      } else {
+        for (let el of this.elements[elKey]) {
+          await ((_a = el.setScroll) === null || _a === void 0 ? void 0 : _a.call(el, e));
+        }
+      }
+    }
+    const newEvent = await newEventPromise;
+    if (newEvent) {
+      event = newEvent;
+    }
+    this.setViewport(skipEvent && this.isPinnedColumn(key) ? Object.assign(Object.assign({}, event), { dimension: key }) : event);
+  }
+  /**
+   * Silent scroll update for mobile devices when we have negative scroll top
+   */
+  async scrollSilentService(e, key) {
+    var _a;
+    for (let elKey in this.elements) {
+      if (elKey === key) {
+        continue;
+      }
+      if (columnTypes.includes(key) && (elKey === "headerRow" || columnTypes.includes(elKey))) {
+        for (let el of this.elements[elKey]) {
+          await ((_a = el.changeScroll) === null || _a === void 0 ? void 0 : _a.call(el, e, true));
+        }
+        continue;
+      }
+    }
+  }
+  isPinnedColumn(key) {
+    return !!key && ["colPinStart", "colPinEnd"].indexOf(key) > -1;
+  }
+  registerElements(els) {
+    this.elements = els;
+  }
+  /**
+   * Register new element for farther scroll support
+   * @param el - can be null if holder removed
+   * @param key - element key
+   */
+  registerElement(el, key) {
+    if (!this.elements[key]) {
+      this.elements[key] = [];
+    }
+    if (el) {
+      this.elements[key].push(el);
+    } else if (this.elements[key]) {
+      delete this.elements[key];
+    }
+  }
+  unregister() {
+    this.elements = {};
+  }
+};
+var SelectionStoreConnector = class {
+  constructor() {
+    this.stores = {};
+    this.columnStores = {};
+    this.rowStores = {};
+    this.storesByType = {};
+    this.storesXToType = {};
+    this.storesYToType = {};
+  }
+  get focusedStore() {
+    var _a;
+    for (let y in this.stores) {
+      for (let x in this.stores[y]) {
+        const focused = (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.store.get("focus");
+        if (focused) {
+          return {
+            entity: this.stores[y][x],
+            cell: focused,
+            position: {
+              x: parseInt(x, 10),
+              y: parseInt(y, 10)
+            }
+          };
+        }
+      }
+    }
+    return null;
+  }
+  get edit() {
+    var _a;
+    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get("edit");
+  }
+  get focused() {
+    var _a;
+    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get("focus");
+  }
+  get selectedRange() {
+    var _a;
+    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get("range");
+  }
+  registerColumn(x, type) {
+    this.updateColumnTypeMapping(x, type);
+    if (this.columnStores[x]) {
+      return this.columnStores[x];
+    }
+    this.columnStores[x] = new SelectionStore();
+    return this.columnStores[x];
+  }
+  registerRow(y, type) {
+    if (this.rowStores[y]) {
+      return this.rowStores[y];
+    }
+    this.rowStores[y] = new SelectionStore();
+    this.storesByType[type] = y;
+    this.storesYToType[y] = type;
+    return this.rowStores[y];
+  }
+  /**
+   * Cross store proxy, based on multiple dimensions
+   */
+  register({ x, y }) {
+    if (!this.stores[y]) {
+      this.stores[y] = {};
+    }
+    let store = this.stores[y][x];
+    if (store) {
+      return store;
+    }
+    this.stores[y][x] = store = new SelectionStore();
+    store.onChange("range", (c) => {
+      this.columnStores[x].setRangeArea(c);
+      this.rowStores[y].setRangeArea(c);
+    });
+    store.store.on("dispose", () => this.destroy(x, y));
+    return store;
+  }
+  destroy(x, y) {
+    var _a, _b;
+    (_a = this.columnStores[x]) === null || _a === void 0 ? void 0 : _a.dispose();
+    (_b = this.rowStores[y]) === null || _b === void 0 ? void 0 : _b.dispose();
+    delete this.rowStores[y];
+    delete this.columnStores[x];
+    if (this.storesXToType[x]) {
+      const type = this.storesXToType[x];
+      delete this.storesXToType[x];
+      delete this.storesByType[type];
+    }
+    if (this.storesYToType[y]) {
+      const type = this.storesYToType[y];
+      delete this.storesYToType[y];
+      delete this.storesByType[type];
+    }
+    if (this.stores[y]) {
+      delete this.stores[y][x];
+    }
+    if (!Object.keys(this.stores[y] || {}).length) {
+      delete this.stores[y];
+    }
+  }
+  setEditByCell(storePos, editCell) {
+    this.focusByCell(storePos, editCell, editCell);
+    this.setEdit("");
+  }
+  /**
+   * Sets the next focus cell before the current one.
+   *
+   * @param focus - The cell to set as the next focus.
+   */
+  beforeNextFocusCell(focus) {
+    var _a;
+    if (!this.focusedStore) {
+      return;
+    }
+    const lastCell = this.focusedStore.entity.store.get("lastCell");
+    const next = lastCell && this.getNextStore(focus, this.focusedStore.position, lastCell);
+    (_a = next === null || next === void 0 ? void 0 : next.store) === null || _a === void 0 ? void 0 : _a.setNextFocus(Object.assign(Object.assign({}, focus), next.item));
+  }
+  focusByCell(storePos, start, end) {
+    const store = this.stores[storePos.y][storePos.x];
+    this.focus(store, { focus: start, end });
+  }
+  focus(store, { focus, end }) {
+    const currentStorePointer = this.getCurrentStorePointer(store);
+    if (!currentStorePointer) {
+      return null;
+    }
+    const lastCell = store.store.get("lastCell");
+    const next = lastCell && this.getNextStore(focus, currentStorePointer, lastCell);
+    if (next === null || next === void 0 ? void 0 : next.store) {
+      const item = Object.assign(Object.assign({}, focus), next.item);
+      this.focus(next.store, { focus: item, end: item });
+      return null;
+    }
+    if (lastCell) {
+      focus = cropCellToMax(focus, lastCell);
+      end = cropCellToMax(end, lastCell);
+    }
+    store.setFocus(focus, end);
+    return focus;
+  }
+  /**
+   * Retrieves the current store pointer based on the active store.
+   * Clears focus from all stores except the active one.
+   */
+  getCurrentStorePointer(store) {
+    let currentStorePointer;
+    for (let y in this.stores) {
+      for (let x in this.stores[y]) {
+        const s = this.stores[y][x];
+        if (s !== store) {
+          s.clearFocus();
+        } else {
+          currentStorePointer = {
+            x: parseInt(x, 10),
+            y: parseInt(y, 10)
+          };
+        }
+      }
+    }
+    return currentStorePointer;
+  }
+  /**
+   * Retrieves the next store based on the focus cell and current store pointer.
+   * If the next store exists, returns an object with the next store and the item in the new store.
+   * If the next store does not exist, returns null.
+   */
+  getNextStore(focus, currentStorePointer, lastCell) {
+    const nextItem = nextCell(focus, lastCell);
+    let nextStore;
+    if (nextItem) {
+      Object.keys(nextItem).forEach((t) => {
+        var _a;
+        const type = t;
+        const nextItemCoord = (_a = nextItem[type]) !== null && _a !== void 0 ? _a : 0;
+        let stores;
+        switch (type) {
+          case "x":
+            stores = this.getXStores(currentStorePointer.y);
+            break;
+          case "y":
+            stores = this.getYStores(currentStorePointer.x);
+            break;
+        }
+        if (nextItemCoord >= 0) {
+          nextStore = stores[++currentStorePointer[type]];
+        } else {
+          nextStore = stores[--currentStorePointer[type]];
+          const nextLastCell = nextStore === null || nextStore === void 0 ? void 0 : nextStore.store.get("lastCell");
+          if (nextLastCell) {
+            nextItem[type] = nextLastCell[type] + nextItemCoord;
+          }
+        }
+      });
+    }
+    const lastCellNext = nextStore === null || nextStore === void 0 ? void 0 : nextStore.store.get("lastCell");
+    if (!(lastCellNext === null || lastCellNext === void 0 ? void 0 : lastCellNext.x) || !(lastCellNext === null || lastCellNext === void 0 ? void 0 : lastCellNext.y)) {
+      nextStore = void 0;
+    }
+    return {
+      store: nextStore,
+      item: nextItem
+    };
+  }
+  clearAll() {
+    var _a;
+    for (let y in this.stores) {
+      for (let x in this.stores[y]) {
+        (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.clearFocus();
+      }
+    }
+  }
+  setEdit(val) {
+    if (!this.focusedStore) {
+      return;
+    }
+    this.focusedStore.entity.setEdit(val);
+  }
+  /**
+   * Select all cells across all stores
+   */
+  selectAll() {
+    for (let y in this.stores) {
+      for (let x in this.stores[y]) {
+        const store = this.stores[y][x];
+        if (!store) {
+          continue;
+        }
+        const lastCell = store.store.get("lastCell");
+        if (lastCell) {
+          store.setRange({ x: 0, y: 0 }, { x: lastCell.x - 1, y: lastCell.y - 1 });
+        }
+      }
+    }
+  }
+  getXStores(y) {
+    return this.stores[y];
+  }
+  getYStores(x) {
+    const stores = {};
+    for (let i in this.stores) {
+      stores[i] = this.stores[i][x];
+    }
+    return stores;
+  }
+  /**
+   * Keep column viewport positions and types in sync across pin/unpin rerenders.
+   * Regression case: when a selected rgCol cell was pinned left, colPinStart
+   * could take over x=0 and render the stale rgCol focus store in the pinned area.
+   */
+  updateColumnTypeMapping(x, type) {
+    const previousType = this.storesXToType[x];
+    const previousX = this.storesByType[type];
+    let shouldClearFocus = false;
+    this.storesByType[type] = x;
+    this.storesXToType[x] = type;
+    if (previousType && previousType !== type) {
+      shouldClearFocus = true;
+      if (this.storesByType[previousType] === x) {
+        delete this.storesByType[previousType];
+      }
+    }
+    if (typeof previousX === "number" && previousX !== x && this.storesXToType[previousX] === type) {
+      delete this.storesXToType[previousX];
+      shouldClearFocus = true;
+    }
+    if (shouldClearFocus) {
+      this.clearAll();
+    }
+  }
+};
+var OrdererService = class {
+  constructor() {
+    this.parentY = 0;
+  }
+  start(parent, { pos, text, event }) {
+    var _a;
+    const { top } = parent.getBoundingClientRect();
+    this.parentY = top;
+    if (this.text) {
+      this.text.innerText = text;
+    }
+    this.move(pos);
+    this.moveTip({ x: event.x, y: event.y });
+    (_a = this.el) === null || _a === void 0 ? void 0 : _a.classList.remove("hidden");
+  }
+  end() {
+    var _a;
+    (_a = this.el) === null || _a === void 0 ? void 0 : _a.classList.add("hidden");
+  }
+  move(pos) {
+    this.moveElement(pos.end - this.parentY);
+  }
+  moveTip({ x, y }) {
+    if (!this.draggable) {
+      return;
+    }
+    this.draggable.style.left = `${x}px`;
+    this.draggable.style.top = `${y}px`;
+  }
+  moveElement(y) {
+    if (!this.rgRow) {
+      return;
+    }
+    this.rgRow.style.transform = `translateY(${y}px)`;
+  }
+};
+var OrderRenderer = ({ ref }) => {
+  const service = new OrdererService();
+  ref(service);
+  return h("div", { class: "draggable-wrapper hidden", ref: (e) => service.el = e }, h("div", { class: "draggable", ref: (el) => service.draggable = el }, h("span", { class: "revo-alt-icon" }), h("span", { ref: (e) => service.text = e })), h("div", { class: "drag-position", ref: (e) => service.rgRow = e }));
+};
+var rowDefinitionByType = (newVal = []) => {
+  const result = {};
+  for (const v of newVal) {
+    let rowDefs = result[v.type];
+    if (!rowDefs) {
+      rowDefs = result[v.type] = {};
+    }
+    if (typeof v.size === "number") {
+      if (!rowDefs.sizes) {
+        rowDefs.sizes = {};
+      }
+      rowDefs.sizes[v.index] = v.size;
+    }
+  }
+  return result;
+};
+var rowDefinitionRemoveByType = (oldVal = []) => {
+  const result = {};
+  for (const v of oldVal) {
+    let rowDefs = result[v.type];
+    if (!rowDefs) {
+      rowDefs = result[v.type] = [];
+    }
+    if (typeof v.size === "number") {
+      rowDefs.push(v.index);
+    }
+  }
+  return result;
+};
+function isMobileDevice() {
+  return /Mobi/i.test(navigator.userAgent) || /Android/i.test(navigator.userAgent) || navigator.maxTouchPoints > 0;
+}
+var WCAGPlugin = class extends BasePlugin {
+  constructor(revogrid, providers) {
+    super(revogrid, providers);
+    revogrid.setAttribute("role", "treegrid");
+    revogrid.setAttribute("aria-keyshortcuts", "Enter");
+    revogrid.setAttribute("aria-multiselectable", "true");
+    revogrid.setAttribute("tabindex", "0");
+    this.addEventListener("beforecolumnsset", ({ detail }) => {
+      const columns = [
+        ...detail.columns.colPinStart,
+        ...detail.columns.rgCol,
+        ...detail.columns.colPinEnd
+      ];
+      revogrid.setAttribute("aria-colcount", `${columns.length}`);
+      columns.forEach((column, index) => {
+        const { columnProperties, cellProperties } = column;
+        column.columnProperties = (...args) => {
+          const result = (columnProperties === null || columnProperties === void 0 ? void 0 : columnProperties(...args)) || {};
+          result.role = "columnheader";
+          result["aria-colindex"] = `${index}`;
+          return result;
+        };
+        column.cellProperties = (...args) => {
+          const wcagProps = {
+            ["role"]: "gridcell",
+            ["aria-colindex"]: `${index}`,
+            ["aria-rowindex"]: `${args[0].rowIndex}`,
+            ["tabindex"]: -1
+          };
+          const columnProps = (cellProperties === null || cellProperties === void 0 ? void 0 : cellProperties(...args)) || {};
+          return Object.assign(Object.assign({}, wcagProps), columnProps);
+        };
+      });
+    });
+    this.addEventListener("beforesourceset", ({ detail }) => {
+      revogrid.setAttribute("aria-rowcount", `${detail.source.length}`);
+    });
+    this.addEventListener("beforerowrender", ({ detail }) => {
+      detail.node.$attrs$ = Object.assign(Object.assign({}, detail.node.$attrs$), { role: "row", ["aria-rowindex"]: detail.item.itemIndex });
+    });
+    this.addEventListener("afterfocus", async (e) => {
+      if (e.defaultPrevented) {
+        return;
+      }
+      const el = this.revogrid.querySelector(`revogr-data[type="${e.detail.rowType}"][col-type="${e.detail.colType}"] [data-rgrow="${e.detail.rowIndex}"][data-rgcol="${e.detail.colIndex}"]`);
+      if (el instanceof HTMLElement) {
+        el.focus();
+      }
+    });
+  }
+};
+var PluginService = class {
+  constructor() {
+    this.internalPlugins = [];
+  }
+  /**
+   * Get all plugins
+   */
+  get() {
+    return [...this.internalPlugins];
+  }
+  /**
+   * Add plugin to collection
+   */
+  add(plugin) {
+    this.internalPlugins.push(plugin);
+  }
+  /**
+   * Add user plugins and create
+   */
+  addUserPluginsAndCreate(element, plugins = [], prevPlugins, pluginData) {
+    if (!pluginData) {
+      return;
+    }
+    const pluginsToRemove = (prevPlugins === null || prevPlugins === void 0 ? void 0 : prevPlugins.filter((prevPlugin) => !plugins.some((userPlugin) => userPlugin === prevPlugin))) || [];
+    pluginsToRemove.forEach((plugin) => {
+      var _a, _b;
+      const index = this.internalPlugins.findIndex((createdPlugin) => createdPlugin instanceof plugin);
+      if (index !== -1) {
+        (_b = (_a = this.internalPlugins[index]).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.internalPlugins.splice(index, 1);
+      }
+    });
+    plugins === null || plugins === void 0 ? void 0 : plugins.forEach((userPlugin) => {
+      const existingPlugin = this.internalPlugins.find((createdPlugin) => createdPlugin instanceof userPlugin);
+      if (existingPlugin) {
+        return;
+      }
+      this.add(new userPlugin(element, pluginData));
+    });
+  }
+  /**
+   * Get plugin by class
+   */
+  getByClass(pluginClass) {
+    return this.internalPlugins.find((p) => p instanceof pluginClass);
+  }
+  /**
+   * Remove plugin
+   */
+  remove(plugin) {
+    var _a, _b;
+    const index = this.internalPlugins.indexOf(plugin);
+    if (index > -1) {
+      (_b = (_a = this.internalPlugins[index]).destroy) === null || _b === void 0 ? void 0 : _b.call(_a);
+      this.internalPlugins.splice(index, 1);
+    }
+  }
+  /**
+   * Remove all plugins
+   */
+  destroy() {
+    this.internalPlugins.forEach((p) => {
+      var _a;
+      return (_a = p.destroy) === null || _a === void 0 ? void 0 : _a.call(p);
+    });
+    this.internalPlugins = [];
+  }
+};
+var RTLPlugin = class extends BasePlugin {
+  constructor(revogrid, providers) {
+    super(revogrid, providers);
+    this.isRTLEnabled = false;
+    this.init();
+  }
+  init() {
+    this.addEventListener("beforecolumnsset", (event) => {
+      this.handleBeforeColumnsSet(event);
+    });
+    this.addEventListener("aftergridinit", () => {
+      this.updateRTLState();
+    });
+    this.watch("rtl", (value) => {
+      this.isRTLEnabled = value;
+      this.emit("rtlstatechanged", { rtl: this.isRTLEnabled });
+    }, { immediate: true });
+  }
+  /**
+   * Handle the beforecolumnsset event to apply RTL transformation
+   */
+  handleBeforeColumnsSet(event) {
+    if (!this.isRTLEnabled) {
+      return;
+    }
+    const columnCollection = event.detail;
+    const transformedColumns = this.applyRTLTransformationToCollection(columnCollection);
+    event.detail.columns = transformedColumns.columns;
+    event.detail.columnByProp = transformedColumns.columnByProp;
+    event.detail.columnGrouping = transformedColumns.columnGrouping;
+  }
+  /**
+   * Apply RTL transformation to the entire column collection
+   */
+  applyRTLTransformationToCollection(collection) {
+    const transformedCollection = {
+      columns: {
+        rgCol: [],
+        colPinStart: [],
+        colPinEnd: []
+      },
+      columnByProp: Object.assign({}, collection.columnByProp),
+      columnGrouping: {
+        rgCol: [],
+        colPinStart: [],
+        colPinEnd: []
+      },
+      maxLevel: collection.maxLevel,
+      sort: Object.assign({}, collection.sort)
+    };
+    Object.keys(collection.columns).forEach((type) => {
+      const columnType = type;
+      const columns = collection.columns[columnType];
+      const reversedColumns = [...columns].reverse();
+      transformedCollection.columns[columnType] = reversedColumns;
+      transformedCollection.columnGrouping[columnType] = this.applyRTLTransformationToGroups(collection.columnGrouping[columnType], columns.length);
+    });
+    return transformedCollection;
+  }
+  /**
+   * Apply RTL transformation to column groups
+   */
+  applyRTLTransformationToGroups(groups, totalColumns) {
+    return groups.map((group) => {
+      const reversedIndexes = group.indexes.map((index) => totalColumns - 1 - index).reverse();
+      return Object.assign(Object.assign({}, group), { indexes: reversedIndexes });
+    }).reverse();
+  }
+  /**
+   * Update RTL state based on the grid's rtl property
+   */
+  updateRTLState() {
+    const grid = this.revogrid;
+    if (grid && typeof grid.rtl === "boolean") {
+      this.isRTLEnabled = grid.rtl;
+    }
+  }
+  /**
+   * Get current RTL state
+   */
+  getRTLState() {
+    return this.isRTLEnabled;
+  }
+  /**
+   * Clean up the plugin
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+var revoGridStyleCss = () => `revo-grid:is([theme=default],[theme=dark]),revo-grid:not([theme]){--rg-theme-font-family:var(     --revo-grid-font-family,     Helvetica,     Arial,     Sans-Serif,     serif   );--rg-theme-font-size:var(--revo-grid-font-size, 12px);--rg-theme-header-height:var(--revo-grid-header-height, 30px);--rg-theme-header-font-size:var(--revo-grid-header-font-size, 12px);--rg-theme-header-font-weight:var(--revo-grid-header-font-weight, normal);--rg-theme-header-text-transform:var(     --revo-grid-header-text-transform,     uppercase   );--rg-theme-header-text-align:var(--revo-grid-header-text-align, center);--rg-theme-cell-text-align:var(--revo-grid-cell-text-align, center);--rg-theme-header-padding:var(--revo-grid-header-padding, 0);--rg-theme-cell-padding:var(--revo-grid-cell-padding, 0);border:1px solid var(--rg-theme-header-border);font-size:var(--rg-theme-font-size)}revo-grid:is([theme=default],[theme=dark]) .rowHeaders revogr-header,revo-grid:not([theme]) .rowHeaders revogr-header{box-shadow:-1px 0 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) revogr-header,revo-grid:not([theme]) revogr-header{text-align:var(--rg-theme-header-text-align);line-height:var(--rg-theme-header-height);background-color:var(--rg-theme-header-bg)}revo-grid:is([theme=default],[theme=dark]) revogr-header .group-rgRow,revo-grid:not([theme]) revogr-header .group-rgRow{box-shadow:none}revo-grid:is([theme=default],[theme=dark]) revogr-header .group-rgRow .rgHeaderCell,revo-grid:not([theme]) revogr-header .group-rgRow .rgHeaderCell{box-shadow:-1px 0 0 0 var(--rg-theme-header-border), -1px 0 0 0 var(--rg-theme-header-border) inset, 0 -1px 0 0 var(--rg-theme-header-border), 0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) revogr-header .header-rgRow,revo-grid:is([theme=default],[theme=dark]) revogr-header .group-rgRow,revo-grid:not([theme]) revogr-header .header-rgRow,revo-grid:not([theme]) revogr-header .group-rgRow{text-transform:var(--rg-theme-header-text-transform);font-size:var(--rg-theme-header-font-size);font-weight:var(--rg-theme-header-font-weight);color:var(--rg-theme-header-color)}revo-grid:is([theme=default],[theme=dark]) revogr-header .header-rgRow,revo-grid:not([theme]) revogr-header .header-rgRow{height:var(--rg-theme-header-height);box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) revogr-header .rgHeaderCell,revo-grid:not([theme]) revogr-header .rgHeaderCell{box-shadow:-1px 0 0 0 var(--rg-theme-header-border) inset, 0 -1px 0 0 var(--rg-theme-header-border), 0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) .rowHeaders,revo-grid:not([theme]) .rowHeaders{background-color:var(--rg-theme-row-headers-bg)}revo-grid:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell,revo-grid:not([theme]) .rowHeaders revogr-data .rgCell{color:var(--rg-theme-row-headers-color)}revo-grid:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell:first-child,revo-grid:not([theme]) .rowHeaders revogr-data .rgCell:first-child{box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell:not(:first-child),revo-grid:not([theme]) .rowHeaders revogr-data .rgCell:not(:first-child){box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset, -1px 0 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell:last-child,revo-grid:not([theme]) .rowHeaders revogr-data .rgCell:last-child{border-right:1px solid var(--rg-theme-header-border)}revo-grid:is([theme=default],[theme=dark]) .rowHeaders revogr-data revogr-header,revo-grid:not([theme]) .rowHeaders revogr-data revogr-header{box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) revogr-viewport-scroll.colPinStart revogr-data .rgRow .rgCell:last-child,revo-grid:not([theme]) revogr-viewport-scroll.colPinStart revogr-data .rgRow .rgCell:last-child{box-shadow:0 -1px 0 0 var(--rg-theme-cell-border) inset, -1px 0 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) revogr-viewport-scroll.colPinStart .footer-wrapper revogr-data .rgRow:first-child .rgCell,revo-grid:not([theme]) revogr-viewport-scroll.colPinStart .footer-wrapper revogr-data .rgRow:first-child .rgCell{box-shadow:0 1px 0 0 var(--rg-theme-header-border) inset, -1px 0 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) revogr-viewport-scroll.colPinEnd,revo-grid:is([theme=default],[theme=dark]) revogr-viewport-scroll.colPinEnd revogr-header,revo-grid:not([theme]) revogr-viewport-scroll.colPinEnd,revo-grid:not([theme]) revogr-viewport-scroll.colPinEnd revogr-header{box-shadow:1px 0 0 var(--rg-theme-header-border) inset}revo-grid:is([theme=default],[theme=dark]) .footer-wrapper revogr-data .rgRow:first-child .rgCell,revo-grid:not([theme]) .footer-wrapper revogr-data .rgRow:first-child .rgCell{box-shadow:0 1px 0 0 var(--rg-theme-cell-border) inset, -1px 0 0 0 var(--rg-theme-cell-border) inset, 0 -1px 0 0 var(--rg-theme-cell-border) inset}revo-grid:is([theme=default],[theme=dark]) revogr-data,revo-grid:not([theme]) revogr-data{text-align:var(--rg-theme-cell-text-align)}revo-grid:is([theme=default],[theme=dark]) revogr-data .revo-draggable,revo-grid:not([theme]) revogr-data .revo-draggable{float:left}revo-grid:is([theme=default],[theme=dark]) revogr-data .rgRow,revo-grid:not([theme]) revogr-data .rgRow{line-height:var(--rg-theme-row-size, 27px)}revo-grid:is([theme=default],[theme=dark]) revogr-data .rgCell,revo-grid:not([theme]) revogr-data .rgCell{padding:var(--rg-theme-cell-padding);box-shadow:0 -1px 0 0 var(--rg-theme-cell-border) inset, -1px 0 0 0 var(--rg-theme-cell-border) inset}revo-grid:is([theme=material],[theme=darkMaterial]),revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]){--rg-theme-font-family:var(     --revo-grid-font-family,     Nunito,     -apple-system,     BlinkMacSystemFont,     'Segoe UI',     Roboto,     'Helvetica Neue',     Arial,     sans-serif,     'Apple Color Emoji',     'Segoe UI Emoji',     'Segoe UI Symbol'   );--rg-theme-header-height:var(--revo-grid-header-height, 50px);--rg-theme-header-font-size:var(     --revo-grid-header-font-size,     var(--rg-theme-font-size)   );--rg-theme-header-font-weight:var(--revo-grid-header-font-weight, 600);--rg-theme-header-text-transform:var(     --revo-grid-header-text-transform,     none   );--rg-theme-header-text-align:var(--revo-grid-header-text-align, left);--rg-theme-cell-text-align:var(--revo-grid-cell-text-align, left);--rg-theme-header-padding:var(--revo-grid-header-padding, 0 15px);--rg-theme-cell-padding:var(--revo-grid-cell-padding, 0 15px);font-family:var(--rg-theme-font-family)}revo-grid:is([theme=material],[theme=darkMaterial]) revogr-header,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) revogr-header{color:var(--rg-theme-header-color);background-color:var(--rg-theme-header-bg);line-height:var(--rg-theme-header-height);font-size:var(--rg-theme-header-font-size);font-weight:var(--rg-theme-header-font-weight);text-transform:var(--rg-theme-header-text-transform);text-align:var(--rg-theme-header-text-align)}revo-grid:is([theme=material],[theme=darkMaterial]) revogr-header .rgHeaderCell,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) revogr-header .rgHeaderCell{padding:var(--rg-theme-header-padding);text-overflow:ellipsis}revo-grid:is([theme=material],[theme=darkMaterial]) revogr-header .header-rgRow,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) revogr-header .header-rgRow{height:var(--rg-theme-header-height)}revo-grid:is([theme=material],[theme=darkMaterial]) .rowHeaders,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) .rowHeaders{color:var(--rg-theme-row-headers-color);background-color:var(--rg-theme-row-headers-bg)}revo-grid:is([theme=material],[theme=darkMaterial]) .rowHeaders revogr-data .rgCell,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) .rowHeaders revogr-data .rgCell{color:var(--rg-theme-row-headers-color)}revo-grid:is([theme=material],[theme=darkMaterial]) revogr-data,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) revogr-data{text-align:var(--rg-theme-cell-text-align)}revo-grid:is([theme=material],[theme=darkMaterial]) revogr-data .rgRow,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) revogr-data .rgRow{line-height:var(--rg-theme-row-size, 42px)}revo-grid:is([theme=material],[theme=darkMaterial]) revogr-data .rgCell,revo-grid[theme]:not([theme=default],[theme=dark],[theme=compact],[theme=darkCompact]) revogr-data .rgCell{padding:var(--rg-theme-cell-padding);box-shadow:-1px 0 0 0 var(--rg-theme-cell-vertical-border) inset}revo-grid:is([theme=compact],[theme=darkCompact]){--rg-theme-font-family:var(     --revo-grid-font-family,     Nunito,     -apple-system,     BlinkMacSystemFont,     'Segoe UI',     Roboto,     'Helvetica Neue',     Arial,     sans-serif,     'Apple Color Emoji',     'Segoe UI Emoji',     'Segoe UI Symbol'   );--rg-theme-header-height:var(--revo-grid-header-height, 45px);--rg-theme-header-font-size:var(     --revo-grid-header-font-size,     var(--rg-theme-font-size)   );--rg-theme-header-font-weight:var(--revo-grid-header-font-weight, 600);--rg-theme-header-text-transform:var(     --revo-grid-header-text-transform,     none   );--rg-theme-header-text-align:var(--revo-grid-header-text-align, left);--rg-theme-cell-text-align:var(--revo-grid-cell-text-align, left);--rg-theme-header-padding:var(--revo-grid-header-padding, 0 15px);--rg-theme-cell-padding:var(--revo-grid-cell-padding, 0 15px);font-family:var(--rg-theme-font-family)}revo-grid:is([theme=compact],[theme=darkCompact]) revogr-header{color:var(--rg-theme-header-color);background-color:var(--rg-theme-header-bg);line-height:var(--rg-theme-header-height);font-size:var(--rg-theme-header-font-size);font-weight:var(--rg-theme-header-font-weight);text-transform:var(--rg-theme-header-text-transform);text-align:var(--rg-theme-header-text-align)}revo-grid:is([theme=compact],[theme=darkCompact]) revogr-header .rgHeaderCell{padding:var(--rg-theme-header-padding);text-overflow:ellipsis}revo-grid:is([theme=compact],[theme=darkCompact]) revogr-header .header-rgRow{height:var(--rg-theme-header-height)}revo-grid:is([theme=compact],[theme=darkCompact]) .rowHeaders{color:var(--rg-theme-row-headers-color);background-color:var(--rg-theme-row-headers-bg)}revo-grid:is([theme=compact],[theme=darkCompact]) .rowHeaders revogr-data .rgCell{color:var(--rg-theme-row-headers-color)}revo-grid:is([theme=compact],[theme=darkCompact]) revogr-data{text-align:var(--rg-theme-cell-text-align)}revo-grid:is([theme=compact],[theme=darkCompact]) revogr-data .rgRow{line-height:var(--rg-theme-row-size, 32px)}revo-grid:is([theme=compact],[theme=darkCompact]) revogr-data .rgCell{padding:var(--rg-theme-cell-padding);box-shadow:-1px 0 0 0 var(--rg-theme-cell-vertical-border) inset}revo-grid:is([theme=compact],[theme=darkCompact]) revo-dropdown .rv-dr-root{padding:0px 9px}revo-grid[dir=rtl] .viewports{flex-direction:row-reverse}revo-grid[dir=rtl] revogr-header .rgHeaderCell{text-align:right}revo-grid[dir=rtl] revogr-data .rgCell{text-align:right}revo-grid[dir=rtl] .rowHeaders revogr-data .rgCell{text-align:right}revo-grid[dir=rtl] revogr-filter-panel{direction:rtl}revo-grid[dir=rtl] revo-dropdown .rv-dr-root{text-align:right}revo-grid[dir=rtl] .drag-position{right:0;left:auto}revo-grid[dir=rtl] .drag-auto-scroll-y{right:0;left:auto}revo-grid[dir=rtl] .clipboard{right:0;left:auto}revo-grid[dir=rtl] .draggable{margin-left:-20px;margin-right:0;padding-right:20px;padding-left:5px}revo-grid[dir=rtl] .draggable .revo-alt-icon{right:5px;left:auto}revo-grid[dir=rtl] .focused-cell{border-right:2px solid var(--rg-theme-primary);border-left:none}revo-grid[dir=rtl] .selection-range{border-right:2px solid var(--rg-theme-primary);border-left:none}revo-grid[dir=rtl] .resize-handle{right:0;left:auto}revo-grid[dir=rtl] .sort-indicator{margin-left:0;margin-right:5px}revo-grid[dir=rtl] .filter-button{margin-left:0;margin-right:5px}revo-grid[dir=rtl] .group-expand{margin-right:0;margin-left:2px;padding-right:5px;padding-left:0}revo-grid[dir=rtl] .rgCell,revo-grid[dir=rtl] .rgHeaderCell{padding-left:5px;padding-right:5px}revo-grid[dir=rtl] revogr-edit{direction:rtl}revo-grid[dir=rtl] .rgHeaderCell{direction:rtl}revo-grid[dir=rtl] revogr-header,revo-grid[dir=rtl] revogr-data{text-align:right}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) .rowHeaders,revo-grid[dir=rtl]:not([theme]) .rowHeaders{background-color:var(--rg-theme-row-headers-bg)}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell,revo-grid[dir=rtl]:not([theme]) .rowHeaders revogr-data .rgCell{color:var(--rg-theme-row-headers-color)}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell:first-child,revo-grid[dir=rtl]:not([theme]) .rowHeaders revogr-data .rgCell:first-child{box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell:not(:first-child),revo-grid[dir=rtl]:not([theme]) .rowHeaders revogr-data .rgCell:not(:first-child){box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset, 1px 0 0 0 var(--rg-theme-header-border) inset}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) .rowHeaders revogr-data .rgCell:last-child,revo-grid[dir=rtl]:not([theme]) .rowHeaders revogr-data .rgCell:last-child{border-left:1px solid var(--rg-theme-header-border);border-right:none}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) .rowHeaders revogr-data revogr-header,revo-grid[dir=rtl]:not([theme]) .rowHeaders revogr-data revogr-header{box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) revogr-header,revo-grid[dir=rtl]:not([theme]) revogr-header{text-align:right}revo-grid[dir=rtl]:is([theme=default],[theme=dark]) revogr-data,revo-grid[dir=rtl]:not([theme]) revogr-data{text-align:right}.revo-drag-icon{width:11px;opacity:0.8}.revo-drag-icon::before{content:"::";display:inline-block}.revo-alt-icon{-webkit-mask-image:url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3Csvg viewBox='0 0 384 383' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E%3Cg%3E%3Cpath d='M192.4375,383 C197.424479,383 201.663411,381.254557 205.154297,377.763672 L205.154297,377.763672 L264.25,318.667969 C270.234375,312.683594 271.605794,306.075846 268.364258,298.844727 C265.122721,291.613607 259.51237,287.998047 251.533203,287.998047 L251.533203,287.998047 L213.382812,287.998047 L213.382812,212.445312 L288.935547,212.445312 L288.935547,250.595703 C288.935547,258.57487 292.551107,264.185221 299.782227,267.426758 C307.013346,270.668294 313.621094,269.296875 319.605469,263.3125 L319.605469,263.3125 L378.701172,204.216797 C382.192057,200.725911 383.9375,196.486979 383.9375,191.5 C383.9375,186.513021 382.192057,182.274089 378.701172,178.783203 L378.701172,178.783203 L319.605469,119.6875 C313.621094,114.201823 307.013346,112.955078 299.782227,115.947266 C292.551107,118.939453 288.935547,124.42513 288.935547,132.404297 L288.935547,132.404297 L288.935547,170.554688 L213.382812,170.554688 L213.382812,95.0019531 L251.533203,95.0019531 C259.51237,95.0019531 264.998047,91.3863932 267.990234,84.1552734 C270.982422,76.9241536 269.735677,70.3164062 264.25,64.3320312 L264.25,64.3320312 L205.154297,5.23632812 C201.663411,1.74544271 197.424479,0 192.4375,0 C187.450521,0 183.211589,1.74544271 179.720703,5.23632812 L179.720703,5.23632812 L120.625,64.3320312 C114.640625,70.3164062 113.269206,76.9241536 116.510742,84.1552734 C119.752279,91.3863932 125.36263,95.0019531 133.341797,95.0019531 L133.341797,95.0019531 L171.492188,95.0019531 L171.492188,170.554688 L95.9394531,170.554688 L95.9394531,132.404297 C95.9394531,124.42513 92.3238932,118.814779 85.0927734,115.573242 C77.8616536,112.331706 71.2539062,113.703125 65.2695312,119.6875 L65.2695312,119.6875 L6.17382812,178.783203 C2.68294271,182.274089 0.9375,186.513021 0.9375,191.5 C0.9375,196.486979 2.68294271,200.725911 6.17382812,204.216797 L6.17382812,204.216797 L65.2695312,263.3125 C71.2539062,268.798177 77.8616536,270.044922 85.0927734,267.052734 C92.3238932,264.060547 95.9394531,258.57487 95.9394531,250.595703 L95.9394531,250.595703 L95.9394531,212.445312 L171.492188,212.445312 L171.492188,287.998047 L133.341797,287.998047 C125.36263,287.998047 119.876953,291.613607 116.884766,298.844727 C113.892578,306.075846 115.139323,312.683594 120.625,318.667969 L120.625,318.667969 L179.720703,377.763672 C183.211589,381.254557 187.450521,383 192.4375,383 Z'%3E%3C/path%3E%3C/g%3E%3C/svg%3E");mask-image:url("data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3Csvg viewBox='0 0 384 383' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E%3Cg%3E%3Cpath d='M192.4375,383 C197.424479,383 201.663411,381.254557 205.154297,377.763672 L205.154297,377.763672 L264.25,318.667969 C270.234375,312.683594 271.605794,306.075846 268.364258,298.844727 C265.122721,291.613607 259.51237,287.998047 251.533203,287.998047 L251.533203,287.998047 L213.382812,287.998047 L213.382812,212.445312 L288.935547,212.445312 L288.935547,250.595703 C288.935547,258.57487 292.551107,264.185221 299.782227,267.426758 C307.013346,270.668294 313.621094,269.296875 319.605469,263.3125 L319.605469,263.3125 L378.701172,204.216797 C382.192057,200.725911 383.9375,196.486979 383.9375,191.5 C383.9375,186.513021 382.192057,182.274089 378.701172,178.783203 L378.701172,178.783203 L319.605469,119.6875 C313.621094,114.201823 307.013346,112.955078 299.782227,115.947266 C292.551107,118.939453 288.935547,124.42513 288.935547,132.404297 L288.935547,132.404297 L288.935547,170.554688 L213.382812,170.554688 L213.382812,95.0019531 L251.533203,95.0019531 C259.51237,95.0019531 264.998047,91.3863932 267.990234,84.1552734 C270.982422,76.9241536 269.735677,70.3164062 264.25,64.3320312 L264.25,64.3320312 L205.154297,5.23632812 C201.663411,1.74544271 197.424479,0 192.4375,0 C187.450521,0 183.211589,1.74544271 179.720703,5.23632812 L179.720703,5.23632812 L120.625,64.3320312 C114.640625,70.3164062 113.269206,76.9241536 116.510742,84.1552734 C119.752279,91.3863932 125.36263,95.0019531 133.341797,95.0019531 L133.341797,95.0019531 L171.492188,95.0019531 L171.492188,170.554688 L95.9394531,170.554688 L95.9394531,132.404297 C95.9394531,124.42513 92.3238932,118.814779 85.0927734,115.573242 C77.8616536,112.331706 71.2539062,113.703125 65.2695312,119.6875 L65.2695312,119.6875 L6.17382812,178.783203 C2.68294271,182.274089 0.9375,186.513021 0.9375,191.5 C0.9375,196.486979 2.68294271,200.725911 6.17382812,204.216797 L6.17382812,204.216797 L65.2695312,263.3125 C71.2539062,268.798177 77.8616536,270.044922 85.0927734,267.052734 C92.3238932,264.060547 95.9394531,258.57487 95.9394531,250.595703 L95.9394531,250.595703 L95.9394531,212.445312 L171.492188,212.445312 L171.492188,287.998047 L133.341797,287.998047 C125.36263,287.998047 119.876953,291.613607 116.884766,298.844727 C113.892578,306.075846 115.139323,312.683594 120.625,318.667969 L120.625,318.667969 L179.720703,377.763672 C183.211589,381.254557 187.450521,383 192.4375,383 Z'%3E%3C/path%3E%3C/g%3E%3C/svg%3E");width:11px;height:11px;background-size:cover;background-repeat:no-repeat}.arrow-down{position:absolute;right:5px;top:0}.arrow-down svg{width:8px;margin-top:5px;margin-left:5px;opacity:0.4}.cell-value-wrapper{margin-right:10px;overflow:hidden;text-overflow:ellipsis}revo-grid[theme]:is([theme=compact],[theme=darkCompact],[theme=material],[theme=darkMaterial]){background-color:transparent}revo-grid[theme]:is([theme=compact],[theme=darkCompact],[theme=material],[theme=darkMaterial]) revogr-header,revo-grid[theme]:is([theme=compact],[theme=darkCompact],[theme=material],[theme=darkMaterial]) .rowHeaders{background-color:transparent;color:inherit}revo-grid[theme]:is([theme=compact],[theme=darkCompact],[theme=material],[theme=darkMaterial]) .rowHeaders revogr-data .rgCell{color:inherit}revo-grid{--rg-theme-primary:var(--revo-grid-primary, #266ae8);--rg-theme-primary-transparent:var(     --revo-grid-primary-transparent,     rgba(38, 106, 232, 0.9)   );--rg-theme-background:var(--revo-grid-background, #fff);--rg-theme-foreground:var(--revo-grid-foreground, black);--rg-theme-divider:var(--revo-grid-divider, gray);--rg-theme-shadow:var(--revo-grid-shadow, rgba(0, 0, 0, 0.15));--rg-theme-text:var(--revo-grid-text, black);--rg-theme-border:var(--revo-grid-border, rgba(0, 0, 0, 0.2));--rg-theme-header-bg:var(--revo-grid-header-bg, #f8f9fa);--rg-theme-header-color:var(--revo-grid-header-color, #000);--rg-theme-header-border:var(--revo-grid-header-border, #cecece);--rg-theme-header-focused-bg:var(     --revo-grid-header-focused-bg,     var(--rg-theme-focused-bg)   );--rg-theme-header-hover-bg:var(     --revo-grid-header-hover-bg,     var(--rg-theme-row-hover)   );--rg-theme-cell-border:var(--revo-grid-cell-border, #e2e3e3);--rg-theme-cell-vertical-border:var(     --revo-grid-cell-vertical-border,     transparent   );--rg-theme-focused-bg:var(--revo-grid-focused-bg, rgba(233, 234, 237, 0.5));--rg-theme-row-hover:var(--revo-grid-row-hover, #f1f1f1);--rg-theme-row-headers-bg:var(     --revo-grid-row-headers-bg,     var(--rg-theme-header-bg)   );--rg-theme-row-headers-color:var(     --revo-grid-row-headers-color,     var(--rg-theme-header-color)   );--rg-theme-cell-disabled-bg:var(     --revo-grid-cell-disabled-bg,     rgba(0, 0, 0, 0.07)   );--rg-theme-filter-panel-bg:var(--revo-grid-filter-panel-bg, #fff);--rg-theme-filter-panel-border:var(--revo-grid-filter-panel-border, #d9d9d9);--rg-theme-filter-panel-shadow:var(     --revo-grid-filter-panel-shadow,     rgba(0, 0, 0, 0.15)   );--rg-theme-filter-panel-input-bg:var(     --revo-grid-filter-panel-input-bg,     #eaeaeb   );--rg-theme-filter-panel-divider:var(     --revo-grid-filter-panel-divider,     #d9d9d9   );--rg-theme-filter-panel-select-border:var(     --revo-grid-filter-panel-select-border,     transparent   );--rg-theme-filter-panel-select-border-hover:var(     --revo-grid-filter-panel-select-border-hover,     transparent   );--rg-theme-filter-panel-reorder-accent:var(     --revo-grid-filter-panel-reorder-accent,     #007cb2   );--rg-theme-filter-panel-reorder-color:var(     --revo-grid-filter-panel-reorder-color,     #6b7280   );--rg-theme-filter-panel-text:var(     --revo-grid-filter-panel-text,     var(--rg-theme-text)   );--rg-theme-filter-panel-muted-text:var(     --revo-grid-filter-panel-muted-text,     gray   );--rg-theme-filter-panel-focus-ring:var(     --revo-grid-filter-panel-focus-ring,     0 0 1px 3px rgba(59, 153, 252, 0.7)   );--rg-theme-filter-panel-icon:var(--revo-grid-filter-panel-icon, gray);--rg-theme-filter-panel-icon-active:var(     --revo-grid-filter-panel-icon-active,     #10224a   );--rg-theme-font-family:var(     --revo-grid-font-family,     Helvetica,     Arial,     Sans-Serif,     serif   );--rg-theme-font-size:var(--revo-grid-font-size, 14px);--rg-theme-header-height:var(--revo-grid-header-height, 30px);--rg-theme-header-font-size:var(--revo-grid-header-font-size, 12px);--rg-theme-header-font-weight:var(--revo-grid-header-font-weight, normal);--rg-theme-header-text-transform:var(     --revo-grid-header-text-transform,     uppercase   );--rg-theme-header-text-align:var(--revo-grid-header-text-align, center);--rg-theme-cell-text-align:var(--revo-grid-cell-text-align, center);--rg-theme-header-padding:var(--revo-grid-header-padding, 0);--rg-theme-cell-padding:var(--revo-grid-cell-padding, 0);--rg-theme-selection-border:var(--revo-grid-selection-border, #0d63e8);--rg-theme-selection-bg:var(--revo-grid-selection-bg, transparent);--rg-theme-autofill-handle-bg:var(     --revo-grid-autofill-handle-bg,     var(--rg-theme-selection-border)   );--rg-theme-autofill-handle-border:var(     --revo-grid-autofill-handle-border,     white   );--rg-theme-range-handle-bg:var(     --revo-grid-range-handle-bg,     rgba(0, 0, 0, 0.2)   );--rg-theme-temporary-range-border:var(     --revo-grid-temporary-range-border,     rgb(255, 94, 0)   );--rg-theme-temporary-selection-border:var(     --revo-grid-temporary-selection-border,     gray   );--rg-theme-header-resize-hover:var(     --revo-grid-header-resize-hover,     deepskyblue   );--rg-theme-button-text:var(--revo-grid-button-text, #fff);--rg-theme-button-bg:var(--revo-grid-button-bg, #4545ff);--rg-theme-button-success-bg:var(--revo-grid-button-success-bg, #009037);--rg-theme-button-danger-bg:var(--revo-grid-button-danger-bg, #e0662e);--rg-theme-button-outline-border:var(     --revo-grid-button-outline-border,     #dbdbdb   );--rg-theme-button-outline-text:var(--revo-grid-button-outline-text, #000)}revo-grid[data-rg-theme-scheme=dark]{color-scheme:dark;--rg-theme-background:var(--revo-grid-background, #212529);--rg-theme-foreground:var(--revo-grid-foreground, #fff);--rg-theme-text:var(--revo-grid-text, rgba(255, 255, 255, 0.9));--rg-theme-divider:var(--revo-grid-divider, #505050);--rg-theme-border:var(     --revo-grid-border,     rgba(255, 255, 255, 0.2)   );--rg-theme-filter-panel-bg:var(--revo-grid-filter-panel-bg, #212529);--rg-theme-filter-panel-border:var(     --revo-grid-filter-panel-border,     #505050   );--rg-theme-filter-panel-input-bg:var(     --revo-grid-filter-panel-input-bg,     #343a40   );--rg-theme-filter-panel-divider:var(     --revo-grid-filter-panel-divider,     #505050   );--rg-theme-filter-panel-icon-active:var(     --revo-grid-filter-panel-icon-active,     #fff   );--rg-theme-header-bg:var(--revo-grid-header-bg, #343a40);--rg-theme-header-color:var(--revo-grid-header-color, #fff);--rg-theme-header-border:var(--revo-grid-header-border, #505050);--rg-theme-cell-border:var(--revo-grid-cell-border, #424242);--rg-theme-focused-bg:var(     --revo-grid-focused-bg,     rgba(52, 58, 64, 0.5)   );--rg-theme-row-hover:var(     --revo-grid-row-hover,     rgba(80, 80, 80, 0.5)   );--rg-theme-row-headers-bg:var(     --revo-grid-row-headers-bg,     rgba(52, 58, 64, 0.8)   );--rg-theme-row-headers-color:var(     --revo-grid-row-headers-color,     rgba(255, 255, 255, 0.8)   );--rg-theme-cell-disabled-bg:var(     --revo-grid-cell-disabled-bg,     rgba(255, 255, 255, 0.07)   );--rg-theme-button-outline-border:var(     --revo-grid-button-outline-border,     #404040   );--rg-theme-button-outline-text:var(     --revo-grid-button-outline-text,     #d8d8d8   )}revo-grid[data-rg-theme-scheme=light]{color-scheme:light}revo-grid{}revo-grid>*{--revo-grid-primary:var(--rg-theme-primary);--revo-grid-primary-transparent:var(--rg-theme-primary-transparent);--revo-grid-background:var(--rg-theme-background);--revo-grid-foreground:var(--rg-theme-foreground);--revo-grid-divider:var(--rg-theme-divider);--revo-grid-shadow:var(--rg-theme-shadow);--revo-grid-text:var(--rg-theme-text);--revo-grid-border:var(--rg-theme-border);--revo-grid-header-bg:var(--rg-theme-header-bg);--revo-grid-header-color:var(--rg-theme-header-color);--revo-grid-header-border:var(--rg-theme-header-border);--revo-grid-header-focused-bg:var(--rg-theme-header-focused-bg);--revo-grid-header-hover-bg:var(--rg-theme-header-hover-bg);--revo-grid-cell-border:var(--rg-theme-cell-border);--revo-grid-cell-vertical-border:var(--rg-theme-cell-vertical-border);--revo-grid-focused-bg:var(--rg-theme-focused-bg);--revo-grid-row-hover:var(--rg-theme-row-hover);--revo-grid-row-headers-bg:var(--rg-theme-row-headers-bg);--revo-grid-row-headers-color:var(--rg-theme-row-headers-color);--revo-grid-cell-disabled-bg:var(--rg-theme-cell-disabled-bg);--revo-grid-filter-panel-bg:var(--rg-theme-filter-panel-bg);--revo-grid-filter-panel-border:var(--rg-theme-filter-panel-border);--revo-grid-filter-panel-shadow:var(--rg-theme-filter-panel-shadow);--revo-grid-filter-panel-input-bg:var(--rg-theme-filter-panel-input-bg);--revo-grid-filter-panel-divider:var(--rg-theme-filter-panel-divider);--revo-grid-filter-panel-select-border:var(--rg-theme-filter-panel-select-border);--revo-grid-filter-panel-select-border-hover:var(--rg-theme-filter-panel-select-border-hover);--revo-grid-filter-panel-reorder-accent:var(--rg-theme-filter-panel-reorder-accent);--revo-grid-filter-panel-reorder-color:var(--rg-theme-filter-panel-reorder-color);--revo-grid-filter-panel-text:var(--rg-theme-filter-panel-text);--revo-grid-filter-panel-muted-text:var(--rg-theme-filter-panel-muted-text);--revo-grid-filter-panel-focus-ring:var(--rg-theme-filter-panel-focus-ring);--revo-grid-filter-panel-icon:var(--rg-theme-filter-panel-icon);--revo-grid-filter-panel-icon-active:var(--rg-theme-filter-panel-icon-active);--revo-grid-font-family:var(--rg-theme-font-family);--revo-grid-font-size:var(--rg-theme-font-size);--revo-grid-header-height:var(--rg-theme-header-height);--revo-grid-header-font-size:var(--rg-theme-header-font-size);--revo-grid-header-font-weight:var(--rg-theme-header-font-weight);--revo-grid-header-text-transform:var(--rg-theme-header-text-transform);--revo-grid-header-text-align:var(--rg-theme-header-text-align);--revo-grid-cell-text-align:var(--rg-theme-cell-text-align);--revo-grid-header-padding:var(--rg-theme-header-padding);--revo-grid-cell-padding:var(--rg-theme-cell-padding);--revo-grid-selection-border:var(--rg-theme-selection-border);--revo-grid-selection-bg:var(--rg-theme-selection-bg);--revo-grid-autofill-handle-bg:var(--rg-theme-autofill-handle-bg);--revo-grid-autofill-handle-border:var(--rg-theme-autofill-handle-border);--revo-grid-range-handle-bg:var(--rg-theme-range-handle-bg);--revo-grid-temporary-range-border:var(--rg-theme-temporary-range-border);--revo-grid-temporary-selection-border:var(--rg-theme-temporary-selection-border);--revo-grid-header-resize-hover:var(--rg-theme-header-resize-hover);--revo-grid-button-text:var(--rg-theme-button-text);--revo-grid-button-bg:var(--rg-theme-button-bg);--revo-grid-button-success-bg:var(--rg-theme-button-success-bg);--revo-grid-button-danger-bg:var(--rg-theme-button-danger-bg);--revo-grid-button-outline-border:var(--rg-theme-button-outline-border);--revo-grid-button-outline-text:var(--rg-theme-button-outline-text)}revo-grid{direction:ltr !important}revo-grid revogr-header .header-rgRow.group{box-shadow:0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid revogr-header .header-rgRow:not(.group){box-shadow:0 -1px 0 0 var(--rg-theme-header-border), 0 -1px 0 0 var(--rg-theme-header-border) inset}revo-grid revogr-header .rgHeaderCell.sortable:hover{background-color:var(--rg-theme-header-hover-bg)}revo-grid revogr-header .rgHeaderCell.focused-cell{background:var(--rg-theme-header-focused-bg)}revo-grid .footer-wrapper revogr-data{box-shadow:0 -1px 0 var(--rg-theme-cell-border)}revo-grid revogr-viewport-scroll.colPinStart{box-shadow:-1px 0 0 var(--rg-theme-cell-border) inset}revo-grid revogr-viewport-scroll.colPinEnd{box-shadow:-1px 0 0 var(--rg-theme-cell-border)}revo-grid revogr-data .rgRow{box-shadow:0 -1px 0 0 var(--rg-theme-cell-border) inset}revo-grid revogr-data .rgRow.focused-rgRow{background-color:var(--rg-theme-focused-bg)}revo-grid revogr-data .rgCell{color:var(--rg-theme-text)}revo-grid revogr-data .rgCell.disabled{background-color:var(--rg-theme-cell-disabled-bg)}revo-grid{display:flex !important;height:100%;min-height:300px;background-color:var(--rg-theme-background);font-family:var(--rg-theme-font-family);font-size:var(--rg-theme-font-size);position:relative;color:var(--rg-theme-text);-webkit-touch-callout:none;-webkit-user-select:none;-khtml-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}revo-grid .attribution{position:absolute;bottom:0;left:0;right:0;z-index:1000;width:0;height:0;border-left:4px solid var(--rg-theme-primary-transparent);border-bottom:4px solid var(--rg-theme-primary-transparent);border-top:4px solid transparent;border-right:4px solid transparent;cursor:pointer}revo-grid .attribution .value{position:absolute;bottom:0;left:0;background-color:var(--rg-theme-background);padding:4px;border-radius:4px;box-shadow:0 1px 10px var(--rg-theme-border);white-space:nowrap;text-decoration:none;color:var(--rg-theme-text);letter-spacing:0.3px;font-size:11px;opacity:0;width:4px;overflow:hidden;transition:opacity 0.5s ease-in-out, width 0.3s ease-in-out}revo-grid .attribution:hover .value{width:63px;opacity:1}revo-grid.column-draggable.column-drag-start:hover,revo-grid.column-draggable.column-drag-start *:hover{cursor:grabbing}revo-grid .footer-wrapper,revo-grid .header-wrapper{width:100%}revo-grid .footer-wrapper revogr-data,revo-grid .header-wrapper revogr-data{z-index:3}revo-grid revo-dropdown{width:100%}revo-grid revo-dropdown .rv-dr-root{max-height:100%}revo-grid revo-dropdown.shrink label{opacity:0}revo-grid .viewports{max-width:100%;display:flex;flex-direction:row;align-items:flex-start;flex-grow:1}revo-grid{display:flex;flex-direction:column;width:100%;height:100%}revo-grid .main-viewport{flex-grow:1;height:0;display:flex;justify-content:space-between;flex-direction:row}revo-grid .draggable{position:fixed;height:30px;line-height:30px;background:var(--rg-theme-background);border-radius:3px;display:block;z-index:100;margin-top:5px;margin-right:-20px;box-shadow:0 4px 20px 0 var(--rg-theme-shadow);padding-left:20px;padding-right:5px}revo-grid .draggable.hidden{display:none}revo-grid .draggable .revo-alt-icon{background-color:var(--rg-theme-foreground);position:absolute;left:5px;top:10px}revo-grid .draggable-wrapper.hidden{display:none}revo-grid .drag-position{position:absolute;left:0;right:0;height:1px;z-index:2;background:var(--rg-theme-divider);pointer-events:none}revo-grid .drag-position-y{position:absolute;top:0;left:0;bottom:0;width:1px;z-index:2;background:var(--rg-theme-divider);pointer-events:none}revo-grid .drag-auto-scroll-y{pointer-events:none;position:absolute;left:0;top:0;height:50px;width:1px}revo-grid .clipboard{position:absolute;left:0;top:0}revo-grid revogr-scroll-virtual{position:relative}revo-grid revogr-scroll-virtual.vertical,revo-grid revogr-scroll-virtual.horizontal{z-index:3}`;
+var DEFAULT_COLUMN_SIZE = 100;
+function getColumnSize(size) {
+  return Number.isFinite(size) && size > 0 ? size : DEFAULT_COLUMN_SIZE;
+}
+var RevoGridComponent = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.contentsizechanged = createEvent(this, "contentsizechanged", 7);
+    this.beforeedit = createEvent(this, "beforeedit", 7);
+    this.beforerangeedit = createEvent(this, "beforerangeedit", 7);
+    this.afteredit = createEvent(this, "afteredit", 7);
+    this.beforeautofill = createEvent(this, "beforeautofill", 7);
+    this.beforerange = createEvent(this, "beforerange", 7);
+    this.afterfocus = createEvent(this, "afterfocus", 7);
+    this.roworderchanged = createEvent(this, "roworderchanged", 7);
+    this.beforesorting = createEvent(this, "beforesorting", 7);
+    this.beforesourcesortingapply = createEvent(this, "beforesourcesortingapply", 7);
+    this.beforesortingapply = createEvent(this, "beforesortingapply", 7);
+    this.aftersortingapply = createEvent(this, "aftersortingapply", 7);
+    this.rowdragstart = createEvent(this, "rowdragstart", 7);
+    this.headerclick = createEvent(this, "headerclick", 7);
+    this.beforecellfocus = createEvent(this, "beforecellfocus", 7);
+    this.beforefocuslost = createEvent(this, "beforefocuslost", 7);
+    this.beforesourceset = createEvent(this, "beforesourceset", 7);
+    this.beforeanysource = createEvent(this, "beforeanysource", 7);
+    this.aftersourceset = createEvent(this, "aftersourceset", 7);
+    this.afteranysource = createEvent(this, "afteranysource", 7);
+    this.beforecolumnsgather = createEvent(this, "beforecolumnsgather", 7);
+    this.beforecolumnsset = createEvent(this, "beforecolumnsset", 7);
+    this.beforecolumnapplied = createEvent(this, "beforecolumnapplied", 7);
+    this.aftercolumnsset = createEvent(this, "aftercolumnsset", 7);
+    this.beforefilterapply = createEvent(this, "beforefilterapply", 7);
+    this.beforefiltertrimmed = createEvent(this, "beforefiltertrimmed", 7);
+    this.beforetrimmed = createEvent(this, "beforetrimmed", 7);
+    this.aftertrimmed = createEvent(this, "aftertrimmed", 7);
+    this.viewportscroll = createEvent(this, "viewportscroll", 7);
+    this.beforeexport = createEvent(this, "beforeexport", 7);
+    this.beforeeditstart = createEvent(this, "beforeeditstart", 7);
+    this.aftercolumnresize = createEvent(this, "aftercolumnresize", 7);
+    this.beforerowdefinition = createEvent(this, "beforerowdefinition", 7);
+    this.filterconfigchanged = createEvent(this, "filterconfigchanged", 7);
+    this.sortingconfigchanged = createEvent(this, "sortingconfigchanged", 7);
+    this.rowheaderschanged = createEvent(this, "rowheaderschanged", 7);
+    this.beforegridrender = createEvent(this, "beforegridrender", 7);
+    this.aftergridrender = createEvent(this, "aftergridrender", 7);
+    this.aftergridinit = createEvent(this, "aftergridinit", 7);
+    this.additionaldatachanged = createEvent(this, "additionaldatachanged", 7);
+    this.afterthemechanged = createEvent(this, "afterthemechanged", 7);
+    this.created = createEvent(this, "created", 7);
+    this.frameSize = 1;
+    this.rowSize = 0;
+    this.colSize = 100;
+    this.range = false;
+    this.readonly = false;
+    this.resize = false;
+    this.noHorizontalScrollTransfer = false;
+    this.canFocus = true;
+    this.useClipboard = true;
+    this.columns = [];
+    this.source = [];
+    this.pinnedTopSource = [];
+    this.pinnedBottomSource = [];
+    this.rowDefinitions = [];
+    this.editors = {};
+    this.applyOnClose = false;
+    this.plugins = [];
+    this.columnTypes = {};
+    this.theme = "default";
+    this.themeDefinitions = [];
+    this.rowClass = "";
+    this.autoSizeColumn = false;
+    this.filter = false;
+    this.canMoveColumns = false;
+    this.trimmedRows = {};
+    this.exporting = false;
+    this.stretch = false;
+    this.additionalData = {};
+    this.disableVirtualX = false;
+    this.virtualX = ["rgCol"];
+    this.disableVirtualY = false;
+    this.hideAttribution = false;
+    this.jobsBeforeRender = [];
+    this.registerVNode = [];
+    this.accessible = true;
+    this.rtl = false;
+    this.canDrag = true;
+    this.extraElements = [];
+    this.pluginService = new PluginService();
+    this.viewport = null;
+    this.isInited = false;
+    this.themeStyles = {};
+  }
+  // #endregion
+  // #region Methods
+  /**
+   * Refreshes data viewport.
+   * Can be specific part as rgRow or pinned rgRow or 'all' by default.
+   */
+  async refresh(type = "all") {
+    if (!this.dataProvider) {
+      throw new Error("Not connected");
+    }
+    this.dataProvider.refresh(type);
+  }
+  /**
+   * Refreshes data at specified cell.
+   * Useful for performance optimization.
+   * No viewport update will be triggered.
+   *
+   * @example
+   * const grid = document.querySelector('revo-grid');
+   * grid.setDataAt({ row: 0, col: 0, val: 'test' }); // refresh
+   */
+  async setDataAt({ row, col, colType = "rgCol", rowType = "rgRow", val, skipDataUpdate = false }) {
+    var _a;
+    if (this.dataProvider && this.columnProvider && !skipDataUpdate) {
+      const columnProp = (_a = this.columnProvider.getColumn(col, colType)) === null || _a === void 0 ? void 0 : _a.prop;
+      if (typeof columnProp !== "undefined") {
+        this.dataProvider.setCellData({
+          type: rowType,
+          rowIndex: row,
+          prop: columnProp,
+          val
+        }, false);
+      }
+    }
+    const dataElement = this.element.querySelector(`revogr-data[type="${rowType}"][col-type="${colType}"]`);
+    return dataElement === null || dataElement === void 0 ? void 0 : dataElement.updateCell({
+      row,
+      col
+    });
+  }
+  /**
+   * Scrolls viewport to specified row by index.
+   */
+  async scrollToRow(coordinate = 0) {
+    if (!this.dimensionProvider) {
+      throw new Error("Not connected");
+    }
+    const y = this.dimensionProvider.getViewPortPos({
+      coordinate,
+      dimension: "rgRow"
+    });
+    await this.scrollToCoordinate({ y });
+  }
+  /**
+   * Scrolls viewport to specified column by index.
+   */
+  async scrollToColumnIndex(coordinate = 0) {
+    if (!this.dimensionProvider) {
+      throw new Error("Not connected");
+    }
+    const x = this.dimensionProvider.getViewPortPos({
+      coordinate,
+      dimension: "rgCol"
+    });
+    await this.scrollToCoordinate({ x });
+  }
+  /**
+   * Scrolls viewport to specified column by prop
+   */
+  async scrollToColumnProp(prop, dimension = "rgCol") {
+    if (!this.dimensionProvider || !this.columnProvider) {
+      throw new Error("Not connected");
+    }
+    const coordinate = this.columnProvider.getColumnIndexByProp(prop, dimension);
+    if (coordinate < 0) {
+      return;
+    }
+    const x = this.dimensionProvider.getViewPortPos({
+      coordinate,
+      dimension
+    });
+    await this.scrollToCoordinate({ x });
+  }
+  /** Update columns */
+  async updateColumns(cols) {
+    var _a;
+    (_a = this.columnProvider) === null || _a === void 0 ? void 0 : _a.updateColumns(cols);
+  }
+  /** Add trimmed by type */
+  async addTrimmed(trimmed, trimmedType = "external", type = "rgRow") {
+    if (!this.dataProvider) {
+      throw new Error("Not connected");
+    }
+    const event = this.beforetrimmed.emit({
+      trimmed,
+      trimmedType,
+      type
+    });
+    if (event.defaultPrevented) {
+      return event;
+    }
+    this.dataProvider.setTrimmed({ [trimmedType]: event.detail.trimmed }, type);
+    this.aftertrimmed.emit();
+    return event;
+  }
+  /**  Scrolls view port to coordinate */
+  async scrollToCoordinate(cell) {
+    var _a;
+    (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.scrollToCell(cell);
+  }
+  /**  Open editor for cell. */
+  async setCellEdit(rgRow, prop, rowSource = "rgRow") {
+    var _a;
+    const rgCol = getColumnByProp(this.columns, prop);
+    if (!rgCol) {
+      return;
+    }
+    await timeout();
+    const colGroup = rgCol.pin || "rgCol";
+    if (!this.columnProvider) {
+      throw new Error("Not connected");
+    }
+    (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.setEdit(rgRow, this.columnProvider.getColumnIndexByProp(prop, colGroup), colGroup, rowSource);
+  }
+  /**  Set focus range. */
+  async setCellsFocus(cellStart = { x: 0, y: 0 }, cellEnd = { x: 0, y: 0 }, colType = "rgCol", rowType = "rgRow") {
+    var _a;
+    (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.setFocus(colType, rowType, cellStart, cellEnd);
+  }
+  /**  Get data from source */
+  async getSource(type = "rgRow") {
+    if (!this.dataProvider) {
+      throw new Error("Not connected");
+    }
+    return this.dataProvider.stores[type].store.get("source");
+  }
+  /**
+   * Get data from visible part of source
+   * Trimmed/filtered rows will be excluded
+   * @param type - type of source
+   */
+  async getVisibleSource(type = "rgRow") {
+    if (!this.dataProvider) {
+      throw new Error("Not connected");
+    }
+    return getVisibleSourceItem(this.dataProvider.stores[type].store);
+  }
+  /**
+   * Provides access to rows internal store observer
+   * Can be used for plugin support
+   * @param type - type of source
+   */
+  async getSourceStore(type = "rgRow") {
+    if (!this.dataProvider) {
+      throw new Error("Not connected");
+    }
+    return this.dataProvider.stores[type].store;
+  }
+  /**
+   * Provides access to column internal store observer
+   * Can be used for plugin support
+   * @param type - type of column
+   */
+  async getColumnStore(type = "rgCol") {
+    if (!this.columnProvider) {
+      throw new Error("Not connected");
+    }
+    return this.columnProvider.stores[type].store;
+  }
+  /**
+   * Update column sorting
+   * @param column - column prop and cellCompare
+   * @param order - order to apply
+   * @param additive - if false will replace current order
+   *
+   * later passed to SortingPlugin
+   */
+  async updateColumnSorting(column, order, additive) {
+    this.sortingconfigchanged.emit({
+      columns: [{
+        prop: column.prop,
+        order,
+        cellCompare: column.cellCompare
+      }],
+      additive
+    });
+  }
+  /**
+   * Clears column sorting
+   */
+  async clearSorting() {
+    this.sortingconfigchanged.emit({
+      columns: []
+    });
+  }
+  /**
+   * Receive all columns in data source
+   */
+  async getColumns() {
+    if (!this.columnProvider) {
+      throw new Error("Not connected");
+    }
+    return this.columnProvider.getColumns();
+  }
+  /**
+   * Clear current grid focus. Grid has no longer focus on it.
+   */
+  async clearFocus() {
+    var _a, _b;
+    const focused = (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.getFocused();
+    const event = this.beforefocuslost.emit(focused);
+    if (event.defaultPrevented) {
+      return;
+    }
+    (_b = this.selectionStoreConnector) === null || _b === void 0 ? void 0 : _b.clearAll();
+  }
+  /**
+   * Get all active plugins instances
+   */
+  async getPlugins() {
+    return this.pluginService.get();
+  }
+  /**
+   * Get the currently focused cell.
+   */
+  async getFocused() {
+    var _a, _b;
+    return (_b = (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.getFocused()) !== null && _b !== void 0 ? _b : null;
+  }
+  /**
+   * Get size of content
+   * Including all pinned data
+   */
+  async getContentSize() {
+    var _a;
+    if (!this.dimensionProvider) {
+      throw new Error("Not connected");
+    }
+    return (_a = this.dimensionProvider) === null || _a === void 0 ? void 0 : _a.getFullSize();
+  }
+  /**
+   * Get the currently selected Range.
+   */
+  async getSelectedRange() {
+    var _a, _b;
+    return (_b = (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.getSelectedRange()) !== null && _b !== void 0 ? _b : null;
+  }
+  /**
+   * Refresh extra elements. Triggers re-rendering of extra elements and functions.
+   * Part of extraElements and registerVNode methods.
+   * Useful for plugins.
+   */
+  async refreshExtraElements() {
+    var _a;
+    (_a = this.extraService) === null || _a === void 0 ? void 0 : _a.refresh();
+  }
+  /**
+   * Get all providers for grid
+   * Useful for external grid integration
+   */
+  async getProviders() {
+    return this.getPluginData();
+  }
+  mousedownHandle(event) {
+    const screenX = getPropertyFromEvent(event, "screenX");
+    const screenY = getPropertyFromEvent(event, "screenY");
+    if (screenX === null || screenY === null) {
+      return;
+    }
+    this.clickTrackForFocusClear = screenX + screenY;
+  }
+  /**
+   * To keep your elements from losing focus use mouseup/touchend e.preventDefault();
+   */
+  async mouseupHandle(event) {
+    var _a;
+    const screenX = getPropertyFromEvent(event, "screenX");
+    const screenY = getPropertyFromEvent(event, "screenY");
+    if (screenX === null || screenY === null) {
+      return;
+    }
+    if (event.defaultPrevented) {
+      return;
+    }
+    const pos = screenX + screenY;
+    if (Math.abs(((_a = this.clickTrackForFocusClear) !== null && _a !== void 0 ? _a : 0) - pos) > 10) {
+      return;
+    }
+    const path = event.composedPath();
+    if (!path.includes(this.element) && !(this.element.shadowRoot && path.includes(this.element.shadowRoot))) {
+      await this.clearFocus();
+    }
+  }
+  // #endregion
+  // #region Listeners
+  /** Drag events */
+  onRowDragStarted(e) {
+    var _a;
+    const dragStart = this.rowdragstart.emit(e.detail);
+    if (dragStart.defaultPrevented) {
+      e.preventDefault();
+      return;
+    }
+    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.start(this.element, Object.assign(Object.assign({}, e.detail), dragStart.detail));
+  }
+  onRowDragEnd() {
+    var _a;
+    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.end();
+  }
+  onRowOrderChange(e) {
+    var _a;
+    (_a = this.dataProvider) === null || _a === void 0 ? void 0 : _a.changeOrder(e.detail);
+  }
+  onRowDrag({ detail }) {
+    var _a;
+    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.move(detail);
+  }
+  onRowMouseMove(e) {
+    var _a;
+    (_a = this.orderService) === null || _a === void 0 ? void 0 : _a.moveTip(e.detail);
+  }
+  async onCellEdit(e) {
+    var _a;
+    const { defaultPrevented, detail } = this.beforeedit.emit(e.detail);
+    await timeout();
+    if (!defaultPrevented) {
+      (_a = this.dataProvider) === null || _a === void 0 ? void 0 : _a.setCellData(detail);
+      this.afteredit.emit(detail);
+    }
+  }
+  onRangeEdit(e) {
+    if (!this.dataProvider) {
+      throw new Error("Not connected");
+    }
+    const { defaultPrevented, detail } = this.beforerangeedit.emit(e.detail);
+    if (defaultPrevented) {
+      e.preventDefault();
+      return;
+    }
+    this.dataProvider.setRangeData(detail.data, detail.type);
+    this.afteredit.emit(detail);
+  }
+  onRangeChanged(e) {
+    const beforeange = this.beforerange.emit(e.detail);
+    if (beforeange.defaultPrevented) {
+      e.preventDefault();
+    }
+    const beforeFill = this.beforeautofill.emit(beforeange.detail);
+    if (beforeFill.defaultPrevented) {
+      e.preventDefault();
+    }
+  }
+  onRowDropped(e) {
+    const { defaultPrevented } = this.roworderchanged.emit(e.detail);
+    if (defaultPrevented) {
+      e.preventDefault();
+    }
+  }
+  onHeaderClick(e) {
+    const { defaultPrevented } = this.headerclick.emit(Object.assign(Object.assign({}, e.detail.column), { originalEvent: e.detail.originalEvent }));
+    if (defaultPrevented) {
+      e.preventDefault();
+    }
+  }
+  onCellFocus(e) {
+    const { defaultPrevented } = this.beforecellfocus.emit(e.detail);
+    if (!this.canFocus || defaultPrevented) {
+      e.preventDefault();
+    }
+  }
+  // #endregion
+  // #region Watchers
+  columnTypesChanged() {
+    this.columnChanged(this.columns);
+  }
+  columnChanged(newVal = [], _prevVal = void 0, __watchName = "columns", init = false) {
+    if (!this.dimensionProvider || !this.columnProvider) {
+      return;
+    }
+    const focusToRestore = init ? void 0 : this.getColumnFocusRestore();
+    const beforeGatherEvent = this.beforecolumnsgather.emit({
+      columns: [...newVal]
+    });
+    if (beforeGatherEvent.defaultPrevented) {
+      return;
+    }
+    const columnGather = getColumns(beforeGatherEvent.detail.columns, 0, this.columnTypes);
+    const beforeSetEvent = this.beforecolumnsset.emit(columnGather);
+    if (beforeSetEvent.defaultPrevented) {
+      return;
+    }
+    this.dimensionProvider.applyNewColumns(beforeSetEvent.detail.columns, this.disableVirtualX, init, this.virtualX);
+    const beforeApplyEvent = this.beforecolumnapplied.emit(columnGather);
+    if (beforeApplyEvent.defaultPrevented) {
+      return;
+    }
+    const columns = this.columnProvider.setColumns(beforeApplyEvent.detail);
+    if (focusToRestore) {
+      this.pendingColumnFocusRestore = focusToRestore;
+    }
+    const order = {};
+    for (const prop of Object.keys(beforeApplyEvent.detail.sort)) {
+      order[prop] = beforeApplyEvent.detail.sort[prop].order;
+    }
+    this.aftercolumnsset.emit({
+      columns,
+      order
+    });
+  }
+  /**
+   * Capture logical focus before columns are repartitioned by pin state.
+   * Regression case: selecting a regular cell, then pinning that column left,
+   * used to let the new pinned viewport reuse the old rgCol selection store.
+   */
+  getColumnFocusRestore() {
+    var _a, _b, _c, _d;
+    const focused = (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.getFocused();
+    const prevStoreX = (_c = (_b = this.selectionStoreConnector) === null || _b === void 0 ? void 0 : _b.focusedStore) === null || _c === void 0 ? void 0 : _c.position.x;
+    const prop = (_d = focused === null || focused === void 0 ? void 0 : focused.column) === null || _d === void 0 ? void 0 : _d.prop;
+    if (!focused || prop === void 0 || prevStoreX === void 0) {
+      return;
+    }
+    return {
+      prop,
+      colType: focused.colType,
+      colIndex: focused.cell.x,
+      prevStoreX,
+      rowType: focused.rowType,
+      rowIndex: focused.cell.y
+    };
+  }
+  /**
+   * Reapply focus by column prop after render, once pinning has moved the
+   * column to its new viewport and virtual index.
+   */
+  restoreColumnFocusAfterRender() {
+    var _a, _b, _c, _d;
+    const pending = this.pendingColumnFocusRestore;
+    if (!pending) {
+      return;
+    }
+    this.pendingColumnFocusRestore = void 0;
+    if (!this.viewport || !this.columnProvider) {
+      return;
+    }
+    const column = (_b = (_a = this.columnProvider.getColumnByProp(pending.prop)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : getColumnByProp(this.columns, pending.prop);
+    if (!column) {
+      return;
+    }
+    const colType = column.pin || "rgCol";
+    const columnIndex = this.columnProvider.getColumnIndexByProp(pending.prop, colType);
+    if (columnIndex < 0) {
+      return;
+    }
+    if (colType === pending.colType && columnIndex === pending.colIndex && pending.prevStoreX === ((_d = (_c = this.selectionStoreConnector) === null || _c === void 0 ? void 0 : _c.focusedStore) === null || _d === void 0 ? void 0 : _d.position.x)) {
+      return;
+    }
+    const cell = {
+      x: columnIndex,
+      y: pending.rowIndex
+    };
+    this.viewport.setFocus(colType, pending.rowType, cell, cell);
+  }
+  refreshColumnsOnConfigChange(newVal, prevVal) {
+    if (newVal === prevVal) {
+      return;
+    }
+    this.columnChanged(this.columns);
+  }
+  disableVirtualXChanged(newVal = false, prevVal = false) {
+    this.refreshColumnsOnConfigChange(newVal, prevVal);
+  }
+  virtualXChanged(newVal = ["rgCol"], prevVal = ["rgCol"]) {
+    this.refreshColumnsOnConfigChange(newVal, prevVal);
+  }
+  rowSizeChanged(s) {
+    if (!this.themeService || !this.dimensionProvider) {
+      return;
+    }
+    this.themeService.rowSize = s;
+    this.applyTheme(this.theme, false, false, "rowSize");
+  }
+  colSizeChanged(s) {
+    if (!this.dimensionProvider || !this.columnProvider) {
+      return;
+    }
+    this.dimensionProvider.setSettings({ originItemSize: getColumnSize(s) }, "rgCol");
+    this.columnChanged(this.columns);
+  }
+  themeChanged(t, _, __ = "theme", init = false) {
+    if (!this.themeService || !this.dimensionProvider) {
+      return;
+    }
+    if (this.pendingNormalizedTheme === t) {
+      this.pendingNormalizedTheme = void 0;
+      return;
+    }
+    const normalizedTheme = getTheme(t);
+    if (normalizedTheme !== t) {
+      this.pendingNormalizedTheme = normalizedTheme;
+      this.theme = normalizedTheme;
+    }
+    this.applyTheme(normalizedTheme, init, true, "theme");
+  }
+  themeDefinitionsChanged(definitions = []) {
+    if (!this.themeService || !this.dimensionProvider) {
+      return;
+    }
+    this.themeService.setDefinitions(definitions);
+    this.applyTheme(this.theme, false, true, "themeDefinitions");
+  }
+  applyTheme(theme, init, emitEvent, reason) {
+    var _a;
+    const resolvedTheme = this.themeService.register(theme);
+    const rowSize = this.themeService.rowSize;
+    const densityChanged = this.appliedThemeRowSize !== rowSize;
+    const hadAppliedTheme = this.appliedThemeRowSize !== void 0;
+    this.appliedThemeRowSize = rowSize;
+    this.themeStyles = this.getThemeStyles();
+    if (densityChanged) {
+      (_a = this.dimensionProvider) === null || _a === void 0 ? void 0 : _a.setSettings({ originItemSize: rowSize }, "rgRow");
+      if (!init && hadAppliedTheme) {
+        this.rowDefChanged(this.rowDefinitions, this.rowDefinitions, reason, true);
+      }
+    }
+    if (emitEvent) {
+      this.afterthemechanged.emit(resolvedTheme.name);
+    }
+  }
+  getThemeStyles() {
+    const styles = {
+      "--rg-theme-row-size": `${this.themeService.rowSize}px`
+    };
+    for (const [name, value] of Object.entries(this.themeService.theme.tokens)) {
+      const cssVariable = themeTokenCssVariables[name];
+      if (cssVariable && value) {
+        styles[cssVariable] = value;
+      }
+    }
+    return styles;
+  }
+  dataSourceChanged(newVal = [], _, watchName) {
+    if (!this.dataProvider) {
+      return;
+    }
+    let type = "rgRow";
+    switch (watchName) {
+      case "pinnedBottomSource":
+        type = "rowPinEnd";
+        break;
+      case "pinnedTopSource":
+        type = "rowPinStart";
+        break;
+      case "source":
+        type = "rgRow";
+        const beforesourceset2 = this.beforesourceset.emit({
+          type,
+          source: newVal
+        });
+        newVal = beforesourceset2.detail.source;
+        break;
+    }
+    const beforesourceset = this.beforeanysource.emit({
+      type,
+      source: newVal
+    });
+    const newSource = [...beforesourceset.detail.source];
+    this.dataProvider.setData(newSource, type, this.disableVirtualY);
+    if (watchName === "source") {
+      this.aftersourceset.emit({
+        type,
+        source: newVal
+      });
+    }
+    this.afteranysource.emit({
+      type,
+      source: newVal
+    });
+  }
+  disableVirtualYChanged(newVal = false, prevVal = false) {
+    if (newVal === prevVal) {
+      return;
+    }
+    this.dataSourceChanged(this.source, this.source, "source");
+  }
+  rowDefChanged(after, before, _watchName, forceUpdate = true) {
+    if (!this.dimensionProvider || !this.dataProvider) {
+      return;
+    }
+    const { detail: { vals: newVal, oldVals: oldVal } } = this.beforerowdefinition.emit({
+      vals: after,
+      oldVals: before
+    });
+    const newRows = rowDefinitionByType(newVal);
+    if (oldVal) {
+      const remove = rowDefinitionRemoveByType(oldVal);
+      for (const t in remove) {
+        if (remove.hasOwnProperty(t)) {
+          const type = t;
+          const store = this.dataProvider.stores[type];
+          const sourceLength = store.store.get("source").length;
+          this.dimensionProvider.clearSize(type, sourceLength);
+        }
+      }
+    }
+    rowTypes.forEach((t) => {
+      var _a;
+      const newSizes = newRows[t];
+      if (newSizes || forceUpdate) {
+        (_a = this.dimensionProvider) === null || _a === void 0 ? void 0 : _a.setCustomSizes(t, (newSizes === null || newSizes === void 0 ? void 0 : newSizes.sizes) || {});
+      }
+    });
+  }
+  trimmedRowsChanged(newVal = {}) {
+    this.addTrimmed(newVal);
+  }
+  /**
+   * Grouping
+   */
+  groupingChanged(newVal = {}) {
+    var _a;
+    (_a = this.pluginService.getByClass(GroupingRowPlugin)) === null || _a === void 0 ? void 0 : _a.setGrouping(newVal || {});
+  }
+  /**
+   * Stretch Plugin Apply
+   */
+  applyStretch(isStretch) {
+    if (!this.dimensionProvider || !this.dataProvider || !this.columnProvider || !this.viewportProvider) {
+      return;
+    }
+    if (isStretch === "false") {
+      isStretch = false;
+    }
+    const pluginData = this.getPluginData();
+    if (!pluginData) {
+      return;
+    }
+    const stretch = this.pluginService.getByClass(StretchColumn);
+    if (typeof isStretch === "boolean" && isStretch || isStretch === "true") {
+      if (!stretch) {
+        this.pluginService.add(new StretchColumn(this.element, pluginData));
+      } else if (isStretchPlugin(stretch)) {
+        stretch.applyStretch(this.columnProvider.getRawColumns());
+      }
+    } else if (stretch) {
+      this.pluginService.remove(stretch);
+    }
+  }
+  applyFilter(cfg) {
+    this.filterconfigchanged.emit(cfg);
+  }
+  applySorting(cfg) {
+    this.sortingconfigchanged.emit(cfg);
+  }
+  rowHeadersChange(rowHeaders) {
+    this.rowheaderschanged.emit(rowHeaders);
+  }
+  /**
+   * Register external VNodes
+   */
+  registerOutsideVNodes(elements = []) {
+    this.extraElements = elements;
+  }
+  additionalDataChanged(data) {
+    this.additionaldatachanged.emit(data);
+  }
+  /**
+   * Watch for RTL changes and reapply column ordering
+   */
+  rtlChanged() {
+    this.columnChanged(this.columns);
+  }
+  /**
+   * User can add plugins via plugins property
+   */
+  pluginsChanged(plugins = [], prevPlugins) {
+    this.pluginService.addUserPluginsAndCreate(this.element, plugins, prevPlugins, this.getPluginData());
+  }
+  // #endregion
+  // #region Plugins
+  setPlugins() {
+    this.removePlugins();
+    const pluginData = this.getPluginData();
+    if (!pluginData) {
+      return;
+    }
+    this.setCorePlugins(pluginData);
+    this.pluginsChanged(this.plugins);
+  }
+  setCorePlugins(pluginData) {
+    if (this.accessible) {
+      this.pluginService.add(new WCAGPlugin(this.element, pluginData));
+    }
+    this.pluginService.add(new RTLPlugin(this.element, pluginData));
+    if (this.autoSizeColumn) {
+      this.pluginService.add(new AutoSizeColumnPlugin(this.element, pluginData, typeof this.autoSizeColumn === "object" ? this.autoSizeColumn : void 0));
+    }
+    if (this.filter) {
+      this.pluginService.add(new FilterPlugin(this.element, pluginData, typeof this.filter === "object" ? this.filter : void 0));
+    }
+    if (this.exporting) {
+      this.pluginService.add(new ExportFilePlugin(this.element, pluginData));
+    }
+    this.pluginService.add(new SortingPlugin(this.element, pluginData));
+    this.pluginService.add(new GroupingRowPlugin(this.element, pluginData));
+    if (this.canMoveColumns) {
+      this.pluginService.add(new ColumnMovePlugin(this.element, pluginData));
+    }
+  }
+  getPluginData() {
+    if (!this.dimensionProvider || !this.dataProvider || !this.columnProvider || !this.viewportProvider || !this.selectionStoreConnector) {
+      return;
+    }
+    const pluginData = {
+      data: this.dataProvider,
+      column: this.columnProvider,
+      dimension: this.dimensionProvider,
+      viewport: this.viewportProvider,
+      selection: this.selectionStoreConnector,
+      plugins: this.pluginService
+    };
+    return pluginData;
+  }
+  removePlugins() {
+    this.pluginService.destroy();
+  }
+  // #endregion
+  // if reconnect to dom we need to set up plugins
+  connectedCallback() {
+    if (this.isInited) {
+      this.setPlugins();
+    }
+    this.created.emit();
+  }
+  /**
+   * Called once just after the component is first connected to the DOM.
+   * Since this method is only called once, it's a good place to load data asynchronously and to setup the state
+   * without triggering extra re-renders.
+   * A promise can be returned, that can be used to wait for the first render().
+   */
+  componentWillLoad() {
+    var _a;
+    this.viewportProvider = new ViewportProvider();
+    this.themeService = new ThemeService({
+      rowSize: this.rowSize
+    });
+    this.themeService.setDefinitions(this.themeDefinitions);
+    this.dimensionProvider = new DimensionProvider(this.viewportProvider, {
+      realSizeChanged: (k) => this.contentsizechanged.emit(k)
+    });
+    this.dimensionProvider.setSettings({ originItemSize: getColumnSize(this.colSize) }, "rgCol");
+    this.columnProvider = new ColumnDataProvider();
+    this.selectionStoreConnector = new SelectionStoreConnector();
+    this.dataProvider = new DataProvider(this.dimensionProvider);
+    this.registerOutsideVNodes(this.registerVNode);
+    this.setPlugins();
+    this.applyStretch(this.stretch);
+    this.themeChanged(this.theme, void 0, void 0, true);
+    this.columnChanged(this.columns, void 0, void 0, true);
+    this.dataSourceChanged(this.source, void 0, "source");
+    this.dataSourceChanged(this.pinnedTopSource, void 0, "pinnedTopSource");
+    this.dataSourceChanged(this.pinnedBottomSource, void 0, "pinnedBottomSource");
+    if (Object.keys((_a = this.trimmedRows) !== null && _a !== void 0 ? _a : {}).length > 0) {
+      this.trimmedRowsChanged(this.trimmedRows);
+    }
+    this.rowDefChanged(this.rowDefinitions, void 0, void 0, false);
+    if (this.grouping && Object.keys(this.grouping).length > 0) {
+      this.groupingChanged(this.grouping);
+    }
+    this.scrollingService = new GridScrollingService((e) => {
+      var _a2;
+      (_a2 = this.dimensionProvider) === null || _a2 === void 0 ? void 0 : _a2.setViewPortCoordinate({
+        coordinate: e.coordinate,
+        type: e.dimension
+      });
+      this.viewportscroll.emit(e);
+    });
+    this.aftergridinit.emit();
+    this.isInited = true;
+  }
+  componentWillRender() {
+    const event = this.beforegridrender.emit();
+    if (event.defaultPrevented) {
+      return false;
+    }
+    return Promise.all(this.jobsBeforeRender);
+  }
+  componentDidRender() {
+    this.restoreColumnFocusAfterRender();
+    this.aftergridrender.emit();
+  }
+  render() {
+    if (!this.dimensionProvider || !this.dataProvider || !this.columnProvider || !this.viewportProvider || !this.selectionStoreConnector) {
+      return;
+    }
+    const contentHeight = this.dimensionProvider.stores["rgRow"].store.get("realSize");
+    this.viewport = new ViewportService({
+      columnProvider: this.columnProvider,
+      dataProvider: this.dataProvider,
+      dimensionProvider: this.dimensionProvider,
+      viewportProvider: this.viewportProvider,
+      scrollingService: this.scrollingService,
+      orderService: this.orderService,
+      selectionStoreConnector: this.selectionStoreConnector,
+      noHorizontalScrollTransfer: this.noHorizontalScrollTransfer,
+      disableVirtualX: this.disableVirtualX,
+      virtualX: this.virtualX,
+      disableVirtualY: this.disableVirtualY,
+      resize: (c) => this.aftercolumnresize.emit(c)
+    }, contentHeight);
+    const viewportSections = [];
+    if (this.rowHeaders && this.viewport.columns.length) {
+      const anyView = this.viewport.columns[0];
+      viewportSections.push(h("revogr-row-headers", { additionalData: this.additionalData, height: contentHeight, rowClass: this.rowClass, resize: this.resize, dataPorts: anyView.dataPorts, headerProp: anyView.headerProp, jobsBeforeRender: this.jobsBeforeRender, rowHeaderColumn: typeof this.rowHeaders === "object" ? this.rowHeaders : void 0, onScrollview: ({ detail: e }) => this.scrollingService.proxyScroll(e, "headerRow"), onRef: ({ detail: e }) => this.scrollingService.registerElement(e, "headerRow") }));
+    }
+    const isMobile = isMobileDevice();
+    const viewPortHtml = [];
+    for (let view of this.viewport.columns) {
+      const headerProperties = Object.assign(Object.assign({}, view.headerProp), { type: view.type, additionalData: this.additionalData, viewportCol: view.viewportCol, selectionStore: view.columnSelectionStore, canResize: this.resize, readonly: this.readonly, columnFilter: !!this.filter });
+      const dataViews = [
+        h("revogr-header", Object.assign({}, headerProperties, { slot: HEADER_SLOT }))
+      ];
+      view.dataPorts.forEach((data) => {
+        const key = `${data.type}_${view.type}`;
+        const dataView = h("revogr-overlay-selection", Object.assign({}, data, { canDrag: this.canDrag && data.canDrag, isMobileDevice: isMobile, onSelectall: () => {
+          var _a;
+          return (_a = this.selectionStoreConnector) === null || _a === void 0 ? void 0 : _a.selectAll();
+        }, editors: this.editors, readonly: this.readonly, range: this.range, useClipboard: this.useClipboard, applyChangesOnClose: this.applyOnClose, additionalData: this.additionalData, slot: data.slot, onBeforenextvpfocus: (e) => {
+          var _a;
+          return (_a = this.selectionStoreConnector) === null || _a === void 0 ? void 0 : _a.beforeNextFocusCell(e.detail);
+        }, onCanceledit: () => {
+          var _a;
+          return (_a = this.selectionStoreConnector) === null || _a === void 0 ? void 0 : _a.setEdit(false);
+        }, onSetedit: (e) => {
+          var _a;
+          const event = this.beforeeditstart.emit(e.detail);
+          if (event.defaultPrevented) {
+            e.preventDefault();
+          } else {
+            (_a = this.selectionStoreConnector) === null || _a === void 0 ? void 0 : _a.setEdit(e.detail.val);
+          }
+        } }), h("revogr-data", Object.assign({}, data, { colType: view.type, key, readonly: this.readonly, range: this.range, rowClass: this.rowClass, rowSelectionStore: data.rowSelectionStore, additionalData: this.additionalData, jobsBeforeRender: this.jobsBeforeRender, slot: DATA_SLOT }), h("slot", { name: `data-${view.type}-${data.type}` })), h("revogr-temp-range", { selectionStore: data.selectionStore, dimensionRow: data.dimensionRow, dimensionCol: data.dimensionCol }), h("revogr-focus", { colData: data.colData, dataStore: data.dataStore, focusTemplate: this.focusTemplate, rowType: data.type, colType: view.type, selectionStore: data.selectionStore, dimensionRow: data.dimensionRow, dimensionCol: data.dimensionCol }, h("slot", { name: `focus-${view.type}-${data.type}` })));
+        dataViews.push(dataView);
+      });
+      viewPortHtml.push(h("revogr-viewport-scroll", Object.assign({}, view.prop, { ref: (el) => this.scrollingService.registerElement(el, `${view.prop.key}`), onScrollviewport: (e) => {
+        this.scrollingService.proxyScroll(e.detail, `${view.prop.key}`, this.noHorizontalScrollTransfer && e.detail.dimension === "rgCol");
+      }, onScrollviewportsilent: (e) => this.scrollingService.scrollSilentService(e.detail, `${view.prop.key}`) }), dataViews));
+    }
+    viewportSections.push(viewPortHtml);
+    const typeRow = "rgRow";
+    const typeCol = "rgCol";
+    const viewports = this.viewportProvider.stores;
+    const dimensions = this.dimensionProvider.stores;
+    const verticalScroll = h("revogr-scroll-virtual", { class: "vertical", dimension: typeRow, clientSize: viewports[typeRow].store.get("clientSize"), virtualSize: viewports[typeRow].store.get("virtualSize"), realSize: dimensions[typeRow].store.get("realSize"), ref: (el) => this.scrollingService.registerElement(el, "rowScroll"), onScrollvirtual: (e) => this.scrollingService.proxyScroll(e.detail) });
+    const horizontalScroll = h("revogr-scroll-virtual", { class: "horizontal", dimension: typeCol, clientSize: viewports[typeCol].store.get("clientSize"), virtualSize: viewports[typeCol].store.get("virtualSize"), realSize: dimensions[typeCol].store.get("realSize"), ref: (el) => this.scrollingService.registerElement(el, "colScroll"), onScrollvirtual: (e) => this.scrollingService.proxyScroll(e.detail) });
+    return h(Host, { dir: this.rtl ? "rtl" : "ltr", "data-rg-theme-scheme": this.themeService.theme.colorScheme, style: this.themeStyles }, this.hideAttribution ? null : h("revogr-attribution", { class: "attribution" }), h("slot", { name: "header" }), h("div", { class: "main-viewport", onClick: (e) => {
+      var _a;
+      if (e.currentTarget === e.target) {
+        (_a = this.viewport) === null || _a === void 0 ? void 0 : _a.clearEdit();
+      }
+    } }, h("div", { class: "viewports" }, h("slot", { name: "viewport" }), viewportSections, verticalScroll, h(OrderRenderer, { ref: (e) => this.orderService = e }))), horizontalScroll, h("revogr-extra", { ref: (el) => this.extraService = el, nodes: this.extraElements }), h("slot", { name: "footer" }));
+  }
+  disconnectedCallback() {
+    this.removePlugins();
+  }
+  get element() {
+    return getElement(this);
+  }
+  static get watchers() {
+    return {
+      "columnTypes": [{
+        "columnTypesChanged": 0
+      }],
+      "columns": [{
+        "columnChanged": 0
+      }],
+      "disableVirtualX": [{
+        "disableVirtualXChanged": 0
+      }],
+      "virtualX": [{
+        "virtualXChanged": 0
+      }],
+      "rowSize": [{
+        "rowSizeChanged": 0
+      }],
+      "colSize": [{
+        "colSizeChanged": 0
+      }],
+      "theme": [{
+        "themeChanged": 0
+      }],
+      "themeDefinitions": [{
+        "themeDefinitionsChanged": 0
+      }],
+      "source": [{
+        "dataSourceChanged": 0
+      }],
+      "pinnedBottomSource": [{
+        "dataSourceChanged": 0
+      }],
+      "pinnedTopSource": [{
+        "dataSourceChanged": 0
+      }],
+      "disableVirtualY": [{
+        "disableVirtualYChanged": 0
+      }],
+      "rowDefinitions": [{
+        "rowDefChanged": 0
+      }],
+      "trimmedRows": [{
+        "trimmedRowsChanged": 0
+      }],
+      "grouping": [{
+        "groupingChanged": 0
+      }],
+      "stretch": [{
+        "applyStretch": 0
+      }],
+      "filter": [{
+        "applyFilter": 0
+      }],
+      "sorting": [{
+        "applySorting": 0
+      }],
+      "rowHeaders": [{
+        "rowHeadersChange": 0
+      }],
+      "registerVNode": [{
+        "registerOutsideVNodes": 0
+      }],
+      "additionalData": [{
+        "additionalDataChanged": 0
+      }],
+      "rtl": [{
+        "rtlChanged": 0
+      }],
+      "plugins": [{
+        "pluginsChanged": 0
+      }]
+    };
+  }
+};
+RevoGridComponent.style = revoGridStyleCss();
+/*! Bundled license information:
+
+@revolist/revogrid/dist/esm/column.drag.plugin-DKgC_0I1.js:
+@revolist/revogrid/dist/esm/revo-grid.entry.js:
+  (*!
+   * Built by Revolist OU ❤️
+   *)
+*/
+
+export { RevoGridComponent as revo_grid };
+//# sourceMappingURL=revo-grid.entry-7FHEBN3O.js.map
+//# sourceMappingURL=revo-grid.entry-7FHEBN3O.js.map