@revolist/revogrid 4.9.41 → 4.10.1

package/dist/esm/{column.service-751345b2.js → index-b1e05212.js}

@@ -1,8 +1,7 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import { a as isObject, b as baseGetTag, r as root, S as Symbol, c as isObjectLike, f as freeGlobal, i as isSymbol, t as toNumber } from './debounce-72878ced.js';
-import { z as identity, G as GRID_INTERNALS, C as CELL_CLASS, h as DISABLED_CLASS } from './index-1dcad6ef.js';
+import { i as isObject, b as baseGetTag, r as root, S as Symbol, a as isObjectLike, f as freeGlobal, c as isSymbol, t as toNumber } from './debounce-7b511afc.js';
 import { g as getRenderingRef, f as forceUpdate } from './index-a61f225b.js';
 
 /**
@@ -2460,6 +2459,26 @@ function baseMatchesProperty(path, srcValue) {
   };
 }
 
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value) {
+  return value;
+}
+
 /**
  * The base implementation of `_.property` without support for deep paths.
  *
@@ -2775,9 +2794,9 @@ function createRange(fromRight) {
  * _.range(0);
  * // => []
  */
-var range = createRange();
+var range$1 = createRange();
 
-const range$1 = range;
+const range$2 = range$1;
 
 const appendToMap = (map, propName, value) => {
     const items = map.get(propName);
@@ -2977,18 +2996,13 @@ const createStore = (defaultState, shouldUpdate) => {
 const trimmedPlugin = (store) => ({
     set(k, newVal) {
         switch (k) {
-            case 'trimmed':
+            case 'trimmed': {
                 const proxy = store.get('proxyItems');
                 const trimmed = gatherTrimmedItems(newVal);
-                const newItems = proxy.reduce((result, v) => {
-                    // check if present in new trimmed remove from items (filter)
-                    if (!trimmed[v]) {
-                        result.push(v);
-                    }
-                    return result;
-                }, []);
+                const newItems = proxy.filter(v => !trimmed[v]);
                 store.set('items', newItems);
                 break;
+            }
         }
     },
 });
@@ -3040,7 +3054,7 @@ class DataStore {
         }
         // clear items
         this.store.set('items', []);
-        const items = range$1(0, (source === null || source === void 0 ? void 0 : source.length) || 0);
+        const items = range$2(0, (source === null || source === void 0 ? void 0 : source.length) || 0);
         // set proxy first
         setStore(this.store, {
             source,
@@ -3150,1246 +3164,451 @@ function getSourceItemVirtualIndexByProp(store, prop) {
     return items.indexOf(physicalIndex);
 }
 
-/**
- * A specialized version of `_.reduce` for arrays without support for
- * iteratee shorthands.
- *
- * @private
- * @param {Array} [array] The array to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @param {*} [accumulator] The initial value.
- * @param {boolean} [initAccum] Specify using the first element of `array` as
- *  the initial value.
- * @returns {*} Returns the accumulated value.
- */
-function arrayReduce(array, iteratee, accumulator, initAccum) {
-  var index = -1,
-      length = array == null ? 0 : array.length;
+/** Used as references for the maximum length and index of an array. */
+var MAX_ARRAY_LENGTH$1 = 4294967295,
+    MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH$1 - 1;
 
-  if (initAccum && length) {
-    accumulator = array[++index];
-  }
-  while (++index < length) {
-    accumulator = iteratee(accumulator, array[index], index, array);
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeFloor = Math.floor,
+    nativeMin = Math.min;
+
+/**
+ * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
+ * which invokes `iteratee` for `value` and each element of `array` to compute
+ * their sort ranking. The iteratee is invoked with one argument; (value).
+ *
+ * @private
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {Function} iteratee The iteratee invoked per element.
+ * @param {boolean} [retHighest] Specify returning the highest qualified index.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ */
+function baseSortedIndexBy(array, value, iteratee, retHighest) {
+  var low = 0,
+      high = array == null ? 0 : array.length;
+  if (high === 0) {
+    return 0;
+  }
+
+  value = iteratee(value);
+  var valIsNaN = value !== value,
+      valIsNull = value === null,
+      valIsSymbol = isSymbol(value),
+      valIsUndefined = value === undefined;
+
+  while (low < high) {
+    var mid = nativeFloor((low + high) / 2),
+        computed = iteratee(array[mid]),
+        othIsDefined = computed !== undefined,
+        othIsNull = computed === null,
+        othIsReflexive = computed === computed,
+        othIsSymbol = isSymbol(computed);
+
+    if (valIsNaN) {
+      var setLow = retHighest || othIsReflexive;
+    } else if (valIsUndefined) {
+      setLow = othIsReflexive && (retHighest || othIsDefined);
+    } else if (valIsNull) {
+      setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+    } else if (valIsSymbol) {
+      setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+    } else if (othIsNull || othIsSymbol) {
+      setLow = false;
+    } else {
+      setLow = retHighest ? (computed <= value) : (computed < value);
+    }
+    if (setLow) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
   }
-  return accumulator;
+  return nativeMin(high, MAX_ARRAY_INDEX);
 }
 
-/**
- * Creates a base function for methods like `_.forIn` and `_.forOwn`.
- *
- * @private
- * @param {boolean} [fromRight] Specify iterating from right to left.
- * @returns {Function} Returns the new base function.
- */
-function createBaseFor(fromRight) {
-  return function(object, iteratee, keysFunc) {
-    var index = -1,
-        iterable = Object(object),
-        props = keysFunc(object),
-        length = props.length;
-
-    while (length--) {
-      var key = props[fromRight ? length : ++index];
-      if (iteratee(iterable[key], key, iterable) === false) {
-        break;
-      }
-    }
-    return object;
-  };
-}
+/** Used as references for the maximum length and index of an array. */
+var MAX_ARRAY_LENGTH = 4294967295,
+    HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
 
 /**
- * The base implementation of `baseForOwn` which iterates over `object`
- * properties returned by `keysFunc` and invokes `iteratee` for each property.
- * Iteratee functions may exit iteration early by explicitly returning `false`.
+ * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
+ * performs a binary search of `array` to determine the index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
  *
  * @private
- * @param {Object} object The object to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @param {Function} keysFunc The function to get the keys of `object`.
- * @returns {Object} Returns `object`.
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @param {boolean} [retHighest] Specify returning the highest qualified index.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
  */
-var baseFor = createBaseFor();
+function baseSortedIndex(array, value, retHighest) {
+  var low = 0,
+      high = array == null ? low : array.length;
 
-const baseFor$1 = baseFor;
+  if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+    while (low < high) {
+      var mid = (low + high) >>> 1,
+          computed = array[mid];
 
-/**
- * The base implementation of `_.forOwn` without support for iteratee shorthands.
- *
- * @private
- * @param {Object} object The object to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @returns {Object} Returns `object`.
- */
-function baseForOwn(object, iteratee) {
-  return object && baseFor$1(object, iteratee, keys);
-}
-
-/**
- * Creates a `baseEach` or `baseEachRight` function.
- *
- * @private
- * @param {Function} eachFunc The function to iterate over a collection.
- * @param {boolean} [fromRight] Specify iterating from right to left.
- * @returns {Function} Returns the new base function.
- */
-function createBaseEach(eachFunc, fromRight) {
-  return function(collection, iteratee) {
-    if (collection == null) {
-      return collection;
-    }
-    if (!isArrayLike(collection)) {
-      return eachFunc(collection, iteratee);
-    }
-    var length = collection.length,
-        index = fromRight ? length : -1,
-        iterable = Object(collection);
-
-    while ((fromRight ? index-- : ++index < length)) {
-      if (iteratee(iterable[index], index, iterable) === false) {
-        break;
+      if (computed !== null && !isSymbol(computed) &&
+          (retHighest ? (computed <= value) : (computed < value))) {
+        low = mid + 1;
+      } else {
+        high = mid;
       }
     }
-    return collection;
-  };
-}
-
-/**
- * The base implementation of `_.forEach` without support for iteratee shorthands.
- *
- * @private
- * @param {Array|Object} collection The collection to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @returns {Array|Object} Returns `collection`.
- */
-var baseEach = createBaseEach(baseForOwn);
-
-const baseEach$1 = baseEach;
-
-/**
- * The base implementation of `_.reduce` and `_.reduceRight`, without support
- * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
- *
- * @private
- * @param {Array|Object} collection The collection to iterate over.
- * @param {Function} iteratee The function invoked per iteration.
- * @param {*} accumulator The initial value.
- * @param {boolean} initAccum Specify using the first or last element of
- *  `collection` as the initial value.
- * @param {Function} eachFunc The function to iterate over `collection`.
- * @returns {*} Returns the accumulated value.
- */
-function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
-  eachFunc(collection, function(value, index, collection) {
-    accumulator = initAccum
-      ? (initAccum = false, value)
-      : iteratee(accumulator, value, index, collection);
-  });
-  return accumulator;
+    return high;
+  }
+  return baseSortedIndexBy(array, value, identity, retHighest);
 }
 
 /**
- * Reduces `collection` to a value which is the accumulated result of running
- * each element in `collection` thru `iteratee`, where each successive
- * invocation is supplied the return value of the previous. If `accumulator`
- * is not given, the first element of `collection` is used as the initial
- * value. The iteratee is invoked with four arguments:
- * (accumulator, value, index|key, collection).
- *
- * Many lodash methods are guarded to work as iteratees for methods like
- * `_.reduce`, `_.reduceRight`, and `_.transform`.
- *
- * The guarded methods are:
- * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
- * and `sortBy`
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
  *
  * @static
  * @memberOf _
  * @since 0.1.0
- * @category Collection
- * @param {Array|Object} collection The collection to iterate over.
- * @param {Function} [iteratee=_.identity] The function invoked per iteration.
- * @param {*} [accumulator] The initial value.
- * @returns {*} Returns the accumulated value.
- * @see _.reduceRight
+ * @category Array
+ * @param {Array} array The sorted array to inspect.
+ * @param {*} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
  * @example
  *
- * _.reduce([1, 2], function(sum, n) {
- *   return sum + n;
- * }, 0);
- * // => 3
- *
- * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
- *   (result[value] || (result[value] = [])).push(key);
- *   return result;
- * }, {});
- * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
+ * _.sortedIndex([30, 50], 40);
+ * // => 1
  */
-function reduce(collection, iteratee, accumulator) {
-  var func = isArray$1(collection) ? arrayReduce : baseReduce,
-      initAccum = arguments.length < 3;
-
-  return func(collection, baseIteratee(iteratee), accumulator, initAccum, baseEach$1);
+function sortedIndex(array, value) {
+  return baseSortedIndex(array, value);
 }
 
 /**
- * Selection store
+ * Pre-calculation
+ * Dimension custom sizes for each cell
+ * Keeps only changed sizes, skips origin size
  */
-function defaultState() {
-    return {
-        range: null,
-        tempRange: null,
-        tempRangeType: null,
-        focus: null,
-        edit: null,
-        lastCell: null,
-        nextFocus: null,
-    };
-}
-class SelectionStore {
-    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 });
+function calculateDimensionData(originItemSize, newSizes = {}) {
+    const positionIndexes = [];
+    const positionIndexToItem = {};
+    const indexToItem = {};
+    // prepare order sorted new sizes and calculate changed real size
+    const newIndexes = Object.keys(newSizes).map(Number).sort((a, b) => a - b);
+    // fill new coordinates based on what is changed
+    newIndexes.reduce((previous, itemIndex, i) => {
+        const newItem = {
+            itemIndex,
+            start: 0,
+            end: 0,
+        };
+        // if previous item was changed too
+        if (previous) {
+            const itemsBetween = (itemIndex - previous.itemIndex - 1) * originItemSize;
+            newItem.start = itemsBetween + previous.end;
         }
         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;
+            newItem.start = itemIndex * originItemSize;
         }
-        setStore(this.store, { edit: null });
-    }
-    dispose() {
-        this.unsubscribe.forEach(f => f());
-        this.store.dispose();
-    }
+        newItem.end = newItem.start + newSizes[itemIndex];
+        positionIndexes.push(newItem.start);
+        indexToItem[itemIndex] = positionIndexToItem[i] = newItem;
+        return newItem;
+    }, undefined);
+    return {
+        indexes: newIndexes,
+        positionIndexes: [...positionIndexes],
+        positionIndexToItem: Object.assign({}, positionIndexToItem),
+        indexToItem,
+    };
 }
-
-const EMPTY_INDEX = -1;
-class SelectionStoreConnector {
-    constructor() {
-        // dirty flag required to cleanup whole store in case visibility of panels changed
-        this.dirty = false;
-        this.stores = {};
-        this.columnStores = {};
-        this.rowStores = {};
-        /**
-         * Helpers for data conversion
-         */
-        this.storesByType = {};
-        this.storesXToType = {};
-        this.storesYToType = {};
-        this.sections = [];
-    }
-    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');
-    }
-    registerSection(e) {
-        if (!e) {
-            this.sections.length = 0;
-            // some elements removed, rebuild stores
-            this.dirty = true;
-            return;
-        }
-        if (this.sections.indexOf(e) === -1) {
-            this.sections.push(e);
-        }
-    }
-    // check if require to cleanup all stores
-    beforeUpdate() {
-        if (this.dirty) {
-            for (let y in this.stores) {
-                for (let x in this.stores[y]) {
-                    this.stores[y][x].dispose();
-                }
-            }
-            this.dirty = false;
-        }
-    }
-    registerColumn(x, type) {
-        // if hidden just create store but no operations needed
-        if (isHiddenStore(x)) {
-            return new SelectionStore();
-        }
-        if (this.columnStores[x]) {
-            return this.columnStores[x];
-        }
-        this.columnStores[x] = new SelectionStore();
-        // build cross-linking type to position
-        this.storesByType[type] = x;
-        this.storesXToType[x] = type;
-        return this.columnStores[x];
-    }
-    registerRow(y, type) {
-        // if hidden just create store
-        if (isHiddenStore(y)) {
-            return new SelectionStore();
-        }
-        if (this.rowStores[y]) {
-            return this.rowStores[y];
-        }
-        this.rowStores[y] = new SelectionStore();
-        // build cross linking type to position
-        this.storesByType[type] = y;
-        this.storesYToType[y] = type;
-        return this.rowStores[y];
-    }
-    /**
-     * Cross store proxy, based on multiple dimensions
-     */
-    register({ x, y }) {
-        var _a, _b;
-        // if hidden just create store
-        if (isHiddenStore(x) || isHiddenStore(y)) {
-            return new SelectionStore();
-        }
-        if (!this.stores[y]) {
-            this.stores[y] = {};
-        }
-        if (this.stores[y][x]) {
-            // Store already registered. Do not register twice
-            return this.stores[y][x];
-        }
-        this.stores[y][x] = new SelectionStore();
-        // proxy update, column store trigger only range area
-        (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.onChange('range', c => {
-            this.columnStores[x].setRangeArea(c);
-            this.rowStores[y].setRangeArea(c);
-        });
-        // clean up on remove
-        (_b = this.stores[y][x]) === null || _b === void 0 ? void 0 : _b.store.on('dispose', () => this.destroy(x, y));
-        return this.stores[y][x];
-    }
-    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];
-        // clear x cross-link
-        if (this.storesXToType[x]) {
-            const type = this.storesXToType[x];
-            delete this.storesXToType[x];
-            delete this.storesByType[type];
-        }
-        // clear y cross-link
-        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];
-        }
-        // clear empty rows
-        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 there is no focused store, return early.
-        if (!this.focusedStore) {
-            return;
-        }
-        // Get the next store based on the current focus and the last cell.
-        const lastCell = this.focusedStore.entity.store.get('lastCell');
-        const next = lastCell && this.getNextStore(focus, this.focusedStore.position, lastCell);
-        // Set the next focus cell in the store.
-        (_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;
-        }
-        // check for the focus in nearby store/viewport
-        const lastCell = store.store.get('lastCell');
-        const next = lastCell && this.getNextStore(focus, currentStorePointer, lastCell);
-        // if next store present - update
-        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;
+/**
+ * Calculate item by position
+ */
+const getItemByPosition = ({ indexes, positionIndexes, originItemSize, positionIndexToItem, }, pos) => {
+    const item = {
+        itemIndex: 0,
+        start: 0,
+        end: 0,
+    };
+    const currentPlace = indexes.length ? sortedIndex(positionIndexes, pos) : 0;
+    // not found or first index
+    if (!currentPlace) {
+        item.itemIndex = Math.floor(pos / originItemSize);
+        item.start = item.itemIndex * originItemSize;
+        item.end = item.start + originItemSize;
+        return item;
+    }
+    const positionItem = positionIndexToItem[currentPlace - 1];
+    // if item has specified size
+    if (positionItem.end > pos) {
+        return positionItem;
+    }
+    // special size item was present before
+    const relativePos = pos - positionItem.end;
+    const relativeIndex = Math.floor(relativePos / originItemSize);
+    item.itemIndex = positionItem.itemIndex + 1 + relativeIndex;
+    item.start = positionItem.end + relativeIndex * originItemSize;
+    item.end = item.start + originItemSize;
+    return item;
+};
+function getItemByIndex(dimension, index) {
+    let item = {
+        itemIndex: index,
+        start: 0,
+        end: 0,
+    };
+    // if item has specified size
+    if (dimension.indexToItem[index]) {
+        return dimension.indexToItem[index];
+    }
+    const currentPlace = dimension.indexes.length
+        ? sortedIndex(dimension.indexes, index)
+        : 0;
+    // not found or first index
+    if (!currentPlace) {
+        item.start = item.itemIndex * dimension.originItemSize;
+        item.end = item.start + dimension.originItemSize;
+        return item;
+    }
+    // special size item was present before
+    const positionItem = dimension.indexToItem[dimension.indexes[currentPlace - 1]];
+    item.start =
+        positionItem.end +
+            (index - positionItem.itemIndex - 1) * dimension.originItemSize;
+    item.end = item.start + dimension.originItemSize;
+    return item;
+}
+
+const MIN_COL_SIZE = 30;
+const RESIZE_INTERVAL = 40;
+const DATA_COL = 'data-rgCol';
+const DATA_ROW = 'data-rgRow';
+const DISABLED_CLASS = 'disabled';
+const CELL_CLASS = 'rgCell';
+const ROW_HEADER_TYPE = 'rowHeaders';
+const HEADER_CLASS = 'rgHeaderCell';
+const HEADER_SORTABLE_CLASS = 'sortable';
+const HEADER_ROW_CLASS = 'header-rgRow';
+const HEADER_ACTUAL_ROW_CLASS = 'actual-rgRow';
+const DRAG_ICON_CLASS = 'revo-drag-icon';
+const DRAGGABLE_CLASS = 'revo-draggable';
+const FOCUS_CLASS = 'focused-cell';
+const SELECTION_BORDER_CLASS = 'selection-border-range';
+const MOBILE_CLASS = 'mobile-handler';
+const TMP_SELECTION_BG_CLASS = 'temp-bg-range';
+const CELL_HANDLER_CLASS = 'autofill-handle';
+const EDIT_INPUT_WR = 'edit-input-wrapper';
+const DRAGG_TEXT = 'Draggable item';
+const GRID_INTERNALS = '__rvgr';
+const ROW_FOCUSED_CLASS = 'focused-rgRow';
+
+var codes;
+(function (codes) {
+    codes[codes["MOUSE_LEFT"] = 1] = "MOUSE_LEFT";
+    codes[codes["MOUSE_RIGHT"] = 3] = "MOUSE_RIGHT";
+    codes[codes["MOUSE_MIDDLE"] = 2] = "MOUSE_MIDDLE";
+    codes[codes["BACKSPACE"] = 8] = "BACKSPACE";
+    codes[codes["COMMA"] = 188] = "COMMA";
+    codes[codes["INSERT"] = 45] = "INSERT";
+    codes[codes["DELETE"] = 46] = "DELETE";
+    codes[codes["END"] = 35] = "END";
+    codes[codes["ENTER"] = 13] = "ENTER";
+    codes[codes["ESCAPE"] = 27] = "ESCAPE";
+    codes[codes["CONTROL"] = 17] = "CONTROL";
+    codes[codes["COMMAND_LEFT"] = 91] = "COMMAND_LEFT";
+    codes[codes["COMMAND_RIGHT"] = 93] = "COMMAND_RIGHT";
+    codes[codes["COMMAND_FIREFOX"] = 224] = "COMMAND_FIREFOX";
+    codes[codes["ALT"] = 18] = "ALT";
+    codes[codes["HOME"] = 36] = "HOME";
+    codes[codes["PAGE_DOWN"] = 34] = "PAGE_DOWN";
+    codes[codes["PAGE_UP"] = 33] = "PAGE_UP";
+    codes[codes["PERIOD"] = 190] = "PERIOD";
+    codes[codes["SPACE"] = 32] = "SPACE";
+    codes[codes["SHIFT"] = 16] = "SHIFT";
+    codes[codes["CAPS_LOCK"] = 20] = "CAPS_LOCK";
+    codes[codes["TAB"] = 9] = "TAB";
+    codes[codes["ARROW_RIGHT"] = 39] = "ARROW_RIGHT";
+    codes[codes["ARROW_LEFT"] = 37] = "ARROW_LEFT";
+    codes[codes["ARROW_UP"] = 38] = "ARROW_UP";
+    codes[codes["ARROW_DOWN"] = 40] = "ARROW_DOWN";
+    codes[codes["F1"] = 112] = "F1";
+    codes[codes["F2"] = 113] = "F2";
+    codes[codes["F3"] = 114] = "F3";
+    codes[codes["F4"] = 115] = "F4";
+    codes[codes["F5"] = 116] = "F5";
+    codes[codes["F6"] = 117] = "F6";
+    codes[codes["F7"] = 118] = "F7";
+    codes[codes["F8"] = 119] = "F8";
+    codes[codes["F9"] = 120] = "F9";
+    codes[codes["F10"] = 121] = "F10";
+    codes[codes["F11"] = 122] = "F11";
+    codes[codes["F12"] = 123] = "F12";
+    codes[codes["A"] = 65] = "A";
+    codes[codes["C"] = 67] = "C";
+    codes[codes["D"] = 68] = "D";
+    codes[codes["F"] = 70] = "F";
+    codes[codes["L"] = 76] = "L";
+    codes[codes["O"] = 79] = "O";
+    codes[codes["P"] = 80] = "P";
+    codes[codes["S"] = 83] = "S";
+    codes[codes["V"] = 86] = "V";
+    codes[codes["X"] = 88] = "X";
+})(codes || (codes = {}));
+var codesLetter;
+(function (codesLetter) {
+    codesLetter["ENTER"] = "Enter";
+    codesLetter["ENTER_NUM"] = "NumpadEnter";
+    codesLetter["A"] = "KeyA";
+    codesLetter["C"] = "KeyC";
+    codesLetter["X"] = "KeyX";
+    codesLetter["V"] = "KeyV";
+    codesLetter["ESCAPE"] = "Escape";
+    codesLetter["TAB"] = "Tab";
+    codesLetter["BACKSPACE"] = "Backspace";
+    codesLetter["DELETE"] = "Delete";
+    codesLetter["ARROW_RIGHT"] = "ArrowRight";
+    codesLetter["ARROW_LEFT"] = "ArrowLeft";
+    codesLetter["ARROW_UP"] = "ArrowUp";
+    codesLetter["ARROW_DOWN"] = "ArrowDown";
+    codesLetter["SHIFT"] = "Shift";
+})(codesLetter || (codesLetter = {}));
+var keyValues;
+(function (keyValues) {
+    keyValues["ENTER"] = "Enter";
+    keyValues["TAB"] = "Tab";
+})(keyValues || (keyValues = {}));
+const KeyCodesEnum = codes;
+
+var osPlatform;
+(function (osPlatform) {
+    osPlatform["mac"] = "Mac";
+})(osPlatform || (osPlatform = {}));
+const OsPlatform = osPlatform;
+
+/* Generate range on size
+ */
+function range(size, startAt = 0) {
+    const res = [];
+    const end = startAt + size;
+    for (let i = startAt; i < end; i++) {
+        res.push(i);
     }
-    /**
-     * Retrieves the current store pointer based on the active store.
-     * Clears focus from all stores except the active one.
-     */
-    getCurrentStorePointer(store) {
-        let currentStorePointer;
-        // Iterate through all stores
-        for (let y in this.stores) {
-            for (let x in this.stores[y]) {
-                const s = this.stores[y][x];
-                // Clear focus from stores other than the active one
-                if (s !== store) {
-                    s.clearFocus();
-                }
-                else {
-                    // Update the current store pointer with the active store coordinates
-                    currentStorePointer = {
-                        x: parseInt(x, 10),
-                        y: parseInt(y, 10)
-                    };
-                }
+    return res;
+}
+/* Find index position in array */
+function findPositionInArray(el, compareFn) {
+    return (function (arr) {
+        let m = 0;
+        let n = arr.length - 1;
+        while (m <= n) {
+            const k = (n + m) >> 1;
+            const cmp = compareFn(el, arr[k]);
+            if (cmp > 0) {
+                m = k + 1;
             }
-        }
-        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) {
-        // item in new store
-        const nextItem = nextCell(focus, lastCell);
-        let nextStore;
-        if (nextItem) {
-            Object.entries(nextItem).forEach(([type, nextItemCoord]) => {
-                let stores;
-                switch (type) {
-                    case 'x':
-                        // Get the X stores for the current Y coordinate of the current store pointer
-                        stores = this.getXStores(currentStorePointer.y);
-                        break;
-                    case 'y':
-                        // Get the Y stores for the current X coordinate of the current store pointer
-                        stores = this.getYStores(currentStorePointer.x);
-                        break;
-                }
-                // Get the next store based on the item in the new store
-                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;
-                    }
-                }
-            });
-        }
-        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();
+            else if (cmp < 0) {
+                n = k - 1;
             }
-        }
-    }
-    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 });
-                }
+            else {
+                return k;
             }
         }
-    }
-    getXStores(y) {
-        return this.stores[y];
-    }
-    getYStores(x) {
-        const stores = {};
-        for (let i in this.stores) {
-            stores[i] = this.stores[i][x];
-        }
-        return stores;
-    }
-}
-
-function isHiddenStore(pos) {
-    return pos === EMPTY_INDEX;
-}
-function nextCell(cell, lastCell) {
-    const nextItem = {};
-    let types = ['x', 'y'];
-    // previous item check
-    for (let t of types) {
-        if (cell[t] < 0) {
-            nextItem[t] = cell[t];
-            return nextItem;
-        }
-    }
-    // next item check
-    for (let t of types) {
-        if (cell[t] >= lastCell[t]) {
-            nextItem[t] = cell[t] - lastCell[t];
-            return nextItem;
-        }
-    }
-    return null;
-}
-function cropCellToMax(cell, lastCell) {
-    const croppedCell = Object.assign({}, cell);
-    const cellCoordinates = ['x', 'y'];
-    for (const coordinate of cellCoordinates) {
-        if (cell[coordinate] < 0) {
-            croppedCell[coordinate] = 0;
-        }
-        else if (cell[coordinate] >= lastCell[coordinate]) {
-            croppedCell[coordinate] = lastCell[coordinate] - 1;
-        }
-    }
-    return croppedCell;
-}
-function getRange(start, end) {
-    return start && end
-        ? {
-            x: Math.min(start.x, end.x),
-            y: Math.min(start.y, end.y),
-            x1: Math.max(start.x, end.x),
-            y1: Math.max(start.y, end.y),
-        }
-        : null;
-}
-function isRangeSingleCell(a) {
-    return a.x === a.x1 && a.y === a.y1;
-}
-
-function getCellData(val) {
-    if (typeof val === 'undefined' || val === null) {
-        return '';
-    }
-    return val;
-}
-function getCellDataParsed(model, column) {
-    const val = column.cellParser ? column.cellParser(model, column) : model[column.prop];
-    return getCellData(val);
+        return -m - 1;
+    })(this);
 }
 /**
- * Get column type from column data
+ * Sorted push
  */
