@dlh.io/bideux 0.1.0

package/dist/element/chunk-AOKCBPMV.js

@@ -0,0 +1,1646 @@
+import { root, Symbol, isObjectLike, freeGlobal, baseGetTag, isObject, toNumber, isSymbol } from './chunk-TFV4CJR4.js';
+import { StencilCore } from './chunk-G3C722QP.js';
+
+// ../../node_modules/.pnpm/@revolist+revogrid@4.25.2/node_modules/@revolist/revogrid/dist/esm/dimension.helpers-fl4HSSK9.js
+var proxyPlugin = (store) => ({
+  /**
+   * Set the value of a property in the store.
+   * If the key is 'proxyItems' it will filter the items in the data source according to the new value.
+   * The new value should be an array of numbers representing the indexes of the items that should be visible.
+   * The method will return a new array of numbers with the indexes of the items that should be visible.
+   * The method will also update the 'items' property of the store with the new array.
+   */
+  set(k, newVal) {
+    if (k !== "proxyItems") {
+      return;
+    }
+    const oldItems = store.get("items").reduce((r, v) => {
+      r.add(v);
+      return r;
+    }, /* @__PURE__ */ new Set());
+    const newItems = newVal.reduce((r, i) => {
+      if (oldItems.has(i)) {
+        r.push(i);
+      }
+      return r;
+    }, []);
+    store.set("items", newItems);
+  }
+});
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length, index = fromIndex + -1;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var asyncTag = "[object AsyncFunction]";
+var funcTag$1 = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var coreJsData = root["__core-js_shared__"];
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype;
+var objectProto$9 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$7).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var Map$1 = getNative(root, "Map");
+var nativeCreate = getNative(Object, "create");
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$6.call(data, key) ? data[key] : void 0;
+}
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$5 = objectProto$7.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== void 0 : hasOwnProperty$5.call(data, key);
+}
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$1 || ListCache)(),
+    "string": new Hash()
+  };
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+function SetCache(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+function arraySome(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var COMPARE_PARTIAL_FLAG$5 = 1;
+var COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var Uint8Array = root.Uint8Array;
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var COMPARE_PARTIAL_FLAG$4 = 1;
+var COMPARE_UNORDERED_FLAG$2 = 2;
+var boolTag$1 = "[object Boolean]";
+var dateTag$1 = "[object Date]";
+var errorTag$1 = "[object Error]";
+var mapTag$2 = "[object Map]";
+var numberTag$1 = "[object Number]";
+var regexpTag$1 = "[object RegExp]";
+var setTag$2 = "[object Set]";
+var stringTag$1 = "[object String]";
+var symbolTag = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]";
+var dataViewTag$2 = "[object DataView]";
+var symbolProto$1 = Symbol ? Symbol.prototype : void 0;
+var symbolValueOf = symbolProto$1 ? symbolProto$1.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag$2:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag$1:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+        return false;
+      }
+      return true;
+    case boolTag$1:
+    case dateTag$1:
+    case numberTag$1:
+      return eq(+object, +other);
+    case errorTag$1:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag$1:
+    case stringTag$1:
+      return object == other + "";
+    case mapTag$2:
+      var convert = mapToArray;
+    case setTag$2:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var isArray = Array.isArray;
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var objectProto$6 = Object.prototype;
+var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable$1.call(object, symbol);
+  });
+};
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+}
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+var propertyIsEnumerable = objectProto$5.propertyIsEnumerable;
+var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$4.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+function stubFalse() {
+  return false;
+}
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var Buffer = moduleExports$1 ? root.Buffer : void 0;
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse;
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var argsTag$1 = "[object Arguments]";
+var arrayTag$1 = "[object Array]";
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var funcTag = "[object Function]";
+var mapTag$1 = "[object Map]";
+var numberTag = "[object Number]";
+var objectTag$2 = "[object Object]";
+var regexpTag = "[object RegExp]";
+var setTag$1 = "[object Set]";
+var stringTag = "[object String]";
+var weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag$1 = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag$1] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag$1] = typedArrayTags[numberTag] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag] = typedArrayTags[setTag$1] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag$1] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var freeProcess = moduleExports && freeGlobal.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule && freeModule.require && freeModule.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}();
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if (hasOwnProperty$3.call(value, key) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto$3 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$3;
+  return value === proto;
+}
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var nativeKeys = overArg(Object.keys, Object);
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$2.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var DataView = getNative(root, "DataView");
+var Promise$1 = getNative(root, "Promise");
+var Set$1 = getNative(root, "Set");
+var WeakMap = getNative(root, "WeakMap");
+var mapTag = "[object Map]";
+var objectTag$1 = "[object Object]";
+var promiseTag = "[object Promise]";
+var setTag = "[object Set]";
+var weakMapTag = "[object WeakMap]";
+var dataViewTag = "[object DataView]";
+var dataViewCtorString = toSource(DataView);
+var mapCtorString = toSource(Map$1);
+var promiseCtorString = toSource(Promise$1);
+var setCtorString = toSource(Set$1);
+var weakMapCtorString = toSource(WeakMap);
+var getTag = baseGetTag;
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag(new Map$1()) != mapTag || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+  getTag = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag;
+        case mapCtorString:
+          return mapTag;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+var COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag = "[object Arguments]";
+var arrayTag = "[object Array]";
+var objectTag = "[object Object]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var COMPARE_PARTIAL_FLAG$1 = 1;
+var COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length, length = index;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (data[2]) {
+      if (objValue === void 0 && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack();
+      var result;
+      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isStrictComparable(value) {
+  return value === value && !isObject(value);
+}
+function getMatchData(object) {
+  var result = keys(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, isStrictComparable(value)];
+  }
+  return result;
+}
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+function baseMatches(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+var reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache)();
+  return memoized;
+}
+memoize.Cache = MapCache;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var symbolProto = Symbol ? Symbol.prototype : void 0;
+var symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+function toKey(value) {
+  if (typeof value == "string" || isSymbol(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+function baseGet(object, path) {
+  path = castPath(path, object);
+  var index = 0, length = path.length;
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return index && index == length ? object : void 0;
+}
+function get(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+}
+function hasIn(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+var COMPARE_PARTIAL_FLAG = 1;
+var COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+function identity(value) {
+  return value;
+}
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+function property(path) {
+  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+function baseIteratee(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == "object") {
+    return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  }
+  return property(value);
+}
+var INFINITY = 1 / 0;
+var MAX_INTEGER = 17976931348623157e292;
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+function findIndex(array, predicate, fromIndex) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return -1;
+  }
+  var index = 0;
+  return baseFindIndex(array, baseIteratee(predicate), index);
+}
+var nativeCeil = Math.ceil;
+var nativeMax = Math.max;
+function baseRange(start, end, step, fromRight) {
+  var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result = Array(length);
+  while (length--) {
+    result[++index] = start;
+    start += step;
+  }
+  return result;
+}
+function isIterateeCall(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+function createRange(fromRight) {
+  return function(start, end, step) {
+    if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
+      end = step = void 0;
+    }
+    start = toFinite(start);
+    if (end === void 0) {
+      end = start;
+      start = 0;
+    } else {
+      end = toFinite(end);
+    }
+    step = step === void 0 ? start < end ? 1 : -1 : toFinite(step);
+    return baseRange(start, end, step);
+  };
+}
+var range = createRange();
+var appendToMap = (map, propName, value) => {
+  let refs = map.get(propName);
+  if (!refs) {
+    refs = [];
+    map.set(propName, refs);
+  }
+  if (!refs.some((ref) => ref.deref() === value)) {
+    refs.push(new WeakRef(value));
+  }
+};
+var debounce = (fn, ms) => {
+  let timeoutId;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = 0;
+      fn(...args);
+    }, ms);
+  };
+};
+var isConnected = (maybeElement) => !("isConnected" in maybeElement) || maybeElement.isConnected;
+var cleanupElements = debounce((map) => {
+  for (let key of map.keys()) {
+    const refs = map.get(key).filter((ref) => {
+      const elm = ref.deref();
+      return elm && isConnected(elm);
+    });
+    map.set(key, refs);
+  }
+}, 2e3);
+var core = StencilCore;
+var forceUpdate = core.forceUpdate;
+var getRenderingRef = core.getRenderingRef;
+var stencilSubscription = () => {
+  if (typeof getRenderingRef !== "function" || typeof forceUpdate !== "function") {
+    return {};
+  }
+  const ensureForceUpdate = forceUpdate;
+  const ensureGetRenderingRef = getRenderingRef;
+  const elmsToUpdate = /* @__PURE__ */ new Map();
+  return {
+    dispose: () => elmsToUpdate.clear(),
+    get: (propName) => {
+      const elm = ensureGetRenderingRef();
+      if (elm) {
+        appendToMap(elmsToUpdate, propName, elm);
+      }
+    },
+    set: (propName) => {
+      const refs = elmsToUpdate.get(propName);
+      if (refs) {
+        const nextRefs = refs.filter((ref) => {
+          const elm = ref.deref();
+          if (!elm)
+            return false;
+          return ensureForceUpdate(elm);
+        });
+        elmsToUpdate.set(propName, nextRefs);
+      }
+      cleanupElements(elmsToUpdate);
+    },
+    reset: () => {
+      elmsToUpdate.forEach((refs) => {
+        refs.forEach((ref) => {
+          const elm = ref.deref();
+          if (elm)
+            ensureForceUpdate(elm);
+        });
+      });
+      cleanupElements(elmsToUpdate);
+    }
+  };
+};
+var unwrap = (val) => typeof val === "function" ? val() : val;
+var createObservableMap = (defaultState, shouldUpdate = (a, b) => a !== b) => {
+  const resolveDefaultState = () => unwrap(defaultState) ?? {};
+  const initialState = resolveDefaultState();
+  let states = new Map(Object.entries(initialState));
+  const proxyAvailable = typeof Proxy !== "undefined";
+  const plainState = proxyAvailable ? null : {};
+  const handlers = {
+    dispose: [],
+    get: [],
+    set: [],
+    reset: []
+  };
+  const changeListeners = /* @__PURE__ */ new Map();
+  const reset = () => {
+    states = new Map(Object.entries(resolveDefaultState()));
+    if (!proxyAvailable) {
+      syncPlainStateKeys();
+    }
+    handlers.reset.forEach((cb) => cb());
+  };
+  const dispose = () => {
+    handlers.dispose.forEach((cb) => cb());
+    reset();
+  };
+  const get2 = (propName) => {
+    handlers.get.forEach((cb) => cb(propName));
+    return states.get(propName);
+  };
+  const set = (propName, value) => {
+    const oldValue = states.get(propName);
+    if (shouldUpdate(value, oldValue, propName)) {
+      states.set(propName, value);
+      if (!proxyAvailable) {
+        ensurePlainProperty(propName);
+      }
+      handlers.set.forEach((cb) => cb(propName, value, oldValue));
+    }
+  };
+  const state = proxyAvailable ? new Proxy(initialState, {
+    get(_, propName) {
+      return get2(propName);
+    },
+    ownKeys(_) {
+      return Array.from(states.keys());
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: true,
+        configurable: true
+      };
+    },
+    has(_, propName) {
+      return states.has(propName);
+    },
+    set(_, propName, value) {
+      set(propName, value);
+      return true;
+    }
+  }) : (() => {
+    syncPlainStateKeys();
+    return plainState;
+  })();
+  const on = (eventName, callback) => {
+    handlers[eventName].push(callback);
+    return () => {
+      removeFromArray(handlers[eventName], callback);
+    };
+  };
+  const onChange = (propName, cb) => {
+    const setHandler = (key, newValue) => {
+      if (key === propName) {
+        cb(newValue);
+      }
+    };
+    const resetHandler = () => {
+      const snapshot = resolveDefaultState();
+      cb(snapshot[propName]);
+    };
+    const unSet = on("set", setHandler);
+    const unReset = on("reset", resetHandler);
+    changeListeners.set(cb, { setHandler, resetHandler, propName });
+    return () => {
+      unSet();
+      unReset();
+      changeListeners.delete(cb);
+    };
+  };
+  const use = (...subscriptions) => {
+    const unsubs = subscriptions.reduce((unsubs2, subscription) => {
+      if (subscription.set) {
+        unsubs2.push(on("set", subscription.set));
+      }
+      if (subscription.get) {
+        unsubs2.push(on("get", subscription.get));
+      }
+      if (subscription.reset) {
+        unsubs2.push(on("reset", subscription.reset));
+      }
+      if (subscription.dispose) {
+        unsubs2.push(on("dispose", subscription.dispose));
+      }
+      return unsubs2;
+    }, []);
+    return () => unsubs.forEach((unsub) => unsub());
+  };
+  const forceUpdate2 = (key) => {
+    const oldValue = states.get(key);
+    handlers.set.forEach((cb) => cb(key, oldValue, oldValue));
+  };
+  const removeListener = (propName, listener) => {
+    const listenerInfo = changeListeners.get(listener);
+    if (listenerInfo && listenerInfo.propName === propName) {
+      removeFromArray(handlers.set, listenerInfo.setHandler);
+      removeFromArray(handlers.reset, listenerInfo.resetHandler);
+      changeListeners.delete(listener);
+    }
+  };
+  function ensurePlainProperty(key) {
+    if (proxyAvailable || !plainState) {
+      return;
+    }
+    if (Object.prototype.hasOwnProperty.call(plainState, key)) {
+      return;
+    }
+    Object.defineProperty(plainState, key, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return get2(key);
+      },
+      set(value) {
+        set(key, value);
+      }
+    });
+  }
+  function syncPlainStateKeys() {
+    if (proxyAvailable || !plainState) {
+      return;
+    }
+    const knownKeys = new Set(states.keys());
+    for (const key of Object.keys(plainState)) {
+      if (!knownKeys.has(key)) {
+        delete plainState[key];
+      }
+    }
+    for (const key of knownKeys) {
+      ensurePlainProperty(key);
+    }
+  }
+  return {
+    state,
+    get: get2,
+    set,
+    on,
+    onChange,
+    use,
+    dispose,
+    reset,
+    forceUpdate: forceUpdate2,
+    removeListener
+  };
+};
+var removeFromArray = (array, item) => {
+  const index = array.indexOf(item);
+  if (index >= 0) {
+    array[index] = array[array.length - 1];
+    array.length--;
+  }
+};
+var createStore = (defaultState, shouldUpdate) => {
+  const map = createObservableMap(defaultState, shouldUpdate);
+  map.use(stencilSubscription());
+  return map;
+};
+var trimmedPlugin = (store) => ({
+  set(k, newVal) {
+    switch (k) {
+      case "trimmed": {
+        const proxy = store.get("proxyItems");
+        const trimmed = gatherTrimmedItems(newVal);
+        const newItems = proxy.filter((v) => !trimmed[v]);
+        store.set("items", newItems);
+        break;
+      }
+    }
+  }
+});
+function gatherTrimmedItems(trimmedItems) {
+  const trimmed = {};
+  for (let trimmedKey in trimmedItems) {
+    for (let t in trimmedItems[trimmedKey]) {
+      trimmed[t] = trimmed[t] || trimmedItems[trimmedKey][t];
+    }
+  }
+  return trimmed;
+}
+function setStore(store, data) {
+  for (const key of Object.keys(data)) {
+    store.set(key, data[key]);
+  }
+}
+var MIN_COL_SIZE = 30;
+var RESIZE_INTERVAL = 40;
+var DATA_COL = "data-rgCol";
+var DATA_ROW = "data-rgRow";
+var DISABLED_CLASS = "disabled";
+var CELL_CLASS = "rgCell";
+var ROW_HEADER_TYPE = "rowHeaders";
+var HEADER_CLASS = "rgHeaderCell";
+var HEADER_SORTABLE_CLASS = "sortable";
+var HEADER_ROW_CLASS = "header-rgRow";
+var HEADER_ACTUAL_ROW_CLASS = "actual-rgRow";
+var DRAG_ICON_CLASS = "revo-drag-icon";
+var DRAGGABLE_CLASS = "revo-draggable";
+var FOCUS_CLASS = "focused-cell";
+var SELECTION_BORDER_CLASS = "selection-border-range";
+var MOBILE_CLASS = "mobile-handler";
+var TMP_SELECTION_BG_CLASS = "temp-bg-range";
+var CELL_HANDLER_CLASS = "autofill-handle";
+var EDIT_INPUT_WR = "edit-input-wrapper";
+var DRAGG_TEXT = "Draggable item";
+var GRID_INTERNALS = "__rvgr";
+var ROW_FOCUSED_CLASS = "focused-rgRow";
+var codes;
+(function(codes2) {
+  codes2[codes2["MOUSE_LEFT"] = 1] = "MOUSE_LEFT";
+  codes2[codes2["MOUSE_RIGHT"] = 3] = "MOUSE_RIGHT";
+  codes2[codes2["MOUSE_MIDDLE"] = 2] = "MOUSE_MIDDLE";
+  codes2[codes2["BACKSPACE"] = 8] = "BACKSPACE";
+  codes2[codes2["COMMA"] = 188] = "COMMA";
+  codes2[codes2["INSERT"] = 45] = "INSERT";
+  codes2[codes2["DELETE"] = 46] = "DELETE";
+  codes2[codes2["END"] = 35] = "END";
+  codes2[codes2["ENTER"] = 13] = "ENTER";
+  codes2[codes2["ESCAPE"] = 27] = "ESCAPE";
+  codes2[codes2["CONTROL"] = 17] = "CONTROL";
+  codes2[codes2["COMMAND_LEFT"] = 91] = "COMMAND_LEFT";
+  codes2[codes2["COMMAND_RIGHT"] = 93] = "COMMAND_RIGHT";
+  codes2[codes2["COMMAND_FIREFOX"] = 224] = "COMMAND_FIREFOX";
+  codes2[codes2["ALT"] = 18] = "ALT";
+  codes2[codes2["HOME"] = 36] = "HOME";
+  codes2[codes2["PAGE_DOWN"] = 34] = "PAGE_DOWN";
+  codes2[codes2["PAGE_UP"] = 33] = "PAGE_UP";
+  codes2[codes2["PERIOD"] = 190] = "PERIOD";
+  codes2[codes2["SPACE"] = 32] = "SPACE";
+  codes2[codes2["SHIFT"] = 16] = "SHIFT";
+  codes2[codes2["CAPS_LOCK"] = 20] = "CAPS_LOCK";
+  codes2[codes2["TAB"] = 9] = "TAB";
+  codes2[codes2["ARROW_RIGHT"] = 39] = "ARROW_RIGHT";
+  codes2[codes2["ARROW_LEFT"] = 37] = "ARROW_LEFT";
+  codes2[codes2["ARROW_UP"] = 38] = "ARROW_UP";
+  codes2[codes2["ARROW_DOWN"] = 40] = "ARROW_DOWN";
+  codes2[codes2["F1"] = 112] = "F1";
+  codes2[codes2["F2"] = 113] = "F2";
+  codes2[codes2["F3"] = 114] = "F3";
+  codes2[codes2["F4"] = 115] = "F4";
+  codes2[codes2["F5"] = 116] = "F5";
+  codes2[codes2["F6"] = 117] = "F6";
+  codes2[codes2["F7"] = 118] = "F7";
+  codes2[codes2["F8"] = 119] = "F8";
+  codes2[codes2["F9"] = 120] = "F9";
+  codes2[codes2["F10"] = 121] = "F10";
+  codes2[codes2["F11"] = 122] = "F11";
+  codes2[codes2["F12"] = 123] = "F12";
+  codes2[codes2["A"] = 65] = "A";
+  codes2[codes2["C"] = 67] = "C";
+  codes2[codes2["D"] = 68] = "D";
+  codes2[codes2["F"] = 70] = "F";
+  codes2[codes2["L"] = 76] = "L";
+  codes2[codes2["O"] = 79] = "O";
+  codes2[codes2["P"] = 80] = "P";
+  codes2[codes2["S"] = 83] = "S";
+  codes2[codes2["V"] = 86] = "V";
+  codes2[codes2["X"] = 88] = "X";
+})(codes || (codes = {}));
+var codesLetter;
+(function(codesLetter2) {
+  codesLetter2["ENTER"] = "Enter";
+  codesLetter2["ENTER_NUM"] = "NumpadEnter";
+  codesLetter2["A"] = "KeyA";
+  codesLetter2["C"] = "KeyC";
+  codesLetter2["X"] = "KeyX";
+  codesLetter2["V"] = "KeyV";
+  codesLetter2["ESCAPE"] = "Escape";
+  codesLetter2["TAB"] = "Tab";
+  codesLetter2["BACKSPACE"] = "Backspace";
+  codesLetter2["DELETE"] = "Delete";
+  codesLetter2["ARROW_RIGHT"] = "ArrowRight";
+  codesLetter2["ARROW_LEFT"] = "ArrowLeft";
+  codesLetter2["ARROW_UP"] = "ArrowUp";
+  codesLetter2["ARROW_DOWN"] = "ArrowDown";
+  codesLetter2["SHIFT"] = "Shift";
+})(codesLetter || (codesLetter = {}));
+var keyValues;
+(function(keyValues2) {
+  keyValues2["ENTER"] = "Enter";
+  keyValues2["TAB"] = "Tab";
+})(keyValues || (keyValues = {}));
+var osPlatform;
+(function(osPlatform2) {
+  osPlatform2["mac"] = "Mac";
+})(osPlatform || (osPlatform = {}));
+var DataStore = class {
+  get store() {
+    return this.dataStore;
+  }
+  constructor(type, storeData) {
+    const store = this.dataStore = createStore(Object.assign({ items: [], proxyItems: [], source: [], groupingDepth: 0, groups: {}, type, trimmed: {}, groupingCustomRenderer: void 0, groupingCellRenderer: void 0 }, storeData));
+    store.use(proxyPlugin(store));
+    store.use(trimmedPlugin(store));
+  }
+  /**
+   * full data source update
+   * @param source - data column/rgRow source
+   * @param grouping - grouping information if present
+   * @param silent - if true, store will be updated without resetting trimmed state
+   * @param preserveTrimmed - if true, current trimmed indexes will be re-applied to the new source, use with caution because physical indexes may change across full data refreshes
+   */
+  updateData(source, grouping, silent = false, preserveTrimmed = false) {
+    const trimmed = this.store.get("trimmed");
+    const trimmedItems = silent && preserveTrimmed ? gatherTrimmedItems(trimmed) : null;
+    if (!silent) {
+      this.store.set("trimmed", {});
+    }
+    this.store.set("items", []);
+    const items = range(0, (source === null || source === void 0 ? void 0 : source.length) || 0);
+    setStore(this.store, {
+      source,
+      proxyItems: [...items]
+    });
+    this.store.set("items", trimmedItems ? items.filter((i) => !trimmedItems[i]) : items);
+    if (grouping) {
+      setStore(this.store, {
+        groupingDepth: grouping.depth,
+        // if groups are not provided, we will consider that there is only one group with all items
+        groups: grouping.groups,
+        groupingCustomRenderer: grouping.customRenderer,
+        groupingCellRenderer: grouping.cellRenderer
+      });
+    }
+  }
+  addTrimmed(some) {
+    let trimmed = this.store.get("trimmed");
+    trimmed = Object.assign(Object.assign({}, trimmed), some);
+    setStore(this.store, { trimmed });
+  }
+  setSourceData(items, mutate = true) {
+    setSourceByVirtualIndex(this.store, items, mutate);
+  }
+  // local data update
+  setData(input) {
+    const data = Object.assign({}, input);
+    setStore(this.store, data);
+  }
+  refresh() {
+    const source = this.store.get("source");
+    this.store.set("source", [...source]);
+  }
+};
+function getPhysical(store, virtualIndex) {
+  const items = store.get("items");
+  return items[virtualIndex];
+}
+function getVisibleSourceItem(store) {
+  const source = store.get("source");
+  return store.get("items").map((v) => source[v]);
+}
+var getSourceItem = (store, virtualIndex) => {
+  const source = store.get("source");
+  return source[getSourcePhysicalIndex(store, virtualIndex)];
+};
+var getSourcePhysicalIndex = (store, virtualIndex) => {
+  const items = store.get("items");
+  return items[virtualIndex];
+};
+function setSourceByVirtualIndex(store, modelByIndex, mutate = true) {
+  const items = store.get("items");
+  const source = store.get("source");
+  for (let virtualIndex in modelByIndex) {
+    const realIndex = items[virtualIndex];
+    const item = modelByIndex[virtualIndex];
+    source[realIndex] = item;
+  }
+  if (mutate) {
+    store.set("source", [...source]);
+  }
+}
+function setSourceByPhysicalIndex(store, modelByIndex, mutate = true) {
+  const source = store.get("source");
+  for (let index in modelByIndex) {
+    source[index] = modelByIndex[index];
+  }
+  if (mutate) {
+    store.set("source", [...source]);
+  }
+}
+function setItems(store, items) {
+  store.set("items", items);
+}
+function getSourceItemVirtualIndexByProp(store, prop) {
+  const items = store.get("items");
+  const source = store.get("source");
+  const physicalIndex = findIndex(source, { prop });
+  return items.indexOf(physicalIndex);
+}
+var MAX_ARRAY_LENGTH$1 = 4294967295;
+var MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH$1 - 1;
+var nativeFloor = Math.floor;
+var nativeMin = Math.min;
+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 === void 0;
+  while (low < high) {
+    var mid = nativeFloor((low + high) / 2), computed = iteratee(array[mid]), othIsDefined = computed !== void 0, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
+    if (valIsNaN) {
+      var setLow = othIsReflexive;
+    } else if (valIsUndefined) {
+      setLow = othIsReflexive && othIsDefined;
+    } else if (valIsNull) {
+      setLow = othIsReflexive && othIsDefined && !othIsNull;
+    } else if (valIsSymbol) {
+      setLow = othIsReflexive && othIsDefined && !othIsNull && !othIsSymbol;
+    } else if (othIsNull || othIsSymbol) {
+      setLow = false;
+    } else {
+      setLow = computed < value;
+    }
+    if (setLow) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return nativeMin(high, MAX_ARRAY_INDEX);
+}
+var MAX_ARRAY_LENGTH = 4294967295;
+var HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+function baseSortedIndex(array, value, retHighest) {
+  var low = 0, high = array == null ? low : array.length;
+  if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+    while (low < high) {
+      var mid = low + high >>> 1, computed = array[mid];
+      if (computed !== null && !isSymbol(computed) && computed < value) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    return high;
+  }
+  return baseSortedIndexBy(array, value, identity);
+}
+function sortedIndex(array, value) {
+  return baseSortedIndex(array, value);
+}
+function calculateDimensionData(originItemSize, newSizes = {}) {
+  const positionIndexes = [];
+  const positionIndexToItem = {};
+  const indexToItem = {};
+  const newIndexes = Object.keys(newSizes).map(Number).sort((a, b) => a - b);
+  let previous;
+  for (let i = 0; i < newIndexes.length; i++) {
+    const itemIndex = newIndexes[i];
+    const newItem = {
+      itemIndex,
+      start: 0,
+      end: 0
+    };
+    if (previous) {
+      const itemsBetween = (itemIndex - previous.itemIndex - 1) * originItemSize;
+      newItem.start = itemsBetween + previous.end;
+    } else {
+      newItem.start = itemIndex * originItemSize;
+    }
+    newItem.end = newItem.start + newSizes[itemIndex];
+    positionIndexes.push(newItem.start);
+    indexToItem[itemIndex] = positionIndexToItem[i] = newItem;
+    previous = newItem;
+  }
+  return {
+    indexes: newIndexes,
+    positionIndexes: [...positionIndexes],
+    positionIndexToItem: Object.assign({}, positionIndexToItem),
+    indexToItem
+  };
+}
+var getItemByPosition = ({ indexes, positionIndexes, originItemSize, positionIndexToItem }, pos) => {
+  const item = {
+    itemIndex: 0,
+    start: 0,
+    end: 0
+  };
+  const currentPlace = indexes.length ? sortedIndex(positionIndexes, pos) : 0;
+  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 (positionItem.end > pos) {
+    return positionItem;
+  }
+  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 (dimension.indexToItem[index]) {
+    return dimension.indexToItem[index];
+  }
+  const currentPlace = dimension.indexes.length ? sortedIndex(dimension.indexes, index) : 0;
+  if (!currentPlace) {
+    item.start = item.itemIndex * dimension.originItemSize;
+    item.end = item.start + dimension.originItemSize;
+    return item;
+  }
+  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;
+}
+/*! Bundled license information:
+
+@revolist/revogrid/dist/esm/dimension.helpers-fl4HSSK9.js:
+  (*!
+   * Built by Revolist OU ❤️
+   *)
+*/
+
+export { CELL_CLASS, CELL_HANDLER_CLASS, DATA_COL, DATA_ROW, DISABLED_CLASS, DRAGGABLE_CLASS, DRAGG_TEXT, DRAG_ICON_CLASS, DataStore, EDIT_INPUT_WR, FOCUS_CLASS, GRID_INTERNALS, HEADER_ACTUAL_ROW_CLASS, HEADER_CLASS, HEADER_ROW_CLASS, HEADER_SORTABLE_CLASS, MIN_COL_SIZE, MOBILE_CLASS, RESIZE_INTERVAL, ROW_FOCUSED_CLASS, ROW_HEADER_TYPE, SELECTION_BORDER_CLASS, TMP_SELECTION_BG_CLASS, baseIteratee, calculateDimensionData, codesLetter, createStore, gatherTrimmedItems, getItemByIndex, getItemByPosition, getPhysical, getSourceItem, getSourceItemVirtualIndexByProp, getVisibleSourceItem, identity, isArray, isArrayLike, isIterateeCall, keyValues, keys, setItems, setSourceByPhysicalIndex, setSourceByVirtualIndex, setStore, toFinite };
+//# sourceMappingURL=chunk-AOKCBPMV.js.map
+//# sourceMappingURL=chunk-AOKCBPMV.js.map