@revolist/revogrid 4.9.41 → 4.10.1

package/dist/cjs/{column.service-26c61ed6.js → index-91e92bea.js}

@@ -4,8 +4,7 @@
 'use strict';
 
 const debounce$1 = require('./debounce-ec7a04b4.js');
-const index = require('./index-3ab26ab9.js');
-const index$1 = require('./index-10d10c55.js');
+const index = require('./index-10d10c55.js');
 
 /**
  * Proxy plugin for data source.
@@ -2462,6 +2461,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.
  *
@@ -2528,7 +2547,7 @@ function baseIteratee(value) {
     return value;
   }
   if (value == null) {
-    return index.identity;
+    return identity;
   }
   if (typeof value == 'object') {
     return isArray$1(value)
@@ -2777,9 +2796,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);
@@ -2819,7 +2838,7 @@ const cleanupElements = debounce((map) => {
     }
 }, 2000);
 const stencilSubscription = () => {
-    if (typeof index$1.getRenderingRef !== 'function') {
+    if (typeof index.getRenderingRef !== 'function') {
         // If we are not in a stencil project, we do nothing.
         // This function is not really exported by @stencil/core.
         return {};
@@ -2828,7 +2847,7 @@ const stencilSubscription = () => {
     return {
         dispose: () => elmsToUpdate.clear(),
         get: (propName) => {
-            const elm = index$1.getRenderingRef();
+            const elm = index.getRenderingRef();
             if (elm) {
                 appendToMap(elmsToUpdate, propName, elm);
             }
@@ -2836,12 +2855,12 @@ const stencilSubscription = () => {
         set: (propName) => {
             const elements = elmsToUpdate.get(propName);
             if (elements) {
-                elmsToUpdate.set(propName, elements.filter(index$1.forceUpdate));
+                elmsToUpdate.set(propName, elements.filter(index.forceUpdate));
             }
             cleanupElements(elmsToUpdate);
         },
         reset: () => {
-            elmsToUpdate.forEach((elms) => elms.forEach(index$1.forceUpdate));
+            elmsToUpdate.forEach((elms) => elms.forEach(index.forceUpdate));
             cleanupElements(elmsToUpdate);
         },
     };
@@ -2979,18 +2998,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;
+            }
         }
     },
 });
@@ -3042,7 +3056,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,
@@ -3152,1305 +3166,511 @@ 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 = debounce$1.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 = debounce$1.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 && !debounce$1.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 = {}));
+exports.codesLetter = void 0;
+(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";
+})(exports.codesLetter || (exports.codesLetter = {}));
+exports.keyValues = void 0;
+(function (keyValues) {
+    keyValues["ENTER"] = "Enter";
+    keyValues["TAB"] = "Tab";
+})(exports.keyValues || (exports.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 = `${index.GRID_INTERNALS}-depth`;
-const PSEUDO_GROUP_ITEM = `${index.GRID_INTERNALS}-name`;
-const PSEUDO_GROUP_ITEM_ID = `${index.GRID_INTERNALS}-id`;
-const PSEUDO_GROUP_ITEM_VALUE = `${index.GRID_INTERNALS}-value`;
-const PSEUDO_GROUP_COLUMN = `${index.GRID_INTERNALS}-column`;
-const GROUP_EXPANDED = `${index.GRID_INTERNALS}-expanded`;
-const GROUP_ORIGINAL_INDEX = `${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)), { [index.CELL_CLASS]: true, [index.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));
+        });
+    });
 }
 
-exports.ColumnService = ColumnService;
+exports.CELL_CLASS = CELL_CLASS;
+exports.CELL_HANDLER_CLASS = CELL_HANDLER_CLASS;
+exports.DATA_COL = DATA_COL;
+exports.DATA_ROW = DATA_ROW;
+exports.DISABLED_CLASS = DISABLED_CLASS;
+exports.DRAGGABLE_CLASS = DRAGGABLE_CLASS;
+exports.DRAGG_TEXT = DRAGG_TEXT;
+exports.DRAG_ICON_CLASS = DRAG_ICON_CLASS;
 exports.DataStore = DataStore;
-exports.EMPTY_INDEX = EMPTY_INDEX;
-exports.GROUPING_ROW_TYPE = GROUPING_ROW_TYPE;
-exports.GROUP_DEPTH = GROUP_DEPTH;
-exports.GROUP_EXPANDED = GROUP_EXPANDED;
-exports.GROUP_EXPAND_BTN = GROUP_EXPAND_BTN;
-exports.GROUP_EXPAND_EVENT = GROUP_EXPAND_EVENT;
-exports.PSEUDO_GROUP_COLUMN = PSEUDO_GROUP_COLUMN;
-exports.PSEUDO_GROUP_ITEM = PSEUDO_GROUP_ITEM;
-exports.PSEUDO_GROUP_ITEM_ID = PSEUDO_GROUP_ITEM_ID;
-exports.PSEUDO_GROUP_ITEM_VALUE = PSEUDO_GROUP_ITEM_VALUE;
-exports.SelectionStore = SelectionStore;
-exports.SelectionStoreConnector = SelectionStoreConnector;
-exports.baseEach = baseEach$1;
+exports.EDIT_INPUT_WR = EDIT_INPUT_WR;
+exports.FOCUS_CLASS = FOCUS_CLASS;
+exports.GRID_INTERNALS = GRID_INTERNALS;
+exports.HEADER_ACTUAL_ROW_CLASS = HEADER_ACTUAL_ROW_CLASS;
+exports.HEADER_CLASS = HEADER_CLASS;
+exports.HEADER_ROW_CLASS = HEADER_ROW_CLASS;
+exports.HEADER_SORTABLE_CLASS = HEADER_SORTABLE_CLASS;
+exports.KeyCodesEnum = KeyCodesEnum;
+exports.MIN_COL_SIZE = MIN_COL_SIZE;
+exports.MOBILE_CLASS = MOBILE_CLASS;
+exports.OsPlatform = OsPlatform;
+exports.RESIZE_INTERVAL = RESIZE_INTERVAL;
+exports.ROW_FOCUSED_CLASS = ROW_FOCUSED_CLASS;
+exports.ROW_HEADER_TYPE = ROW_HEADER_TYPE;
+exports.SELECTION_BORDER_CLASS = SELECTION_BORDER_CLASS;
+exports.TMP_SELECTION_BG_CLASS = TMP_SELECTION_BG_CLASS;
+exports.applyMixins = applyMixins;
 exports.baseIteratee = baseIteratee;
 exports.baseKeys = baseKeys;
 exports.baseProperty = baseProperty;
+exports.calculateDimensionData = calculateDimensionData;
 exports.createStore = createStore;
-exports.cropCellToMax = cropCellToMax;
-exports.doPropMerge = doPropMerge;
 exports.findIndex = findIndex;
-exports.gatherGroup = gatherGroup;
-exports.gatherGrouping = gatherGrouping;
+exports.findPositionInArray = findPositionInArray;
 exports.gatherTrimmedItems = gatherTrimmedItems;
-exports.getCellData = getCellData;
-exports.getCellDataParsed = getCellDataParsed;
-exports.getColumnByProp = getColumnByProp;
-exports.getColumnSizes = getColumnSizes;
-exports.getColumnType = getColumnType;
-exports.getColumns = getColumns;
-exports.getGroupingName = getGroupingName;
+exports.getItemByIndex = getItemByIndex;
+exports.getItemByPosition = getItemByPosition;
 exports.getNative = getNative;
-exports.getParsedGroup = getParsedGroup;
 exports.getPhysical = getPhysical;
-exports.getRange = getRange;
+exports.getScrollbarSize = getScrollbarSize;
 exports.getSourceItem = getSourceItem;
 exports.getSourceItemVirtualIndexByProp = getSourceItemVirtualIndexByProp;
 exports.getSourcePhysicalIndex = getSourcePhysicalIndex;
 exports.getTag = getTag$1;
 exports.getVisibleSourceItem = getVisibleSourceItem;
+exports.identity = identity;
 exports.isArray = isArray$1;
 exports.isArrayLike = isArrayLike;
-exports.isColGrouping = isColGrouping;
-exports.isGrouping = isGrouping;
-exports.isGroupingColumn = isGroupingColumn;
-exports.isHiddenStore = isHiddenStore;
 exports.isIterateeCall = isIterateeCall;
-exports.isRangeSingleCell = isRangeSingleCell;
-exports.isRowDragService = isRowDragService;
-exports.isSameGroup = isSameGroup;
-exports.nextCell = nextCell;
+exports.keys = keys;
+exports.mergeSortedArray = mergeSortedArray;
 exports.proxyPlugin = proxyPlugin;
-exports.reduce = reduce;
+exports.pushSorted = pushSorted;
+exports.range = range;
+exports.scaleValue = scaleValue;
 exports.setItems = setItems;
 exports.setSourceByPhysicalIndex = setSourceByPhysicalIndex;
 exports.setSourceByVirtualIndex = setSourceByVirtualIndex;
 exports.setStore = setStore;
+exports.timeout = timeout;
 exports.toInteger = toInteger;
 exports.trimmedPlugin = trimmedPlugin;
 
-//# sourceMappingURL=column.service-26c61ed6.js.map
+//# sourceMappingURL=index-91e92bea.js.map