-function getColumnType(rgCol) {
-    if (rgCol.pin) {
-        return rgCol.pin;
-    }
-    return 'rgCol';
+function pushSorted(arr, el, fn) {
+    arr.splice(findPositionInArray.bind(arr)(el, fn), 0, el);
+    return arr;
 }
-function getColumnSizes(cols) {
-    const res = {};
-    for (const [i, c] of cols.entries()) {
-        if (c.size) {
-            res[i] = c.size;
-        }
-    }
-    return res;
+// (arr1[index1] < arr2[index2])
+function simpleCompare(el1, el2) {
+    return el1 < el2;
 }
 /**
- * Check if column is grouping column
+ * Merge sorted array helper function
  */
-function isColGrouping(colData) {
-    return !!colData.children;
-}
-/**
- * This function is used to create a collection of columns.
- */
-function getColumns(columns, level = 0, types) {
-    const collection = {
-        // columns as they are in stores per type
-        columns: {
-            rgCol: [],
-            colPinStart: [],
-            colPinEnd: [],
-        },
-        // columns indexed by prop for quick access
-        columnByProp: {},
-        // column grouping
-        columnGrouping: {
-            rgCol: [],
-            colPinStart: [],
-            colPinEnd: [],
-        },
-        // max depth level for column grouping
-        maxLevel: level,
-        // sorting
-        sort: {},
-    };
-    return reduce(columns, (res, colData) => {
-        // Grouped column
-        if (isColGrouping(colData)) {
-            return gatherGroup(res, colData, getColumns(colData.children, level + 1, types), level);
-        }
-        // Column type
-        const columnDefinitionFromType = colData.columnType && (types === null || types === void 0 ? void 0 : types[colData.columnType]);
-        // Regular column
-        const regularColumn = Object.assign(Object.assign({}, columnDefinitionFromType), colData);
-        // Regular column, no Pin
-        if (!regularColumn.pin) {
-            res.columns.rgCol.push(regularColumn);
-            // Pin
+function mergeSortedArray(arr1, arr2, compareFn = simpleCompare) {
+    const merged = [];
+    let index1 = 0;
+    let index2 = 0;
+    let current = 0;
+    while (current < arr1.length + arr2.length) {
+        let isArr1Depleted = index1 >= arr1.length;
+        let isArr2Depleted = index2 >= arr2.length;
+        if (!isArr1Depleted && (isArr2Depleted || compareFn(arr1[index1], arr2[index2]))) {
+            merged[current] = arr1[index1];
+            index1++;
         }
         else {
-            res.columns[regularColumn.pin].push(regularColumn);
-        }
-        if (regularColumn.order) {
-            res.sort[regularColumn.prop] = regularColumn;
-        }
-        // it's possible that some columns have same prop, but better to avoid it
-        if (!res.columnByProp[regularColumn.prop]) {
-            res.columnByProp[regularColumn.prop] = [];
-        }
-        res.columnByProp[regularColumn.prop].push(regularColumn);
-        // trigger setup hook if present
-        regularColumn.beforeSetup && regularColumn.beforeSetup(regularColumn);
-        return res;
-    }, collection);
-}
-function gatherGroup(res, colData, collection, level = 0) {
-    // group template
-    const group = Object.assign(Object.assign({}, colData), { level, ids: [] });
-    // check columns for update
-    for (let k in collection.columns) {
-        const key = k;
-        const resultItem = res.columns[key];
-        const collectionItem = collection.columns[key];
-        // if column data
-        if (isArray$1(resultItem) && isArray$1(collectionItem)) {
-            // fill columns
-            resultItem.push(...collectionItem);
-            // fill grouping
-            if (collectionItem.length) {
-                res.columnGrouping[key].push(Object.assign(Object.assign({}, group), { ids: collectionItem.map(item => item.prop) }));
-            }
-        }
-    }
-    // merge column groupings
-    for (let k in collection.columnGrouping) {
-        const key = k;
-        const collectionItem = collection.columnGrouping[key];
-        res.columnGrouping[key].push(...collectionItem);
-    }
-    res.maxLevel = Math.max(res.maxLevel, collection.maxLevel);
-    res.sort = Object.assign(Object.assign({}, res.sort), collection.sort);
-    return res;
-}
-function findColumn(columns, prop) {
-    for (const c of columns) {
-        if (isColGrouping(c)) {
-            const found = findColumn(c.children, prop);
-            if (found) {
-                return found;
-            }
-        }
-        else if (c.prop === prop) {
-            return c;
-        }
-    }
-    return undefined;
-}
-function getColumnByProp(columns, prop) {
-    return findColumn(columns, prop);
-}
-
-const GROUP_DEPTH = `${GRID_INTERNALS}-depth`;
-const PSEUDO_GROUP_ITEM = `${GRID_INTERNALS}-name`;
-const PSEUDO_GROUP_ITEM_ID = `${GRID_INTERNALS}-id`;
-const PSEUDO_GROUP_ITEM_VALUE = `${GRID_INTERNALS}-value`;
-const PSEUDO_GROUP_COLUMN = `${GRID_INTERNALS}-column`;
-const GROUP_EXPANDED = `${GRID_INTERNALS}-expanded`;
-const GROUP_ORIGINAL_INDEX = `${GRID_INTERNALS}-original-index`;
-const GROUP_EXPAND_BTN = `group-expand`;
-const GROUP_EXPAND_EVENT = `groupexpandclick`;
-const GROUPING_ROW_TYPE = 'rgRow';
-
-function getGroupValueDefault(item, prop) {
-    return item[prop] || null;
-}
-/**
- * Gather data for grouping
- * @param array - flat data array
- * @param groupIds - ids of groups
- * @param expanded - potentially expanded items if present
- */
-function gatherGrouping(array, groupIds, { prevExpanded, expandedAll, getGroupValue = getGroupValueDefault, }) {
-    const groupedItems = new Map();
-    array.forEach((item, originalIndex) => {
-        const groupLevelValues = groupIds.map(groupId => getGroupValue(item, groupId));
-        const lastLevelValue = groupLevelValues.pop();
-        let currentGroupLevel = groupedItems;
-        groupLevelValues.forEach(value => {
-            if (!currentGroupLevel.has(value)) {
-                currentGroupLevel.set(value, new Map());
-            }
-            currentGroupLevel = currentGroupLevel.get(value);
-        });
-        if (!currentGroupLevel.has(lastLevelValue)) {
-            currentGroupLevel.set(lastLevelValue, []);
+            merged[current] = arr2[index2];
+            index2++;
         }
-        const lastLevelItems = currentGroupLevel.get(lastLevelValue);
-        lastLevelItems.push(Object.assign(Object.assign({}, item), { [GROUP_ORIGINAL_INDEX]: originalIndex }));
-    });
-    let itemIndex = -1;
-    const groupingDepth = groupIds.length;
-    // collapse all groups in the beginning
-    const trimmed = {};
-    // index mapping
-    const oldNewIndexMap = {};
-    // check if group header exists
-    const pseudoGroupTest = {};
-    const sourceWithGroups = [];
-    function flattenGroupMaps(groupedValues, parentIds, isExpanded) {
-        const depth = parentIds.length;
-        groupedValues.forEach((innerGroupedValues, groupId) => {
-            const levelIds = [...parentIds, groupId];
-            const mergedIds = levelIds.join(',');
-            const isGroupExpanded = isExpanded && (!!expandedAll || !!(prevExpanded === null || prevExpanded === void 0 ? void 0 : prevExpanded[mergedIds]));
-            sourceWithGroups.push({
-                [PSEUDO_GROUP_ITEM]: groupId,
-                [GROUP_DEPTH]: depth,
-                [PSEUDO_GROUP_ITEM_ID]: JSON.stringify(levelIds),
-                [PSEUDO_GROUP_ITEM_VALUE]: mergedIds,
-                [GROUP_EXPANDED]: isGroupExpanded,
-            });
-            itemIndex += 1;
-            if (!isGroupExpanded && depth) {
-                trimmed[itemIndex] = true;
-            }
-            if (Array.isArray(innerGroupedValues)) {
-                innerGroupedValues.forEach(value => {
-                    itemIndex += 1;
-                    if (!isGroupExpanded) {
-                        trimmed[itemIndex] = true;
-                    }
-                    oldNewIndexMap[value[GROUP_ORIGINAL_INDEX]] = itemIndex;
-                    const pseudoGroupTestIds = levelIds.map((_value, index) => levelIds.slice(0, index + 1).join(','));
-                    pseudoGroupTestIds.forEach(pseudoGroupTestId => {
-                        if (!pseudoGroupTest[pseudoGroupTestId]) {
-                            pseudoGroupTest[pseudoGroupTestId] = [];
-                        }
-                        pseudoGroupTest[pseudoGroupTestId].push(itemIndex);
-                    });
-                });
-                sourceWithGroups.push(...innerGroupedValues);
-            }
-            else {
-                flattenGroupMaps(innerGroupedValues, levelIds, isGroupExpanded);
-            }
-        });
-    }
-    flattenGroupMaps(groupedItems, [], true);
-    return {
-        sourceWithGroups, // updates source mirror
-        depth: groupingDepth, // largest depth for grouping
-        trimmed, // used for expand/collapse grouping values
-        oldNewIndexMap, // used for mapping old values to new
-        childrenByGroup: pseudoGroupTest, // used to get child items in group
-    };
-}
-function getGroupingName(rgRow) {
-    return rgRow && rgRow[PSEUDO_GROUP_ITEM];
-}
-function isGrouping(rgRow) {
-    return typeof (rgRow === null || rgRow === void 0 ? void 0 : rgRow[PSEUDO_GROUP_ITEM]) !== 'undefined';
-}
-function isGroupingColumn(column) {
-    return column && typeof column[PSEUDO_GROUP_COLUMN] !== 'undefined';
-}
-function measureEqualDepth(groupA, groupB) {
-    const ln = groupA.length;
-    let i = 0;
-    for (; i < ln; i++) {
-        if (groupA[i] !== groupB[i]) {
-            return i;
-        }
-    }
-    return i;
-}
-function getParsedGroup(id) {
-    const parseGroup = JSON.parse(id);
-    // extra precaution and type safeguard
-    if (!Array.isArray(parseGroup)) {
-        return null;
-    }
-    return parseGroup;
-}
-// check if items is child of current clicked group
-function isSameGroup(currentGroup, currentModel, nextModel) {
-    const nextGroup = getParsedGroup(nextModel[PSEUDO_GROUP_ITEM_ID]);
-    if (!nextGroup) {
-        return false;
+        current++;
     }
-    const depth = measureEqualDepth(currentGroup, nextGroup);
-    return currentModel[GROUP_DEPTH] < depth;
+    return merged;
 }
-
 /**
- * The base implementation of `_.slice` without an iteratee call guard.
- *
- * @private
- * @param {Array} array The array to slice.
- * @param {number} [start=0] The start position.
- * @param {number} [end=array.length] The end position.
- * @returns {Array} Returns the slice of `array`.
+ * Calculate system scrollbar size
  */
-function baseSlice(array, start, end) {
-  var index = -1,
-      length = array.length;
-
-  if (start < 0) {
-    start = -start > length ? 0 : (length + start);
-  }
-  end = end > length ? length : end;
-  if (end < 0) {
-    end += length;
-  }
-  length = start > end ? 0 : ((end - start) >>> 0);
-  start >>>= 0;
-
-  var result = Array(length);
-  while (++index < length) {
-    result[index] = array[index + start];
-  }
-  return result;
+function getScrollbarSize(document) {
+    // Create a temporary div container and append it to the body
+    const container = document.createElement('div');
+    // Apply styling to ensure the div is scrollable
+    container.style.overflow = 'scroll';
+    container.style.visibility = 'hidden'; // make sure the container isn't visible
+    container.style.position = 'absolute';
+    container.style.top = '-9999px'; // move it out of the screen
+    container.style.width = '50px'; // arbitrary width
+    container.style.height = '50px'; // arbitrary height
+    // Append the div to the body
+    document.body.appendChild(container);
+    // Calculate the width of the scrollbar
+    const scrollbarWidth = container.offsetWidth - container.clientWidth;
+    // Remove the div from the body after calculation
+    document.body.removeChild(container);
+    // Return the calculated width of the scrollbar
+    return scrollbarWidth;
 }
-
-/**
- * Creates a slice of `array` from `start` up to, but not including, `end`.
+/* Scale a value between 2 ranges
  *
- * **Note:** This method is used instead of
- * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
- * returned.
+ * Sample:
+ * // 55 from a 0-100 range to a 0-1000 range (Ranges don't have to be positive)
+ * const n = scaleValue(55, [0,100], [0,1000]);
  *
- * @static
- * @memberOf _
- * @since 3.0.0
- * @category Array
- * @param {Array} array The array to slice.
- * @param {number} [start=0] The start position.
- * @param {number} [end=array.length] The end position.
- * @returns {Array} Returns the slice of `array`.
+ * Ranges of two values
+ * @from
+ * @to
+ *
+ * ~~ return value does the equivalent of Math.floor but faster.
  */
-function slice(array, start, end) {
-  var length = array == null ? 0 : array.length;
-  if (!length) {
-    return [];
-  }
-  if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
-    start = 0;
-    end = length;
-  }
-  else {
-    start = start == null ? 0 : toInteger(start);
-    end = end === undefined ? length : toInteger(end);
-  }
-  return baseSlice(array, start, end);
-}
-
-class ColumnService {
-    get columns() {
-        return getVisibleSourceItem(this.source);
-    }
-    constructor(dataStore, source) {
-        this.dataStore = dataStore;
-        this.source = source;
-        this.unsubscribe = [];
-        this.hasGrouping = false;
-        this.unsubscribe.push(source.onChange('source', s => this.checkGrouping(s)));
-        this.checkGrouping(source.get('source'));
-        this.type = source.get('type');
-    }
-    checkGrouping(cols) {
-        for (let rgCol of cols) {
-            if (isGroupingColumn(rgCol)) {
-                this.hasGrouping = true;
-                return;
-            }
-            this.hasGrouping = false;
-        }
-    }
-    isReadOnly(r, c) {
-        var _a;
-        const readOnly = (_a = this.columns[c]) === null || _a === void 0 ? void 0 : _a.readonly;
-        if (typeof readOnly === 'function') {
-            const data = this.rowDataModel(r, c);
-            return readOnly(data);
-        }
-        return !!readOnly;
-    }
-    mergeProperties(r, c, defaultProps, model, extraPropsFunc) {
-        const props = Object.assign({}, defaultProps);
-        props.class = Object.assign(Object.assign({}, (typeof props.class === 'string'
-            ? { [props.class]: true }
-            : props.class)), { [CELL_CLASS]: true, [DISABLED_CLASS]: this.isReadOnly(r, c) });
-        const extra = extraPropsFunc === null || extraPropsFunc === void 0 ? void 0 : extraPropsFunc(model);
-        if (!extra) {
-            return props;
-        }
-        return doPropMerge(props, extra);
-    }
-    getRowClass(r, prop) {
-        const model = getSourceItem(this.dataStore, r) || {};
-        return model[prop] || '';
-    }
-    getCellData(r, c) {
-        const data = this.rowDataModel(r, c);
-        return getCellData(data.model[data.prop]);
-    }
-    getSaveData(rowIndex, colIndex, val) {
-        const data = this.rowDataModel(rowIndex, colIndex);
-        if (typeof val === 'undefined') {
-            val = getCellData(data.model[data.prop]);
-        }
-        return {
-            prop: data.prop,
-            rowIndex,
-            colIndex,
-            val,
-            model: data.model,
-            colType: this.type,
-            type: this.dataStore.get('type'),
-        };
-    }
-    getCellEditor(_r, c, editors) {
-        var _a;
-        const editor = (_a = this.columns[c]) === null || _a === void 0 ? void 0 : _a.editor;
-        if (!editor) {
-            return undefined;
-        }
-        // reference
-        if (typeof editor === 'string') {
-            return editors[editor];
-        }
-        return editor;
-    }
-    /**
-     * Get cell data model for given rowIndex and colIndex
-     * Used to pass data to editor/renderer
-     */
-    rowDataModel(rowIndex, colIndex) {
-        const column = this.columns[colIndex];
-        const prop = column === null || column === void 0 ? void 0 : column.prop;
-        const model = getSourceItem(this.dataStore, rowIndex) || {};
-        const value = model[prop];
-        const type = this.dataStore.get('type');
-        return {
-            prop,
-            model,
-            data: this.dataStore.get('source'),
-            column,
-            rowIndex,
-            colIndex,
-            colType: this.type,
-            type,
-            value,
-        };
-    }
-    getRangeData(d, columns) {
-        var _a;
-        const changed = {};
-        // get original length sizes
-        const copyColLength = d.oldRange.x1 - d.oldRange.x + 1;
-        const copyRowLength = d.oldRange.y1 - d.oldRange.y + 1;
-        const mapping = {};
-        // rows
-        for (let rowIndex = d.newRange.y, i = 0; rowIndex < d.newRange.y1 + 1; rowIndex++, i++) {
-            // copy original data link
-            const oldRowIndex = d.oldRange.y + (i % copyRowLength);
-            const copyRow = getSourceItem(this.dataStore, oldRowIndex) || {};
-            // columns
-            for (let colIndex = d.newRange.x, j = 0; colIndex < d.newRange.x1 + 1; colIndex++, j++) {
-                // check if old range area
-                if (rowIndex >= d.oldRange.y &&
-                    rowIndex <= d.oldRange.y1 &&
-                    colIndex >= d.oldRange.x &&
-                    colIndex <= d.oldRange.x1) {
-                    continue;
-                }
-                // requested column beyond range
-                if (!this.columns[colIndex]) {
-                    continue;
-                }
-                const prop = (_a = this.columns[colIndex]) === null || _a === void 0 ? void 0 : _a.prop;
-                const copyColIndex = d.oldRange.x + (j % copyColLength);
-                const copyColumnProp = columns[copyColIndex].prop;
-                /** if can write */
-                if (!this.isReadOnly(rowIndex, colIndex)) {
-                    /** to show before save */
-                    if (!changed[rowIndex]) {
-                        changed[rowIndex] = {};
-                    }
-                    changed[rowIndex][prop] = copyRow[copyColumnProp];
-                    /** Generate mapping object */
-                    if (!mapping[rowIndex]) {
-                        mapping[rowIndex] = {};
-                    }
-                    mapping[rowIndex][prop] = {
-                        colIndex: copyColIndex,
-                        colProp: copyColumnProp,
-                        rowIndex: oldRowIndex,
-                    };
-                }
-            }
-        }
-        return {
-            changed,
-            mapping,
-        };
-    }
-    getTransformedDataToApply(start, data) {
-        const changed = {};
-        const copyRowLength = data.length;
-        const colLength = this.columns.length;
-        const rowLength = this.dataStore.get('items').length;
-        // rows
-        let rowIndex = start.y;
-        let maxCol = 0;
-        for (let i = 0; rowIndex < rowLength && i < copyRowLength; rowIndex++, i++) {
-            // copy original data link
-            const copyRow = data[i % copyRowLength];
-            const copyColLength = (copyRow === null || copyRow === void 0 ? void 0 : copyRow.length) || 0;
-            // columns
-            let colIndex = start.x;
-            for (let j = 0; colIndex < colLength && j < copyColLength; colIndex++, j++) {
-                const p = this.columns[colIndex].prop;
-                const currentCol = j % colLength;
-                /** if can write */
-                if (!this.isReadOnly(rowIndex, colIndex)) {
-                    /** to show before save */
-                    if (!changed[rowIndex]) {
-                        changed[rowIndex] = {};
-                    }
-                    changed[rowIndex][p] = copyRow[currentCol];
-                }
-            }
-            maxCol = Math.max(maxCol, colIndex - 1);
-        }
-        const range = getRange(start, {
-            y: rowIndex - 1,
-            x: maxCol,
-        });
-        return {
-            changed,
-            range,
-        };
-    }
-    getRangeStaticData(d, value) {
-        const changed = {};
-        // rows
-        for (let rowIndex = d.y, i = 0; rowIndex < d.y1 + 1; rowIndex++, i++) {
-            // columns
-            for (let colIndex = d.x, j = 0; colIndex < d.x1 + 1; colIndex++, j++) {
-                // requested column beyond range
-                if (!this.columns[colIndex]) {
-                    continue;
-                }
-                const p = this.columns[colIndex].prop;
-                /** if can write */
-                if (!this.isReadOnly(rowIndex, colIndex)) {
-                    /** to show before save */
-                    if (!changed[rowIndex]) {
-                        changed[rowIndex] = {};
-                    }
-                    changed[rowIndex][p] = value;
-                }
-            }
-        }
-        return changed;
-    }
-    getRangeTransformedToProps(d, store) {
-        var _a;
-        const area = [];
-        const type = this.dataStore.get('type');
-        // rows
-        for (let rowIndex = d.y, i = 0; rowIndex < d.y1 + 1; rowIndex++, i++) {
-            // columns
-            for (let colIndex = d.x, j = 0; colIndex < d.x1 + 1; colIndex++, j++) {
-                const prop = (_a = this.columns[colIndex]) === null || _a === void 0 ? void 0 : _a.prop;
-                area.push({
-                    prop,
-                    rowIndex,
-                    colIndex,
-                    model: getSourceItem(store, rowIndex),
-                    type,
-                    colType: this.type,
-                });
-            }
-        }
-        return area;
-    }
-    copyRangeArray(range, store) {
-        const cols = [...this.columns];
-        const props = slice(cols, range.x, range.x1 + 1).map(v => v.prop);
-        const toCopy = [];
-        const mapping = {};
-        // rows indexes
-        for (let i = range.y; i <= range.y1; i++) {
-            const rgRow = [];
-            mapping[i] = {};
-            // columns indexes
-            for (let prop of props) {
-                const item = getSourceItem(store, i);
-                // if no item - skip
-                if (!item) {
-                    continue;
-                }
-                const val = item[prop];
-                rgRow.push(val);
-                mapping[i][prop] = val;
-            }
-            toCopy.push(rgRow);
-        }
-        return {
-            data: toCopy,
-            mapping,
-        };
-    }
-    destroy() {
-        this.unsubscribe.forEach(f => f());
-    }
+function scaleValue(value, from, to) {
+    return ((to[1] - to[0]) * (value - from[0])) / (from[1] - from[0]) + to[0];
 }
 /**
- * Checks if the given rowDrag is a service for dragging rows.
+ * Async timeout
  */
-function isRowDragService(rowDrag, model) {
-    if (typeof rowDrag === 'function') {
-        return rowDrag(model);
-    }
-    return !!rowDrag;
-}
-function mergeClasses(class1 = {}, class2 = {}) {
-    if (typeof class1 === 'string') {
-        class1 = { [class1]: true };
-    }
-    if (typeof class2 === 'string') {
-        class2 = { [class2]: true };
-    }
-    return Object.assign(Object.assign({}, class1), class2);
+async function timeout(delay = 0) {
+    await new Promise((r) => {
+        setTimeout(() => r(), delay);
+    });
 }
-function doPropMerge(existing, extra) {
-    // if className is provided - remove it from props it messing with stencil
-    if (extra.className) {
-        extra.class = mergeClasses(extra.class, extra.className);
-        delete extra.className;
-    }
-    let props = Object.assign(Object.assign({}, extra), existing);
-    // extend existing props
-    if (extra.class) {
-        props.class = mergeClasses(props.class, extra.class);
-    }
-    if (extra.style) {
-        props.style = Object.assign(Object.assign({}, extra.style), props.style);
-    }
-    return props;
+/**
+ * Type script mixins
+ */
+function applyMixins(derivedCtor, constructors) {
+    constructors.forEach(baseCtor => {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
+            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));
+        });
+    });
 }
 
-export { ColumnService as $, reduce as A, isArray$1 as B, baseEach$1 as C, DataStore as D, toInteger as E, isIterateeCall as F, isGrouping as G, getGroupingName as H, doPropMerge as I, GROUP_EXPANDED as J, getParsedGroup as K, isSameGroup as L, GROUP_DEPTH as M, PSEUDO_GROUP_ITEM_ID as N, GROUPING_ROW_TYPE as O, PSEUDO_GROUP_ITEM_VALUE as P, PSEUDO_GROUP_COLUMN as Q, GROUP_EXPAND_EVENT as R, SelectionStore as S, gatherGrouping as T, isGroupingColumn as U, baseProperty as V, isArrayLike as W, getTag$1 as X, baseKeys as Y, EMPTY_INDEX as Z, SelectionStoreConnector as _, getVisibleSourceItem as a, findIndex as a0, GROUP_EXPAND_BTN as a1, PSEUDO_GROUP_ITEM as a2, isRowDragService as a3, getNative as a4, baseIteratee as a5, getSourceItem as b, getSourcePhysicalIndex as c, setSourceByPhysicalIndex as d, setItems as e, getSourceItemVirtualIndexByProp as f, getPhysical as g, gatherTrimmedItems as h, isHiddenStore as i, cropCellToMax as j, getRange as k, isRangeSingleCell as l, setStore as m, nextCell as n, getCellData as o, proxyPlugin as p, getCellDataParsed as q, getColumnType as r, setSourceByVirtualIndex as s, trimmedPlugin as t, getColumnSizes as u, isColGrouping as v, getColumns as w, gatherGroup as x, getColumnByProp as y, createStore as z };
+export { keys as $, ROW_HEADER_TYPE as A, HEADER_SORTABLE_CLASS as B, CELL_CLASS as C, DataStore as D, HEADER_ROW_CLASS as E, HEADER_ACTUAL_ROW_CLASS as F, DRAG_ICON_CLASS as G, HEADER_CLASS as H, DRAGGABLE_CLASS as I, FOCUS_CLASS as J, MOBILE_CLASS as K, CELL_HANDLER_CLASS as L, MIN_COL_SIZE as M, EDIT_INPUT_WR as N, DRAGG_TEXT as O, GRID_INTERNALS as P, ROW_FOCUSED_CLASS as Q, RESIZE_INTERVAL as R, SELECTION_BORDER_CLASS as S, TMP_SELECTION_BG_CLASS as T, codesLetter as U, keyValues as V, createStore as W, identity as X, isArray$1 as Y, toInteger as Z, isIterateeCall as _, getVisibleSourceItem as a, isArrayLike as a0, baseIteratee as a1, OsPlatform as a2, KeyCodesEnum as a3, baseProperty as a4, getTag$1 as a5, baseKeys as a6, findIndex as a7, getNative as a8, getSourceItem as b, getSourcePhysicalIndex as c, setSourceByPhysicalIndex as d, setItems as e, getSourceItemVirtualIndexByProp as f, getPhysical as g, gatherTrimmedItems as h, calculateDimensionData as i, getItemByPosition as j, getItemByIndex as k, findPositionInArray as l, pushSorted as m, mergeSortedArray as n, getScrollbarSize as o, proxyPlugin as p, scaleValue as q, range as r, setSourceByVirtualIndex as s, trimmedPlugin as t, timeout as u, applyMixins as v, setStore as w, DATA_COL as x, DATA_ROW as y, DISABLED_CLASS as z };
 
-//# sourceMappingURL=column.service-751345b2.js.map
+//# sourceMappingURL=index-b1e05212.js.map