jquery.dgtable 0.5.59 → 0.6.0

package/dist/jquery.dgtable.cjs.js

@@ -1,5 +1,5 @@
 /*!
- * jquery.dgtable 0.5.59
+ * jquery.dgtable 0.6.0
  * git://github.com/danielgindi/jquery.dgtable.git
  */
 'use strict';
@@ -15,7 +15,7 @@ var check = function (it) {
 };
 
 // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
-var global$a =
+var global$b =
   // eslint-disable-next-line es/no-global-this -- safe
   check(typeof globalThis == 'object' && globalThis) ||
   check(typeof window == 'object' && window) ||
@@ -91,19 +91,19 @@ var FunctionPrototype$1 = Function.prototype;
 var call$3 = FunctionPrototype$1.call;
 var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype$1.bind.bind(call$3, call$3);
 
-var functionUncurryThisRaw = function (fn) {
-  return NATIVE_BIND ? uncurryThisWithBind(fn) : function () {
+var functionUncurryThisRaw = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
+  return function () {
     return call$3.apply(fn, arguments);
   };
 };
 
 var uncurryThisRaw$1 = functionUncurryThisRaw;
 
-var toString$3 = uncurryThisRaw$1({}.toString);
-var stringSlice = uncurryThisRaw$1(''.slice);
+var toString$4 = uncurryThisRaw$1({}.toString);
+var stringSlice$1 = uncurryThisRaw$1(''.slice);
 
 var classofRaw$2 = function (it) {
-  return stringSlice(toString$3(it), 8, -1);
+  return stringSlice$1(toString$4(it), 8, -1);
 };
 
 var classofRaw$1 = classofRaw$2;
@@ -116,12 +116,12 @@ var functionUncurryThis = function (fn) {
   if (classofRaw$1(fn) === 'Function') return uncurryThisRaw(fn);
 };
 
-var uncurryThis$7 = functionUncurryThis;
+var uncurryThis$8 = functionUncurryThis;
 var fails$7 = fails$a;
 var classof$2 = classofRaw$2;
 
 var $Object$3 = Object;
-var split = uncurryThis$7(''.split);
+var split = uncurryThis$8(''.split);
 
 // fallback for non-array-like ES3 and non-enumerable old V8 strings
 var indexedObject = fails$7(function () {
@@ -173,47 +173,47 @@ var documentAll$1 = $documentAll$1.all;
 
 // `IsCallable` abstract operation
 // https://tc39.es/ecma262/#sec-iscallable
-var isCallable$b = $documentAll$1.IS_HTMLDDA ? function (argument) {
+var isCallable$c = $documentAll$1.IS_HTMLDDA ? function (argument) {
   return typeof argument == 'function' || argument === documentAll$1;
 } : function (argument) {
   return typeof argument == 'function';
 };
 
-var isCallable$a = isCallable$b;
+var isCallable$b = isCallable$c;
 var $documentAll = documentAll_1;
 
 var documentAll = $documentAll.all;
 
 var isObject$5 = $documentAll.IS_HTMLDDA ? function (it) {
-  return typeof it == 'object' ? it !== null : isCallable$a(it) || it === documentAll;
+  return typeof it == 'object' ? it !== null : isCallable$b(it) || it === documentAll;
 } : function (it) {
-  return typeof it == 'object' ? it !== null : isCallable$a(it);
+  return typeof it == 'object' ? it !== null : isCallable$b(it);
 };
 
-var global$9 = global$a;
-var isCallable$9 = isCallable$b;
+var global$a = global$b;
+var isCallable$a = isCallable$c;
 
 var aFunction = function (argument) {
-  return isCallable$9(argument) ? argument : undefined;
+  return isCallable$a(argument) ? argument : undefined;
 };
 
 var getBuiltIn$3 = function (namespace, method) {
-  return arguments.length < 2 ? aFunction(global$9[namespace]) : global$9[namespace] && global$9[namespace][method];
+  return arguments.length < 2 ? aFunction(global$a[namespace]) : global$a[namespace] && global$a[namespace][method];
 };
 
-var uncurryThis$6 = functionUncurryThis;
+var uncurryThis$7 = functionUncurryThis;
 
-var objectIsPrototypeOf = uncurryThis$6({}.isPrototypeOf);
+var objectIsPrototypeOf = uncurryThis$7({}.isPrototypeOf);
 
 var getBuiltIn$2 = getBuiltIn$3;
 
 var engineUserAgent = getBuiltIn$2('navigator', 'userAgent') || '';
 
-var global$8 = global$a;
+var global$9 = global$b;
 var userAgent$3 = engineUserAgent;
 
-var process = global$8.process;
-var Deno = global$8.Deno;
+var process = global$9.process;
+var Deno = global$9.Deno;
 var versions = process && process.versions || Deno && Deno.version;
 var v8 = versions && versions.v8;
 var match, version;
@@ -254,15 +254,15 @@ var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$6(func
 
 /* eslint-disable es/no-symbol -- required for testing */
 
-var NATIVE_SYMBOL$1 = symbolConstructorDetection;
+var NATIVE_SYMBOL$2 = symbolConstructorDetection;
 
-var useSymbolAsUid = NATIVE_SYMBOL$1
+var useSymbolAsUid = NATIVE_SYMBOL$2
   && !Symbol.sham
   && typeof Symbol.iterator == 'symbol';
 
 var getBuiltIn$1 = getBuiltIn$3;
-var isCallable$8 = isCallable$b;
-var isPrototypeOf = objectIsPrototypeOf;
+var isCallable$9 = isCallable$c;
+var isPrototypeOf$1 = objectIsPrototypeOf;
 var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
 
 var $Object$2 = Object;
@@ -271,7 +271,7 @@ var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
   return typeof it == 'symbol';
 } : function (it) {
   var $Symbol = getBuiltIn$1('Symbol');
-  return isCallable$8($Symbol) && isPrototypeOf($Symbol.prototype, $Object$2(it));
+  return isCallable$9($Symbol) && isPrototypeOf$1($Symbol.prototype, $Object$2(it));
 };
 
 var $String$2 = String;
@@ -284,14 +284,14 @@ var tryToString$2 = function (argument) {
   }
 };
 
-var isCallable$7 = isCallable$b;
+var isCallable$8 = isCallable$c;
 var tryToString$1 = tryToString$2;
 
 var $TypeError$5 = TypeError;
 
 // `Assert: IsCallable(argument) is true`
 var aCallable$2 = function (argument) {
-  if (isCallable$7(argument)) return argument;
+  if (isCallable$8(argument)) return argument;
   throw $TypeError$5(tryToString$1(argument) + ' is not a function');
 };
 
@@ -306,7 +306,7 @@ var getMethod$1 = function (V, P) {
 };
 
 var call$2 = functionCall;
-var isCallable$6 = isCallable$b;
+var isCallable$7 = isCallable$c;
 var isObject$4 = isObject$5;
 
 var $TypeError$4 = TypeError;
@@ -315,32 +315,32 @@ var $TypeError$4 = TypeError;
 // https://tc39.es/ecma262/#sec-ordinarytoprimitive
 var ordinaryToPrimitive$1 = function (input, pref) {
   var fn, val;
-  if (pref === 'string' && isCallable$6(fn = input.toString) && !isObject$4(val = call$2(fn, input))) return val;
-  if (isCallable$6(fn = input.valueOf) && !isObject$4(val = call$2(fn, input))) return val;
-  if (pref !== 'string' && isCallable$6(fn = input.toString) && !isObject$4(val = call$2(fn, input))) return val;
+  if (pref === 'string' && isCallable$7(fn = input.toString) && !isObject$4(val = call$2(fn, input))) return val;
+  if (isCallable$7(fn = input.valueOf) && !isObject$4(val = call$2(fn, input))) return val;
+  if (pref !== 'string' && isCallable$7(fn = input.toString) && !isObject$4(val = call$2(fn, input))) return val;
   throw $TypeError$4("Can't convert object to primitive value");
 };
 
 var shared$3 = {exports: {}};
 
-var global$7 = global$a;
+var global$8 = global$b;
 
 // eslint-disable-next-line es/no-object-defineproperty -- safe
-var defineProperty$1 = Object.defineProperty;
+var defineProperty$2 = Object.defineProperty;
 
 var defineGlobalProperty$3 = function (key, value) {
   try {
-    defineProperty$1(global$7, key, { value: value, configurable: true, writable: true });
+    defineProperty$2(global$8, key, { value: value, configurable: true, writable: true });
   } catch (error) {
-    global$7[key] = value;
+    global$8[key] = value;
   } return value;
 };
 
-var global$6 = global$a;
+var global$7 = global$b;
 var defineGlobalProperty$2 = defineGlobalProperty$3;
 
 var SHARED = '__core-js_shared__';
-var store$3 = global$6[SHARED] || defineGlobalProperty$2(SHARED, {});
+var store$3 = global$7[SHARED] || defineGlobalProperty$2(SHARED, {});
 
 var sharedStore = store$3;
 
@@ -349,10 +349,10 @@ var store$2 = sharedStore;
 (shared$3.exports = function (key, value) {
   return store$2[key] || (store$2[key] = value !== undefined ? value : {});
 })('versions', []).push({
-  version: '3.25.5',
+  version: '3.26.0',
   mode: 'global',
   copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
-  license: 'https://github.com/zloirock/core-js/blob/v3.25.5/LICENSE',
+  license: 'https://github.com/zloirock/core-js/blob/v3.26.0/LICENSE',
   source: 'https://github.com/zloirock/core-js'
 });
 
@@ -366,44 +366,44 @@ var toObject$2 = function (argument) {
   return $Object$1(requireObjectCoercible(argument));
 };
 
-var uncurryThis$5 = functionUncurryThis;
+var uncurryThis$6 = functionUncurryThis;
 var toObject$1 = toObject$2;
 
-var hasOwnProperty$1 = uncurryThis$5({}.hasOwnProperty);
+var hasOwnProperty$2 = uncurryThis$6({}.hasOwnProperty);
 
 // `HasOwnProperty` abstract operation
 // https://tc39.es/ecma262/#sec-hasownproperty
 // eslint-disable-next-line es/no-object-hasown -- safe
 var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
-  return hasOwnProperty$1(toObject$1(it), key);
+  return hasOwnProperty$2(toObject$1(it), key);
 };
 
-var uncurryThis$4 = functionUncurryThis;
+var uncurryThis$5 = functionUncurryThis;
 
 var id = 0;
 var postfix = Math.random();
-var toString$2 = uncurryThis$4(1.0.toString);
+var toString$3 = uncurryThis$5(1.0.toString);
 
 var uid$2 = function (key) {
-  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$2(++id + postfix, 36);
+  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$3(++id + postfix, 36);
 };
 
-var global$5 = global$a;
+var global$6 = global$b;
 var shared$2 = shared$3.exports;
-var hasOwn$6 = hasOwnProperty_1;
+var hasOwn$7 = hasOwnProperty_1;
 var uid$1 = uid$2;
-var NATIVE_SYMBOL = symbolConstructorDetection;
+var NATIVE_SYMBOL$1 = symbolConstructorDetection;
 var USE_SYMBOL_AS_UID = useSymbolAsUid;
 
 var WellKnownSymbolsStore = shared$2('wks');
-var Symbol$1 = global$5.Symbol;
+var Symbol$1 = global$6.Symbol;
 var symbolFor = Symbol$1 && Symbol$1['for'];
 var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
 
 var wellKnownSymbol$3 = function (name) {
-  if (!hasOwn$6(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
+  if (!hasOwn$7(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL$1 || typeof WellKnownSymbolsStore[name] == 'string')) {
     var description = 'Symbol.' + name;
-    if (NATIVE_SYMBOL && hasOwn$6(Symbol$1, name)) {
+    if (NATIVE_SYMBOL$1 && hasOwn$7(Symbol$1, name)) {
       WellKnownSymbolsStore[name] = Symbol$1[name];
     } else if (USE_SYMBOL_AS_UID && symbolFor) {
       WellKnownSymbolsStore[name] = symbolFor(description);
@@ -449,10 +449,10 @@ var toPropertyKey$3 = function (argument) {
   return isSymbol(key) ? key : key + '';
 };
 
-var global$4 = global$a;
+var global$5 = global$b;
 var isObject$2 = isObject$5;
 
-var document$1 = global$4.document;
+var document$1 = global$5.document;
 // typeof document.createElement is 'object' in old IE
 var EXISTS$1 = isObject$2(document$1) && isObject$2(document$1.createElement);
 
@@ -460,25 +460,25 @@ var documentCreateElement = function (it) {
   return EXISTS$1 ? document$1.createElement(it) : {};
 };
 
-var DESCRIPTORS$6 = descriptors;
+var DESCRIPTORS$7 = descriptors;
 var fails$5 = fails$a;
 var createElement$1 = documentCreateElement;
 
 // Thanks to IE8 for its funny defineProperty
-var ie8DomDefine = !DESCRIPTORS$6 && !fails$5(function () {
+var ie8DomDefine = !DESCRIPTORS$7 && !fails$5(function () {
   // eslint-disable-next-line es/no-object-defineproperty -- required for testing
   return Object.defineProperty(createElement$1('div'), 'a', {
     get: function () { return 7; }
   }).a != 7;
 });
 
-var DESCRIPTORS$5 = descriptors;
+var DESCRIPTORS$6 = descriptors;
 var call = functionCall;
 var propertyIsEnumerableModule = objectPropertyIsEnumerable;
 var createPropertyDescriptor$2 = createPropertyDescriptor$3;
 var toIndexedObject$2 = toIndexedObject$3;
 var toPropertyKey$2 = toPropertyKey$3;
-var hasOwn$5 = hasOwnProperty_1;
+var hasOwn$6 = hasOwnProperty_1;
 var IE8_DOM_DEFINE$1 = ie8DomDefine;
 
 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -486,23 +486,23 @@ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
 
 // `Object.getOwnPropertyDescriptor` method
 // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
-objectGetOwnPropertyDescriptor.f = DESCRIPTORS$5 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
+objectGetOwnPropertyDescriptor.f = DESCRIPTORS$6 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
   O = toIndexedObject$2(O);
   P = toPropertyKey$2(P);
   if (IE8_DOM_DEFINE$1) try {
     return $getOwnPropertyDescriptor$1(O, P);
   } catch (error) { /* empty */ }
-  if (hasOwn$5(O, P)) return createPropertyDescriptor$2(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+  if (hasOwn$6(O, P)) return createPropertyDescriptor$2(!call(propertyIsEnumerableModule.f, O, P), O[P]);
 };
 
 var objectDefineProperty = {};
 
-var DESCRIPTORS$4 = descriptors;
+var DESCRIPTORS$5 = descriptors;
 var fails$4 = fails$a;
 
 // V8 ~ Chrome 36-
 // https://bugs.chromium.org/p/v8/issues/detail?id=3334
-var v8PrototypeDefineBug = DESCRIPTORS$4 && fails$4(function () {
+var v8PrototypeDefineBug = DESCRIPTORS$5 && fails$4(function () {
   // eslint-disable-next-line es/no-object-defineproperty -- required for testing
   return Object.defineProperty(function () { /* empty */ }, 'prototype', {
     value: 42,
@@ -521,7 +521,7 @@ var anObject$2 = function (argument) {
   throw $TypeError$2($String$1(argument) + ' is not an object');
 };
 
-var DESCRIPTORS$3 = descriptors;
+var DESCRIPTORS$4 = descriptors;
 var IE8_DOM_DEFINE = ie8DomDefine;
 var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
 var anObject$1 = anObject$2;
@@ -538,7 +538,7 @@ var WRITABLE = 'writable';
 
 // `Object.defineProperty` method
 // https://tc39.es/ecma262/#sec-object.defineproperty
-objectDefineProperty.f = DESCRIPTORS$3 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+objectDefineProperty.f = DESCRIPTORS$4 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
   anObject$1(O);
   P = toPropertyKey$1(P);
   anObject$1(Attributes);
@@ -565,11 +565,11 @@ objectDefineProperty.f = DESCRIPTORS$3 ? V8_PROTOTYPE_DEFINE_BUG ? function defi
   return O;
 };
 
-var DESCRIPTORS$2 = descriptors;
+var DESCRIPTORS$3 = descriptors;
 var definePropertyModule$3 = objectDefineProperty;
 var createPropertyDescriptor$1 = createPropertyDescriptor$3;
 
-var createNonEnumerableProperty$2 = DESCRIPTORS$2 ? function (object, key, value) {
+var createNonEnumerableProperty$2 = DESCRIPTORS$3 ? function (object, key, value) {
   return definePropertyModule$3.f(object, key, createPropertyDescriptor$1(1, value));
 } : function (object, key, value) {
   object[key] = value;
@@ -578,17 +578,17 @@ var createNonEnumerableProperty$2 = DESCRIPTORS$2 ? function (object, key, value
 
 var makeBuiltIn$2 = {exports: {}};
 
-var DESCRIPTORS$1 = descriptors;
-var hasOwn$4 = hasOwnProperty_1;
+var DESCRIPTORS$2 = descriptors;
+var hasOwn$5 = hasOwnProperty_1;
 
 var FunctionPrototype = Function.prototype;
 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
-var getDescriptor = DESCRIPTORS$1 && Object.getOwnPropertyDescriptor;
+var getDescriptor = DESCRIPTORS$2 && Object.getOwnPropertyDescriptor;
 
-var EXISTS = hasOwn$4(FunctionPrototype, 'name');
+var EXISTS = hasOwn$5(FunctionPrototype, 'name');
 // additional protection from minified / mangled / dropped function names
 var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
-var CONFIGURABLE = EXISTS && (!DESCRIPTORS$1 || (DESCRIPTORS$1 && getDescriptor(FunctionPrototype, 'name').configurable));
+var CONFIGURABLE = EXISTS && (!DESCRIPTORS$2 || (DESCRIPTORS$2 && getDescriptor(FunctionPrototype, 'name').configurable));
 
 var functionName = {
   EXISTS: EXISTS,
@@ -596,14 +596,14 @@ var functionName = {
   CONFIGURABLE: CONFIGURABLE
 };
 
-var uncurryThis$3 = functionUncurryThis;
-var isCallable$5 = isCallable$b;
+var uncurryThis$4 = functionUncurryThis;
+var isCallable$6 = isCallable$c;
 var store$1 = sharedStore;
 
-var functionToString = uncurryThis$3(Function.toString);
+var functionToString = uncurryThis$4(Function.toString);
 
 // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
-if (!isCallable$5(store$1.inspectSource)) {
+if (!isCallable$6(store$1.inspectSource)) {
   store$1.inspectSource = function (it) {
     return functionToString(it);
   };
@@ -611,12 +611,12 @@ if (!isCallable$5(store$1.inspectSource)) {
 
 var inspectSource$1 = store$1.inspectSource;
 
-var global$3 = global$a;
-var isCallable$4 = isCallable$b;
+var global$4 = global$b;
+var isCallable$5 = isCallable$c;
 
-var WeakMap$1 = global$3.WeakMap;
+var WeakMap$1 = global$4.WeakMap;
 
-var weakMapBasicDetection = isCallable$4(WeakMap$1) && /native code/.test(String(WeakMap$1));
+var weakMapBasicDetection = isCallable$5(WeakMap$1) && /native code/.test(String(WeakMap$1));
 
 var shared$1 = shared$3.exports;
 var uid = uid$2;
@@ -630,17 +630,17 @@ var sharedKey$1 = function (key) {
 var hiddenKeys$3 = {};
 
 var NATIVE_WEAK_MAP = weakMapBasicDetection;
-var global$2 = global$a;
+var global$3 = global$b;
 var isObject = isObject$5;
 var createNonEnumerableProperty$1 = createNonEnumerableProperty$2;
-var hasOwn$3 = hasOwnProperty_1;
+var hasOwn$4 = hasOwnProperty_1;
 var shared = sharedStore;
 var sharedKey = sharedKey$1;
 var hiddenKeys$2 = hiddenKeys$3;
 
 var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
-var TypeError$1 = global$2.TypeError;
-var WeakMap = global$2.WeakMap;
+var TypeError$1 = global$3.TypeError;
+var WeakMap = global$3.WeakMap;
 var set, get, has;
 
 var enforce = function (it) {
@@ -679,16 +679,16 @@ if (NATIVE_WEAK_MAP || shared.state) {
   var STATE = sharedKey('state');
   hiddenKeys$2[STATE] = true;
   set = function (it, metadata) {
-    if (hasOwn$3(it, STATE)) throw TypeError$1(OBJECT_ALREADY_INITIALIZED);
+    if (hasOwn$4(it, STATE)) throw TypeError$1(OBJECT_ALREADY_INITIALIZED);
     metadata.facade = it;
     createNonEnumerableProperty$1(it, STATE, metadata);
     return metadata;
   };
   get = function (it) {
-    return hasOwn$3(it, STATE) ? it[STATE] : {};
+    return hasOwn$4(it, STATE) ? it[STATE] : {};
   };
   has = function (it) {
-    return hasOwn$3(it, STATE);
+    return hasOwn$4(it, STATE);
   };
 }
 
@@ -701,9 +701,9 @@ var internalState = {
 };
 
 var fails$3 = fails$a;
-var isCallable$3 = isCallable$b;
-var hasOwn$2 = hasOwnProperty_1;
-var DESCRIPTORS = descriptors;
+var isCallable$4 = isCallable$c;
+var hasOwn$3 = hasOwnProperty_1;
+var DESCRIPTORS$1 = descriptors;
 var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
 var inspectSource = inspectSource$1;
 var InternalStateModule = internalState;
@@ -711,10 +711,10 @@ var InternalStateModule = internalState;
 var enforceInternalState = InternalStateModule.enforce;
 var getInternalState = InternalStateModule.get;
 // eslint-disable-next-line es/no-object-defineproperty -- safe
-var defineProperty = Object.defineProperty;
+var defineProperty$1 = Object.defineProperty;
 
-var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails$3(function () {
-  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
+var CONFIGURABLE_LENGTH = DESCRIPTORS$1 && !fails$3(function () {
+  return defineProperty$1(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
 });
 
 var TEMPLATE = String(String).split('String');
@@ -725,21 +725,21 @@ var makeBuiltIn$1 = makeBuiltIn$2.exports = function (value, name, options) {
   }
   if (options && options.getter) name = 'get ' + name;
   if (options && options.setter) name = 'set ' + name;
-  if (!hasOwn$2(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
-    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
+  if (!hasOwn$3(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+    if (DESCRIPTORS$1) defineProperty$1(value, 'name', { value: name, configurable: true });
     else value.name = name;
   }
-  if (CONFIGURABLE_LENGTH && options && hasOwn$2(options, 'arity') && value.length !== options.arity) {
-    defineProperty(value, 'length', { value: options.arity });
+  if (CONFIGURABLE_LENGTH && options && hasOwn$3(options, 'arity') && value.length !== options.arity) {
+    defineProperty$1(value, 'length', { value: options.arity });
   }
   try {
-    if (options && hasOwn$2(options, 'constructor') && options.constructor) {
-      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
+    if (options && hasOwn$3(options, 'constructor') && options.constructor) {
+      if (DESCRIPTORS$1) defineProperty$1(value, 'prototype', { writable: false });
     // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
     } else if (value.prototype) value.prototype = undefined;
   } catch (error) { /* empty */ }
   var state = enforceInternalState(value);
-  if (!hasOwn$2(state, 'source')) {
+  if (!hasOwn$3(state, 'source')) {
     state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
   } return value;
 };
@@ -747,10 +747,10 @@ var makeBuiltIn$1 = makeBuiltIn$2.exports = function (value, name, options) {
 // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
 // eslint-disable-next-line no-extend-native -- required
 Function.prototype.toString = makeBuiltIn$1(function toString() {
-  return isCallable$3(this) && getInternalState(this).source || inspectSource(this);
+  return isCallable$4(this) && getInternalState(this).source || inspectSource(this);
 }, 'toString');
 
-var isCallable$2 = isCallable$b;
+var isCallable$3 = isCallable$c;
 var definePropertyModule$2 = objectDefineProperty;
 var makeBuiltIn = makeBuiltIn$2.exports;
 var defineGlobalProperty$1 = defineGlobalProperty$3;
@@ -759,7 +759,7 @@ var defineBuiltIn$1 = function (O, key, value, options) {
   if (!options) options = {};
   var simple = options.enumerable;
   var name = options.name !== undefined ? options.name : key;
-  if (isCallable$2(value)) makeBuiltIn(value, name, options);
+  if (isCallable$3(value)) makeBuiltIn(value, name, options);
   if (options.global) {
     if (simple) O[key] = value;
     else defineGlobalProperty$1(key, value);
@@ -865,22 +865,22 @@ var arrayIncludes = {
   indexOf: createMethod(false)
 };
 
-var uncurryThis$2 = functionUncurryThis;
-var hasOwn$1 = hasOwnProperty_1;
+var uncurryThis$3 = functionUncurryThis;
+var hasOwn$2 = hasOwnProperty_1;
 var toIndexedObject = toIndexedObject$3;
 var indexOf$1 = arrayIncludes.indexOf;
 var hiddenKeys$1 = hiddenKeys$3;
 
-var push$1 = uncurryThis$2([].push);
+var push$1 = uncurryThis$3([].push);
 
 var objectKeysInternal = function (object, names) {
   var O = toIndexedObject(object);
   var i = 0;
   var result = [];
   var key;
-  for (key in O) !hasOwn$1(hiddenKeys$1, key) && hasOwn$1(O, key) && push$1(result, key);
+  for (key in O) !hasOwn$2(hiddenKeys$1, key) && hasOwn$2(O, key) && push$1(result, key);
   // Don't enum bug & hidden keys
-  while (names.length > i) if (hasOwn$1(O, key = names[i++])) {
+  while (names.length > i) if (hasOwn$2(O, key = names[i++])) {
     ~indexOf$1(result, key) || push$1(result, key);
   }
   return result;
@@ -915,12 +915,12 @@ var objectGetOwnPropertySymbols = {};
 objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
 
 var getBuiltIn = getBuiltIn$3;
-var uncurryThis$1 = functionUncurryThis;
+var uncurryThis$2 = functionUncurryThis;
 var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
 var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
 var anObject = anObject$2;
 
-var concat = uncurryThis$1([].concat);
+var concat = uncurryThis$2([].concat);
 
 // all object keys, includes non-enumerable and symbols
 var ownKeys$1 = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
@@ -929,25 +929,25 @@ var ownKeys$1 = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
   return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
 };
 
-var hasOwn = hasOwnProperty_1;
+var hasOwn$1 = hasOwnProperty_1;
 var ownKeys = ownKeys$1;
 var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
 var definePropertyModule$1 = objectDefineProperty;
 
-var copyConstructorProperties$1 = function (target, source, exceptions) {
+var copyConstructorProperties$2 = function (target, source, exceptions) {
   var keys = ownKeys(source);
   var defineProperty = definePropertyModule$1.f;
   var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
   for (var i = 0; i < keys.length; i++) {
     var key = keys[i];
-    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+    if (!hasOwn$1(target, key) && !(exceptions && hasOwn$1(exceptions, key))) {
       defineProperty(target, key, getOwnPropertyDescriptor(source, key));
     }
   }
 };
 
 var fails$2 = fails$a;
-var isCallable$1 = isCallable$b;
+var isCallable$2 = isCallable$c;
 
 var replacement = /#|\.prototype\./;
 
@@ -955,7 +955,7 @@ var isForced$1 = function (feature, detection) {
   var value = data[normalize(feature)];
   return value == POLYFILL ? true
     : value == NATIVE ? false
-    : isCallable$1(detection) ? fails$2(detection)
+    : isCallable$2(detection) ? fails$2(detection)
     : !!detection;
 };
 
@@ -969,12 +969,12 @@ var POLYFILL = isForced$1.POLYFILL = 'P';
 
 var isForced_1 = isForced$1;
 
-var global$1 = global$a;
+var global$2 = global$b;
 var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
 var createNonEnumerableProperty = createNonEnumerableProperty$2;
 var defineBuiltIn = defineBuiltIn$1;
 var defineGlobalProperty = defineGlobalProperty$3;
-var copyConstructorProperties = copyConstructorProperties$1;
+var copyConstructorProperties$1 = copyConstructorProperties$2;
 var isForced = isForced_1;
 
 /*
@@ -998,11 +998,11 @@ var _export = function (options, source) {
   var STATIC = options.stat;
   var FORCED, target, key, targetProperty, sourceProperty, descriptor;
   if (GLOBAL) {
-    target = global$1;
+    target = global$2;
   } else if (STATIC) {
-    target = global$1[TARGET] || defineGlobalProperty(TARGET, {});
+    target = global$2[TARGET] || defineGlobalProperty(TARGET, {});
   } else {
-    target = (global$1[TARGET] || {}).prototype;
+    target = (global$2[TARGET] || {}).prototype;
   }
   if (target) for (key in source) {
     sourceProperty = source[key];
@@ -1014,7 +1014,7 @@ var _export = function (options, source) {
     // contained in target
     if (!FORCED && targetProperty !== undefined) {
       if (typeof sourceProperty == typeof targetProperty) continue;
-      copyConstructorProperties(sourceProperty, targetProperty);
+      copyConstructorProperties$1(sourceProperty, targetProperty);
     }
     // add a flag to not completely full polyfills
     if (options.sham || (targetProperty && targetProperty.sham)) {
@@ -1024,14 +1024,6 @@ var _export = function (options, source) {
   }
 };
 
-var tryToString = tryToString$2;
-
-var $TypeError = TypeError;
-
-var deletePropertyOrThrow$1 = function (O, P) {
-  if (!delete O[P]) throw $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
-};
-
 var wellKnownSymbol$1 = wellKnownSymbol$3;
 
 var TO_STRING_TAG$1 = wellKnownSymbol$1('toStringTag');
@@ -1042,7 +1034,7 @@ test$1[TO_STRING_TAG$1] = 'z';
 var toStringTagSupport = String(test$1) === '[object z]';
 
 var TO_STRING_TAG_SUPPORT = toStringTagSupport;
-var isCallable = isCallable$b;
+var isCallable$1 = isCallable$c;
 var classofRaw = classofRaw$2;
 var wellKnownSymbol = wellKnownSymbol$3;
 
@@ -1068,18 +1060,83 @@ var classof$1 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
     // builtinTag case
     : CORRECT_ARGUMENTS ? classofRaw(O)
     // ES3 arguments fallback
-    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
+    : (result = classofRaw(O)) == 'Object' && isCallable$1(O.callee) ? 'Arguments' : result;
 };
 
 var classof = classof$1;
 
 var $String = String;
 
-var toString$1 = function (argument) {
+var toString$2 = function (argument) {
   if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
   return $String(argument);
 };
 
+var $$2 = _export;
+var DESCRIPTORS = descriptors;
+var global$1 = global$b;
+var uncurryThis$1 = functionUncurryThis;
+var hasOwn = hasOwnProperty_1;
+var isCallable = isCallable$c;
+var isPrototypeOf = objectIsPrototypeOf;
+var toString$1 = toString$2;
+var defineProperty = objectDefineProperty.f;
+var copyConstructorProperties = copyConstructorProperties$2;
+
+var NativeSymbol = global$1.Symbol;
+var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
+
+if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) ||
+  // Safari 12 bug
+  NativeSymbol().description !== undefined
+)) {
+  var EmptyStringDescriptionStore = {};
+  // wrap Symbol constructor for correct work with undefined description
+  var SymbolWrapper = function Symbol() {
+    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString$1(arguments[0]);
+    var result = isPrototypeOf(SymbolPrototype, this)
+      ? new NativeSymbol(description)
+      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
+      : description === undefined ? NativeSymbol() : NativeSymbol(description);
+    if (description === '') EmptyStringDescriptionStore[result] = true;
+    return result;
+  };
+
+  copyConstructorProperties(SymbolWrapper, NativeSymbol);
+  SymbolWrapper.prototype = SymbolPrototype;
+  SymbolPrototype.constructor = SymbolWrapper;
+
+  var NATIVE_SYMBOL = String(NativeSymbol('test')) == 'Symbol(test)';
+  var thisSymbolValue = uncurryThis$1(SymbolPrototype.valueOf);
+  var symbolDescriptiveString = uncurryThis$1(SymbolPrototype.toString);
+  var regexp = /^Symbol\((.*)\)[^)]+$/;
+  var replace = uncurryThis$1(''.replace);
+  var stringSlice = uncurryThis$1(''.slice);
+
+  defineProperty(SymbolPrototype, 'description', {
+    configurable: true,
+    get: function description() {
+      var symbol = thisSymbolValue(this);
+      if (hasOwn(EmptyStringDescriptionStore, symbol)) return '';
+      var string = symbolDescriptiveString(symbol);
+      var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1');
+      return desc === '' ? undefined : desc;
+    }
+  });
+
+  $$2({ global: true, constructor: true, forced: true }, {
+    Symbol: SymbolWrapper
+  });
+}
+
+var tryToString = tryToString$2;
+
+var $TypeError = TypeError;
+
+var deletePropertyOrThrow$1 = function (O, P) {
+  if (!delete O[P]) throw $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
+};
+
 var toPropertyKey = toPropertyKey$3;
 var definePropertyModule = objectDefineProperty;
 var createPropertyDescriptor = createPropertyDescriptor$3;
@@ -1184,7 +1241,7 @@ var aCallable = aCallable$2;
 var toObject = toObject$2;
 var lengthOfArrayLike = lengthOfArrayLike$3;
 var deletePropertyOrThrow = deletePropertyOrThrow$1;
-var toString = toString$1;
+var toString = toString$2;
 var fails = fails$a;
 var internalSort = arraySort;
 var arrayMethodIsStrict = arrayMethodIsStrict$1;
@@ -1505,12 +1562,12 @@ ColumnCollection.prototype.initialize = function () {
 
 /**
  * Get the column by this name
- * @param {String} column column name
+ * @param {string} column column name
  * @returns {Object} the column object
  */
 ColumnCollection.prototype.get = function (column) {
   for (let i = 0, len = this.length; i < len; i++) {
-    if (this[i].name == column) {
+    if (this[i].name === column) {
       return this[i];
     }
   }
@@ -1519,12 +1576,12 @@ ColumnCollection.prototype.get = function (column) {
 
 /**
  * Get the index of the column by this name
- * @param {String} column column name
+ * @param {string} column column name
  * @returns {int} the index of this column
  */
 ColumnCollection.prototype.indexOf = function (column) {
   for (let i = 0, len = this.length; i < len; i++) {
-    if (this[i].name == column) {
+    if (this[i].name === column) {
       return i;
     }
   }
@@ -1533,12 +1590,12 @@ ColumnCollection.prototype.indexOf = function (column) {
 
 /**
  * Get the column by the specified order
- * @param {Number} order the column's order
+ * @param {number} order the column's order
  * @returns {Object} the column object
  */
 ColumnCollection.prototype.getByOrder = function (order) {
   for (let i = 0, len = this.length; i < len; i++) {
-    if (this[i].order == order) {
+    if (this[i].order === order) {
       return this[i];
     }
   }
@@ -1632,27 +1689,6 @@ ColumnCollection.prototype.moveColumn = function (src, dest) {
 
 /* eslint-env browser */
 
-const CssUtil = {};
-
-let _isTransformSupported = null;
-
-CssUtil.getSupportedTransform = () => {
-  if (_isTransformSupported === null) {
-    let prefixes = ['transform', 'WebkitTransform', 'MozTransform', 'OTransform', 'msTransform'];
-    let div = document.createElement('div');
-    _isTransformSupported = false;
-    for (let item of prefixes) {
-      if (div && div.style[item] !== undefined) {
-        _isTransformSupported = item;
-        break;
-      }
-    }
-  }
-  return _isTransformSupported;
-};
-
-/* eslint-env browser */
-
 // saveSelection/restoreSelection courtesy of Tim Down, with my improvements
 // https://stackoverflow.com/questions/13949059/persisting-the-changes-of-range-objects-after-selection-in-html/13950376#13950376
 
@@ -1706,12 +1742,1332 @@ class SelectionHelper {
         }
       }
     }
-
-    let sel = window.getSelection();
-    sel.removeAllRanges();
-    sel.addRange(range);
+
+    let sel = window.getSelection();
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+}
+
+/**
+ * @typedef {function(index: number):(number|undefined)} VirtualListHelper~ItemHeightEstimatorFunction
+ */
+
+/**
+ * @typedef {function():Element} VirtualListHelper~ItemElementCreatorFunction
+ */
+
+/**
+ * @typedef {function(itemEl: Element, index: number)} VirtualListHelper~ItemRenderFunction
+ */
+
+/**
+ * @typedef {function(itemEl: Element)} VirtualListHelper~ItemUnrenderFunction
+ */
+
+/**
+ * @typedef {Object} VirtualListHelper~Options
+ * @property {Element} list - the main element to operate inside of
+ * @property {Element?} [itemsParent] - the element to use as parent for the items (automatically created in virtual mode, uses parent by default in non-virtual mode)
+ * @property {boolean} [autoVirtualWrapperWidth=true] automatically set the width of the virtual wrapper
+ * @property {boolean} [hookScrollEvent=true] automatically hook scroll event as needed
+ * @property {number} [count=0] the item count
+ * @property {boolean} [virtual=true] is virtual mode on?
+ * @property {number} [estimatedItemHeight=20] estimated item height
+ * @property {number} [buffer=5] the amount of buffer items to keep on each end of the list
+ * @property {VirtualListHelper~ItemHeightEstimatorFunction} [itemHeightEstimatorFn] an optional function for providing item height estimations
+ * @property {VirtualListHelper~ItemElementCreatorFunction} [itemElementCreatorFn] an optional function for providing fresh item elements (default creates `<li />`s)
+ * @property {VirtualListHelper~ItemRenderFunction} [onItemRender] a function for rendering element content based on item index
+ * @property {VirtualListHelper~ItemUnrenderFunction} [onItemUnrender] a function for freeing resources in an item element
+ *
+ */
+
+/** */
+
+const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+
+class VirtualListHelper {
+  /**
+   * @param {VirtualListHelper~Options} opts
+   */
+  constructor(opts) {var _opts$autoVirtualWrap;
+    /** @private */
+    const p = this._p = {
+      // these come from options:
+
+      list: opts.list || null,
+      hookScrollEvent: opts.hookScrollEvent === undefined ? true : !!opts.hookScrollEvent,
+      count: opts.count || 0,
+      virtual: opts.virtual === undefined ? true : !!opts.virtual,
+      userItemsParent: opts.itemsParent || null,
+      setVirtualWrapperWidth: (_opts$autoVirtualWrap = opts.autoVirtualWrapperWidth) !== null && _opts$autoVirtualWrap !== void 0 ? _opts$autoVirtualWrap : true,
+      estimatedItemHeight: 20,
+      buffer: 5,
+
+      /** @type VirtualListHelper~ItemHeightEstimatorFunction|null */
+      itemHeightEstimatorFn: null,
+
+      /** @type VirtualListHelper~ItemElementCreatorFunction|null */
+      itemElementCreatorFn: defaultElementCreator,
+
+      /** @type VirtualListHelper~ItemRenderFunction|null */
+      onItemRender: null,
+
+      /** @type VirtualListHelper~ItemUnrenderFunction|null */
+      onItemUnrender: null,
+
+      // internal:
+
+      /** @type Element|null */
+      virtualWrapper: null,
+
+      /** @type Element|null */
+      currentItemsParent: null,
+
+      /** @type (number|undefined)[] */
+      cachedItemHeights: [],
+
+      /** @type (number|undefined)[] */
+      cachedItemEstimatedHeights: [],
+
+      /** @type (number|undefined)[] */
+      cachedItemPositions: [],
+
+      /** @type number */
+      itemPositionsNeedsUpdate: 0,
+
+      /** @type function */
+      boundRender: this.render.bind(this),
+
+      /** @type Element[] */
+      existingEls: []
+    };
+
+    p.currentItemsParent = p.userItemsParent || p.list;
+
+    if (typeof opts.hookScrollEvent === 'boolean')
+    this.setHookScrollEvent(opts.hookScrollEvent);else
+    this._hookEvents();
+
+    if (typeof opts.count === 'number')
+    this.setCount(opts.count);
+
+    if (typeof opts.virtual === 'boolean')
+    this.setVirtual(opts.virtual);
+
+    if (typeof opts.estimatedItemHeight === 'number')
+    this.setEstimatedItemHeight(opts.estimatedItemHeight);
+
+    if (typeof opts.buffer === 'number')
+    this.setBuffer(opts.buffer);
+
+    if (typeof opts.itemHeightEstimatorFn === 'function')
+    this.setItemHeightEstimatorFn(opts.itemHeightEstimatorFn);
+
+    if (typeof opts.itemElementCreatorFn === 'function')
+    this.setItemElementCreatorFn(opts.itemElementCreatorFn);
+
+    if (typeof opts.onItemRender === 'function')
+    this.setOnItemRender(opts.onItemRender);
+
+    if (typeof opts.onItemUnrender === 'function')
+    this.setOnItemUnrender(opts.onItemUnrender);
+  }
+
+  /**
+   * Clean up and free up all resources.
+   */
+  destroy() {
+    this._unhookEvents().invalidate()._destroyElements();
+  }
+
+  /**
+   * Sets whether 'scroll' event on the list should be hooked automatically.
+   * @param {boolean} enabled
+   * @returns {VirtualListHelper}
+   */
+  setHookScrollEvent(enabled) {
+    const p = this._p;
+    enabled = enabled === undefined ? true : !!enabled;
+
+    if (p.hookScrollEvent === enabled)
+    return this;
+
+    p.hookScrollEvent = enabled;
+
+    this._unhookEvents()._hookEvents();
+
+    return this;
+  }
+
+  /**
+   * @returns {boolean} whether 'scroll' event on the list should be hooked automatically
+   */
+  isHookScrollEventEnabled() {
+    const p = this._p;
+    return p.hookScrollEvent;
+  }
+
+  /**
+   * Sets the list item count. <br />
+   * You should probably call `render()` after this.
+   * @param {number} count
+   * @returns {VirtualListHelper}
+   */
+  setCount(count) {
+    const p = this._p;
+    p.count = count;
+
+    return this.invalidatePositions();
+  }
+
+  /**
+   * @returns {number} current item count
+   */
+  getCount() {
+    const p = this._p;
+    return p.count;
+  }
+
+  /**
+   * Switches between virtual and non-virtual mode. <br />
+   * The list is invalidated automatically. <br />
+   * You should call `render()` to update the view.
+   * @param {boolean} enabled
+   * @returns {VirtualListHelper}
+   */
+  setVirtual(enabled) {
+    const p = this._p;
+    enabled = enabled === undefined ? true : !!enabled;
+
+    if (p.virtual === enabled)
+    return this;
+
+    p.virtual = enabled;
+
+    this._hookEvents().invalidate()._destroyElements();
+
+    return this;
+  }
+
+  /**
+   * @returns {boolean} virtual mode
+   */
+  isVirtual() {
+    const p = this._p;
+    return p.virtual;
+  }
+
+  /**
+   * Sets estimated item height. <br />
+   * No need to be accurate. <br />
+   * The better the estimation - the better the scrollbar behavior will be. <br />
+   * Applicable for virtual-mode only. <br />
+   * You should `invalidate` if you want this to take effect on the existing rendering.
+   * @param {number} height - a positive number representing estimated item height.
+   * @returns {VirtualListHelper}
+   */
+  setEstimatedItemHeight(height) {
+    const p = this._p;
+    p.estimatedItemHeight = Math.abs((typeof height === 'number' ? height : Number(height)) || 20);
+    return this;
+  }
+
+  /**
+   * @returns {number} current item height estimation
+   */
+  getEstimatedItemHeight() {
+    const p = this._p;
+    return p.estimatedItemHeight;
+  }
+
+  /**
+   * Sets whether the virtual wrapper width should be set automatically. <br />
+   * @param {boolean} enabled
+   * @returns {VirtualListHelper}
+   */
+  setAutoVirtualWrapperWidth(enabled) {
+    const p = this._p;
+    p.autoVirtualWrapperWidth = enabled === undefined ? true : !!enabled;
+
+    if (p.virtualWrapper) {
+      if (p.autoVirtualWrapperWidth !== p.virtualWrapperWidthWasSet) {
+        p.virtualWrapper.style.width = p.autoVirtualWrapperWidth ? '100%' : '';
+        p.virtualWrapperWidthWasSet = p.autoVirtualWrapperWidth;
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * @returns {boolean} whether the virtual wrapper width should be set automatically
+   */
+  isAutoVirtualWrapperWidth() {
+    const p = this._p;
+    return p.autoVirtualWrapperWidth;
+  }
+
+  /**
+   * Sets the amount of buffer items to keep on each end of the list. <br />
+   * Applicable for virtual-mode only.
+   * @param {number} buffer - a positive value representing the count of buffer items for each end.
+   * @returns {VirtualListHelper}
+   */
+  setBuffer(buffer) {
+    const p = this._p;
+    p.buffer = Math.abs(typeof buffer === 'number' ? buffer : Number(buffer) || 5);
+    return this;
+  }
+
+  /**
+   * @returns {number} current buffer value
+   */
+  getBuffer() {
+    const p = this._p;
+    return p.buffer;
+  }
+
+  /**
+   * The `itemHeightEstimatorFn` is an alternative to `estimatedItemHeight` to give better estimations for specific item. <br/>
+   * It's optional, and if it's present - it should return either a numeric height estimation,
+   *   or `undefined` to fall back to the default estimation. <br />
+   * You should `invalidate` if you want this to take effect on the existing rendering.
+   * @param {VirtualListHelper~ItemHeightEstimatorFunction} fn
+   * @returns {VirtualListHelper}
+   */
+  setItemHeightEstimatorFn(fn) {
+    const p = this._p;
+    p.itemHeightEstimatorFn = fn;
+    return this;
+  }
+
+  /**
+   * The `itemElementCreatorFn` is a function creating a basic item element, that will be possibly reused later. <br />
+   * It has no association with a specific item index. <br />
+   * You should `invalidate` if you want this to take effect on the existing rendering.
+   * @param {VirtualListHelper~ItemElementCreatorFunction} fn
+   * @returns {VirtualListHelper}
+   */
+  setItemElementCreatorFn(fn) {
+    const p = this._p;
+    p.itemElementCreatorFn = fn || defaultElementCreator;
+    return this;
+  }
+
+  /**
+   * The `onItemRender` is a function called for rendering the contents of an item. <br />
+   * It's passed an `Element` and an item index. <br />
+   * You should `invalidate` if you want this to take effect on the existing rendering.
+   * @param {VirtualListHelper~ItemRenderFunction} fn
+   * @returns {VirtualListHelper}
+   */
+  setOnItemRender(fn) {
+    const p = this._p;
+    p.onItemRender = fn;
+    return this;
+  }
+
+  /**
+   * The `onItemUnrender` is a function called for freeing resources in an item element,
+   *   if you've attached something that needs to be explicitly freed. <br />
+   * It's passed an `Element` only, and has no association with a specific index,
+   *   as by the time it's called - the indexes are probably not valid anymore.
+   * @param {VirtualListHelper~ItemUnrenderFunction} fn
+   * @returns {VirtualListHelper}
+   */
+  setOnItemUnrender(fn) {
+    const p = this._p;
+    p.onItemUnrender = fn;
+    return this;
+  }
+
+  /**
+   * Estimates the full scroll height. This gets better as more renderings occur.
+   * @returns {number}
+   */
+  estimateFullHeight() {
+    const p = this._p;
+
+    if (p.count === 0)
+    return 0;
+
+    if (p.virtual) {
+      return this._calculateItemPosition(p.count) || 0;
+    } else {
+      const existingEls = p.existingEls;
+      if (p.count === existingEls.length) {
+        let rect1 = existingEls[0].getBoundingClientRect();
+        let rect2 = existingEls[existingEls.length - 1].getBoundingClientRect();
+        return rect2.top - rect1.top + rect2.height;
+      }
+
+      return this._calculateItemPosition(p.count) || 0;
+    }
+  }
+
+  /**
+   * States that the cached positions/heights are invalid,
+   *   and needs to be completely re-calculated.<br />
+   * You should probably call `render()` after this.
+   * @returns {VirtualListHelper}
+   */
+  invalidatePositions() {
+    const p = this._p;
+
+    p.itemPositionsNeedsUpdate = 0;
+    p.cachedItemHeights = [];
+    p.cachedItemEstimatedHeights = [];
+    p.cachedItemPositions = [];
+    p.cachedItemHeights.length = p.count;
+    p.cachedItemEstimatedHeights.length = p.count;
+    p.cachedItemPositions.length = p.count;
+
+    return this;
+  }
+
+  /**
+   * States that the indexes/item count/rendered content are invalid,
+   *   and needs to be completely re-calculated and re-rendered. <br />
+   * You should probably call `render()` after this.
+   * @returns {VirtualListHelper}
+   */
+  invalidate() {
+    const p = this._p;
+
+    this.invalidatePositions();
+
+    const onItemUnrender = p.onItemUnrender;
+    const existingEls = p.existingEls;
+
+    for (let i = 0; i < existingEls.length; i++) {
+      const el = existingEls[i];
+      const itemIndex = el[ItemIndexSymbol];
+      if (itemIndex === undefined) continue;
+
+      if (onItemUnrender)
+      onItemUnrender(el);
+
+      delete el[ItemIndexSymbol];
+    }
+
+    return this;
+  }
+
+  /**
+   * Renders the current viewport. <br />
+   * Call this after making changes to the list. <br />
+   * In virtual mode, this is called automatically for every scroll event.
+   */
+  render() {
+    const p = this._p;
+    const list = p.list;
+    const virtual = p.virtual;
+    let virtualWrapper = p.virtualWrapper;
+    let scrollTop = list.scrollTop;
+    let visibleHeight = list.clientHeight;
+    let visibleBottom = scrollTop + visibleHeight;
+    let count = p.count;
+    let buffer = p.buffer;
+    let onItemUnrender = p.onItemUnrender;
+    let existingEls = p.existingEls;
+    let existingCount = existingEls.length;
+
+    if (virtual) {
+      const originalWidth = list.clientWidth;
+
+      if (!virtualWrapper) {
+        virtualWrapper = p.virtualWrapper = p.userItemsParent;
+        if (!virtualWrapper) {
+          virtualWrapper = p.virtualWrapper = document.createElement('div');
+          list.appendChild(virtualWrapper);
+        }
+
+        this._resetCurrentItemsParent();
+
+        if (p.autoVirtualWrapperWidth) {
+          virtualWrapper.style.width = '100%';
+          p.virtualWrapperWidthWasSet = true;
+        } else {
+          p.virtualWrapperWidthWasSet = false;
+        }
+      }
+
+      // Mark all of them for potential reuse
+      for (let i = 0; i < existingCount; i++) {
+        existingEls[i][ReuseElSymbol] = true;
+      }
+
+      // Make sure we have at least estimated positions for all items so we can translate scroll position
+      this._calculateItemPosition(p.count - 1);
+
+      // Find existing elements index range
+      let existingRange = this._getExistingElsRange();
+
+      // Find first visible element
+      let firstVisibleIndex = binarySearchPosition(p.cachedItemPositions, scrollTop);
+      let firstRenderIndex = Math.max(0, firstVisibleIndex - buffer);
+
+      // Iterate over viewport
+      let index = firstRenderIndex;
+      let renderPos = this._calculateItemPosition(index);
+      let bufferEnd = buffer;
+
+      /** @type Node|undefined */
+      let lastEl = undefined;
+
+      // If rendering position has not reached the viewport bottom
+      //    AND we have not rendered all the buffer items yet
+      while ((renderPos < visibleBottom || bufferEnd-- > 0) && index < count) {
+        // Find existing element to reuse
+        /** @type Element|undefined */
+        let existingEl = undefined;
+
+        if (existingRange.firstIndex !== -1 && index >= existingRange.firstIndex && index <= existingRange.lastIndex) {
+          existingEl = existingEls.find((x) => x[ItemIndexSymbol] === index && x[ReuseElSymbol] === true);
+        }
+
+        if (existingEl === undefined) {
+          existingEl = (existingRange.firstIndex < firstRenderIndex || existingRange.firstValidArrayIndex > 0 ?
+          existingEls.find((x) =>
+          (x[ItemIndexSymbol] < firstRenderIndex || false === hasOwnProperty$1.call(x, ItemIndexSymbol)) &&
+          x[ReuseElSymbol] === true) :
+          undefined) ||
+          findLast(existingEls, (x) => x[ReuseElSymbol] === true);
+        }
+
+        if (existingEl !== undefined) {
+          delete existingEl[ReuseElSymbol];
+        }
+
+        // Find the element to insert before
+        let insertBefore = lastEl ? lastEl.nextSibling : virtualWrapper.childNodes[0];
+        if (insertBefore && insertBefore === existingEl)
+        insertBefore = insertBefore.nextSibling;
+
+        // Dequeue the element by reusing or creating a new one
+        lastEl = this._dequeueElementForIndex(existingEl, index, insertBefore);
+
+        // Increment pointers
+        renderPos = p.cachedItemPositions[index] + p.cachedItemHeights[index];
+        index++;
+      }
+
+      // Calculate up to date scroll height
+      let scrollHeight = this.estimateFullHeight();
+      p.virtualWrapper.style.height = scrollHeight + 'px';
+
+      if (originalWidth !== list.clientWidth)
+      this.render();
+    } else {// non-virtual
+      if (count !== existingEls.length) {
+        for (let i = 0; i < existingCount; i++) {
+          existingEls[i][ReuseElSymbol] = true;
+        }
+
+        /** @type Node|undefined */
+        let lastEl = undefined;
+        for (let index = 0; index < count; index++) {
+          // Find existing element to reuse
+          let existingEl = existingEls.find((x) => x[ItemIndexSymbol] === index && x[ReuseElSymbol] === true);
+
+          if (existingEl !== undefined) {
+            delete existingEl[ReuseElSymbol];
+          }
+
+          // Find the element to insert before
+          let insertBefore = lastEl ? lastEl.nextSibling : list.childNodes[0];
+          if (insertBefore && insertBefore === existingEl)
+          insertBefore = insertBefore.nextSibling;
+
+          // Dequeue the element by reusing or creating a new one
+          lastEl = this._dequeueElementForIndex(existingEl, index, insertBefore);
+        }
+      }
+    }
+
+    // Cleanup extra unused elements
+    existingCount = existingEls.length; // May have changed
+    for (let i = 0; i < existingCount; i++) {
+      const el = existingEls[i];
+      if (el[ReuseElSymbol] !== true) continue;
+
+      let parent = el.parentNode;
+      if (parent)
+      parent.removeChild(el);
+      if (onItemUnrender && el[ItemIndexSymbol] !== undefined)
+      onItemUnrender(el);
+      existingEls.splice(i, 1);
+
+      i--;
+      existingCount--;
+    }
+  }
+
+  /**
+   * States that items were added at a certain position in the list. <br />
+   * Virtual mode: Call `render()` to update the view after making changes.
+   * @param {number} count
+   * @param {number} [atIndex=-1]
+   * @returns {VirtualListHelper}
+   */
+  addItemsAt(count, atIndex = -1) {
+    if (typeof count !== 'number' || count <= 0)
+    return this;
+
+    const p = this._p;
+
+    if (atIndex < -1 || atIndex >= p.count)
+    atIndex = p.count;
+
+    p.count += count;
+
+    if (p.virtual) {
+      if (atIndex >= 0 && atIndex < p.count) {
+        this._invalidateItemIndexesAt(atIndex, -1);
+      }
+    } else
+    {// non-virtual
+      let existingEls = p.existingEls;
+      let existingCount = existingEls.length;
+      if (existingCount !== p.count - count)
+      return this;
+
+      let existingRange = this._getExistingElsRange();
+      if (existingRange.firstValidArrayIndex === -1)
+      return this;
+
+      let startIndex = existingRange.firstValidArrayIndex + atIndex - existingRange.firstIndex;
+
+      this._pushItemIndexesAt(atIndex, count);
+
+      /** @type Node|undefined */
+      let lastEl = existingEls[startIndex - 1];
+
+      for (let index = atIndex, end = atIndex + count; index < end; index++) {
+        let insertBefore = lastEl ? lastEl.nextSibling : existingEls[0];
+        lastEl = this._dequeueElementForIndex(undefined, index, insertBefore);
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * States that items were removed at a certain position in the list. <br />
+   * Virtual mode: Call `render()` to update the view after making changes.
+   * @param {number} count
+   * @param {number} atIndex
+   * @returns {VirtualListHelper}
+   */
+  removeItemsAt(count, atIndex) {
+    const p = this._p;
+
+    if (typeof count !== 'number' || typeof atIndex !== 'number' || count <= 0 || atIndex < 0 || atIndex >= p.count)
+    return this;
+
+    p.count -= Math.min(count, p.count - atIndex);
+
+    if (p.virtual) {
+      this._invalidateItemIndexesAt(atIndex, -1);
+    } else
+    {// non-virtual
+      let existingEls = p.existingEls;
+      let existingCount = existingEls.length;
+      if (existingCount !== p.count + count)
+      return this;
+
+      let existingRange = this._getExistingElsRange();
+      if (existingRange.firstValidArrayIndex === -1)
+      return this;
+
+      this._pushItemIndexesAt(atIndex + count, -count);
+
+      const onItemUnrender = p.onItemUnrender;
+      let index = existingRange.firstValidArrayIndex + atIndex - existingRange.firstIndex;
+      if (index < existingEls.length) {
+        for (let i = 0; i < count; i++) {
+          let itemEl = existingEls[index + i];
+
+          let parent = itemEl.parentNode;
+          if (parent)
+          parent.removeChild(itemEl);
+          if (onItemUnrender && itemEl[ItemIndexSymbol] !== undefined)
+          onItemUnrender(itemEl);
+        }
+        existingEls.splice(index, count);
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * Mark an element for a re-render. <br />
+   * Virtual mode: Call `render()` to update the view after making changes. <br />
+   * Non-virtual mode - the element is re-rendered immediately.
+   * @param {number} index - the index of the element to re-render
+   * @returns {VirtualListHelper}
+   */
+  refreshItemAt(index) {
+    const p = this._p;
+
+    if (typeof index !== 'number' || index < 0 || index >= p.count)
+    return this;
+
+    if (p.virtual) {
+      this._invalidateItemIndexesAt(index, 1);
+    } else
+    {// non-virtual
+      let existingEls = p.existingEls;
+      let existingCount = existingEls.length;
+      if (existingCount !== p.count)
+      return this;
+
+      let existingRange = this._getExistingElsRange();
+
+      if (index >= existingRange.firstIndex && index <= existingRange.lastIndex) {
+        let itemEl = existingEls[existingRange.firstValidArrayIndex + index - existingRange.firstIndex];
+        delete itemEl[ItemIndexSymbol];
+        this._dequeueElementForIndex(itemEl, index, itemEl.nextSibling);
+      }
+    }
+
+    return this;
+  }
+
+  /**
+   * Tests whether an item at the specified index is rendered.
+   * @param {number} index - the index to test
+   * @returns {boolean}
+   */
+  isItemRendered(index) {
+    const p = this._p;
+
+    if (typeof index !== 'number' || index < 0 || index >= p.count)
+    return false;
+
+    let existingRange = this._getExistingElsRange();
+
+    return index >= existingRange.firstIndex && index <= existingRange.lastIndex;
+  }
+
+  /**
+   * Retrieves DOM element for the item at the specified index - if it's currently rendered.
+   * @param {number} index - the index to retrieve
+   * @returns {Element|undefined}
+   */
+  getItemElementAt(index) {
+    const p = this._p;
+
+    if (typeof index !== 'number' || index < 0 || index >= p.count)
+    return undefined;
+
+    let existingEls = p.existingEls;
+    let existingRange = this._getExistingElsRange();
+
+    if (index >= existingRange.firstIndex && index <= existingRange.lastIndex) {
+      return existingEls[existingRange.firstValidArrayIndex + index - existingRange.firstIndex];
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Retrieves the position for the specified index. <br />
+   * Can be used to scroll to a specific item.
+   * @param {number} index
+   * @returns {number|undefined}
+   */
+  getItemPosition(index) {
+    const p = this._p;
+
+    if (typeof index !== 'number' || index < 0 || index >= p.count)
+    return undefined;
+
+    if (p.virtual) {
+      return this._calculateItemPosition(index);
+    } else {
+      let itemEl = this.getItemElementAt(index);
+      if (itemEl === undefined)
+      return undefined;
+
+      const list = p.list;
+      return Css.getElementOffset(itemEl).top - Css.getElementOffset(list).top + list.scrollTop;
+    }
+  }
+
+  /**
+   * Retrieves the item index for the specified element
+   * @param {Element} el
+   * @returns {number|undefined}
+   */
+  getItemIndexFromElement(el) {
+    return el ? el[ItemIndexSymbol] : undefined;
+  }
+
+  /**
+   * Retrieves the size (or estimated size, if unknown) for the specified index. <br />
+   * @param {number} index
+   * @returns {number|undefined}
+   */
+  getItemSize(index) {
+    const p = this._p;
+
+    if (typeof index !== 'number' || index < 0 || index >= p.count)
+    return undefined;
+
+    let height = p.cachedItemHeights[index - 1]; // already calculated
+
+    if (height === undefined) {
+      height = p.itemHeightEstimatorFn ? p.itemHeightEstimatorFn(index - 1) : null; // estimated per item
+
+      if (typeof height !== 'number')
+      height = p.estimatedItemHeight; // estimated
+
+      p.cachedItemEstimatedHeights[index - 1] = height;
+    }
+
+    return height;
+  }
+
+  /**
+   * Retrieves the number of items that fit into the current viewport.
+   * @returns {number}
+   */
+  getVisibleItemCount() {
+    const p = this._p,list = p.list;
+
+    let scrollTop = list.scrollTop;
+    let visibleHeight = list.clientHeight;
+    let firstVisibleIndex, lastVisibleIndex;
+
+    if (p.virtual) {
+      firstVisibleIndex = binarySearchPosition(p.cachedItemPositions, scrollTop);
+      lastVisibleIndex = binarySearchPosition(p.cachedItemPositions, scrollTop + visibleHeight, firstVisibleIndex);
+    } else
+    {
+      const retriever = (i) => {
+        let pos = this.getItemPosition(i);
+        if (pos === undefined)
+        pos = Infinity;
+        return pos;
+      };
+
+      firstVisibleIndex = binarySearchPositionByFn(p.count, retriever, scrollTop);
+      lastVisibleIndex = binarySearchPositionByFn(p.count, retriever, scrollTop + visibleHeight, firstVisibleIndex);
+    }
+
+    if (this.getItemPosition(lastVisibleIndex) === scrollTop + visibleHeight)
+    lastVisibleIndex--;
+    return lastVisibleIndex - firstVisibleIndex + 1;
+  }
+
+  /**
+   * Renders a temporary ghost item. Can be used for testings several aspects of a proposed element, i.e measurements.
+   * @param {*} ghostIndex - the value to pass as the index for the renderer function
+   * @param {boolean} append - whether to append the item element to the DOM
+   * @param {function(itemEl: Element)} ghostTester - the function that will receive the element, called synchronously.
+   */
+  createGhostItemElement(ghostIndex, append, ghostTester) {
+    const p = this._p;
+
+    let itemEl = this._dequeueElementForIndex(null, ghostIndex, false);
+    try {
+      if (append) {
+        p.currentItemsParent.appendChild(itemEl);
+      }
+      ghostTester(itemEl);
+    } finally {
+      if (append) {
+        let parent = itemEl.parentNode;
+        if (parent)
+        parent.removeChild(itemEl);
+      }
+      if (p.onItemUnrender)
+      p.onItemUnrender(itemEl);
+    }
+  }
+
+  /**
+   * Reset the pointer to the current items wrapper
+   * @private
+   */
+  _resetCurrentItemsParent() {var _ref, _p$virtualWrapper;
+    const p = this._p;
+    p.currentItemsParent = (_ref = (_p$virtualWrapper = p.virtualWrapper) !== null && _p$virtualWrapper !== void 0 ? _p$virtualWrapper : p.userItemsParent) !== null && _ref !== void 0 ? _ref : p.list;
+  }
+
+  /**
+   * Destroy all created elements, for cleanup
+   * @returns {VirtualListHelper}
+   * @private
+   */
+  _destroyElements() {
+    const p = this._p;
+    const onItemUnrender = p.onItemUnrender;
+    const existingEls = p.existingEls;
+
+    for (let i = 0; i < existingEls.length; i++) {
+      const el = existingEls[i];
+
+      let parent = el.parentNode;
+      if (parent)
+      parent.removeChild(el);
+      if (onItemUnrender && el[ItemIndexSymbol] !== undefined)
+      onItemUnrender(el);
+    }
+
+    existingEls.length = 0;
+
+    if (p.virtualWrapper) {
+      if (p.virtualWrapper !== p.userItemsParent) {
+        if (p.virtualWrapper.parentNode) {
+          p.virtualWrapper.parentNode.removeChild(p.virtualWrapper);
+        }
+      }
+      p.virtualWrapper = null;
+      this._resetCurrentItemsParent();
+    }
+
+    return this;
+  }
+
+  /**
+   * Marks (an) item(s) at specific index(es) as to be re-rendered. <br />
+   * Applicable for virtual mode only.
+   * @param {number} index
+   * @param {number} count
+   * @private
+   */
+  _invalidateItemIndexesAt(index, count) {
+    const p = this._p;
+
+    this._setItemPositionsNeedsUpdate(index);
+
+    let existingEls = p.existingEls;
+    let existingCount = existingEls.length;
+    let existingRange = this._getExistingElsRange();
+
+    if (existingRange.firstValidArrayIndex === -1)
+    return;
+
+    if (count === -1)
+    count = existingEls.length;
+
+    // Clean
+    if (index >= existingRange.firstIndex && index <= existingRange.lastIndex) {
+      for (let i = existingRange.firstValidArrayIndex + index - existingRange.firstIndex,
+        c = 0;
+      i < existingCount && c < count;
+      i++, c++)
+      delete existingEls[i][ItemIndexSymbol];
+    }
+  }
+
+  /**
+   * In/decrement the item-index marker for specific item(s). <br />
+   * Used for inserting/removing items in the middle of the list, without re-rendering everything. <br />
+   * Applicable for non-virtual mode only.
+   * @param {number} index
+   * @param {number} count
+   * @private
+   */
+  _pushItemIndexesAt(index, count) {
+    const p = this._p;
+
+    let existingEls = p.existingEls;
+    let existingCount = existingEls.length;
+    let existingRange = this._getExistingElsRange();
+
+    if (existingRange.firstValidArrayIndex === -1)
+    return;
+
+    // Clean
+    if (index >= existingRange.firstIndex && index <= existingRange.lastIndex) {
+      for (let i = existingRange.firstValidArrayIndex + index - existingRange.firstIndex;
+      i < existingCount;
+      i++)
+      existingEls[i][ItemIndexSymbol] += count;
+    }
+  }
+
+  /**
+   * Hook relevant events
+   * @returns {VirtualListHelper}
+   * @private
+   */
+  _hookEvents() {
+    const p = this._p;
+
+    this._unhookEvents();
+
+    if (p.virtual && p.hookScrollEvent) {
+      p.list && p.list.addEventListener('scroll', /**@type Function*/p.boundRender);
+    }
+
+    return this;
+  }
+
+  /**
+   * Unhook previously hooked events
+   * @returns {VirtualListHelper}
+   * @private
+   */
+  _unhookEvents() {
+    const p = this._p;
+
+    p.list && p.list.removeEventListener('scroll', /**@type Function*/p.boundRender);
+
+    return this;
+  }
+
+  /**
+   * Mark item index from which the positions are not considered valid anymore. <br />
+   * Applicable for virtual mode only.
+   * @param {number} value
+   * @private
+   */
+  _setItemPositionsNeedsUpdate(value) {
+    const p = this._p;
+
+    if (value < p.itemPositionsNeedsUpdate) {
+      p.itemPositionsNeedsUpdate = value;
+    }
+  }
+
+  /**
+   * Calculates an item's top position (and stores in the private `cachedItemPositions` array). <br />
+   * Allows calculating last+1 index too, to get the bottom-most position. <br />
+   * Applicable for non-virtual mode only.
+   * @param {number} index
+   * @returns {number|undefined}
+   * @private
+   */
+  _calculateItemPosition(index) {
+    const p = this._p;
+
+    const cachedItemPositions = p.cachedItemPositions;
+
+    if (index >= p.itemPositionsNeedsUpdate) {
+      const count = p.count;
+      const cachedItemHeights = p.cachedItemHeights;
+      const cachedItemEstimatedHeights = p.cachedItemEstimatedHeights;
+      const estimatedItemHeight = p.estimatedItemHeight;
+      const itemHeightEstimatorFn = p.itemHeightEstimatorFn;
+
+      if (cachedItemHeights.length !== count) {
+        cachedItemHeights.length = count;
+        cachedItemEstimatedHeights.length = count;
+        cachedItemPositions.length = count;
+      }
+
+      let fromIndex = p.itemPositionsNeedsUpdate;
+      let toIndex = Math.min(index, count);
+
+      let pos = 0;
+
+      if (fromIndex > 0) {
+        pos = cachedItemPositions[fromIndex - 1];
+      }
+
+      for (let i = fromIndex; i <= toIndex; i++) {
+        if (i === 0) {
+          cachedItemPositions[i] = pos;
+          continue;
+        }
+
+        const prevIndex = i - 1;
+
+        let height = cachedItemHeights[prevIndex]; // already calculated
+
+        if (height === undefined) {
+          height = itemHeightEstimatorFn ? itemHeightEstimatorFn(prevIndex) : null; // estimated per item
+
+          if (typeof height !== 'number')
+          height = estimatedItemHeight; // estimated
+
+          cachedItemEstimatedHeights[prevIndex] = height;
+        }
+
+        pos += height;
+        cachedItemPositions[i] = pos;
+      }
+
+      p.itemPositionsNeedsUpdate = toIndex + 1;
+    }
+
+    // item after the last (calculate full height)
+    if (index > 0 && index === p.count) {
+      let height = p.cachedItemHeights[index - 1]; // already calculated
+
+      if (height === undefined) {
+        height = p.itemHeightEstimatorFn ? p.itemHeightEstimatorFn(index - 1) : null; // estimated per item
+
+        if (typeof height !== 'number')
+        height = p.estimatedItemHeight; // estimated
+
+        p.cachedItemEstimatedHeights[index - 1] = height;
+      }
+
+      return cachedItemPositions[index - 1] + height;
+    }
+
+    return cachedItemPositions[index];
+  }
+
+  /**
+   * Create (or reuse an existing) element for an item at the specified index,
+   *   and insert physically at specified position. <br />
+   * This will also update the element's position in the `existingEls` array.
+   * @param {Element|undefined} itemEl
+   * @param {number} index
+   * @param {Node|boolean|undefined} insertBefore
+   * @returns {Element}
+   * @private
+   */
+  _dequeueElementForIndex(itemEl, index, insertBefore) {
+    const p = this._p;
+    const virtualWrapper = p.virtualWrapper;
+    const itemParent = p.currentItemsParent;
+    const existingEls = p.existingEls;
+    const onItemRender = p.onItemRender;
+    const onItemUnrender = p.onItemUnrender;
+    const isNew = !itemEl;
+    const shouldReRender = isNew || index !== itemEl[ItemIndexSymbol];
+
+    if (itemEl) {
+      if (onItemUnrender && shouldReRender) {
+        onItemUnrender(itemEl);
+      }
+    } else {
+      itemEl = p.itemElementCreatorFn();
+
+      if (virtualWrapper && insertBefore !== false) {
+        /**@type ElementCSSInlineStyle*/itemEl.style.position = 'absolute';
+        /**@type ElementCSSInlineStyle*/itemEl.style.top = '0';
+        /**@type ElementCSSInlineStyle*/itemEl.style.left = '0';
+        /**@type ElementCSSInlineStyle*/itemEl.style.right = '0';
+      }
+    }
+
+    // Render only if it's a new item element
+    //   OR the index of the existing element is not the same of the index to render
+    if (shouldReRender) {
+      itemEl.innerHTML = ''; // Basic cleanup
+
+      if (onItemRender)
+      onItemRender(itemEl, index);
+    }
+
+    if (insertBefore !== false) {
+      if (!(insertBefore instanceof Node))
+      insertBefore = null;
+
+      // Insert into DOM
+      if (itemEl.parentNode !== itemParent ||
+      itemEl.nextSibling !== insertBefore) {
+        itemParent.insertBefore(itemEl, insertBefore);
+      }
+
+      // Remove from existing list
+      if (!isNew) {
+        let i = existingEls.indexOf(itemEl);
+        if (i !== -1)
+        existingEls.splice(i, 1);
+      }
+
+      // Insert into existing list
+      let beforeIndex = insertBefore ? existingEls.indexOf( /**@type Element*/insertBefore) : -1;
+      if (beforeIndex === -1) {
+        existingEls.push(itemEl);
+      } else {
+        existingEls.splice(beforeIndex, 0, itemEl);
+      }
+
+      if (virtualWrapper) {
+        // Calculate height
+        let itemHeight = itemEl.getBoundingClientRect().height;
+
+        // Put calculated height into cache, and invalidate positions if it's different
+        let cachedItemHeight = p.cachedItemHeights[index];
+        if (cachedItemHeight !== itemHeight) {
+          p.cachedItemHeights[index] = itemHeight;
+        }
+
+        if (cachedItemHeight !== undefined && itemHeight !== cachedItemHeight ||
+        cachedItemHeight === undefined && itemHeight !== p.cachedItemEstimatedHeights[index]) {
+          this._setItemPositionsNeedsUpdate(index + 1);
+        }
+
+        // Set item top position
+        let pos = this._calculateItemPosition(index);
+        const supportedTransform = getSupportedTransform();
+
+        if (supportedTransform === false) {
+          /**@type ElementCSSInlineStyle*/itemEl.style.top = `${pos}px`;
+        } else {
+          /**@type ElementCSSInlineStyle*/itemEl.style[supportedTransform] = `translateY(${pos}px)`;
+        }
+      }
+    }
+
+    // Add index metadata to item
+    itemEl[ItemIndexSymbol] = index;
+
+    return itemEl;
+  }
+
+  /**
+   * Fetches valid range of existingEls
+   * @returns {{firstIndex: (*|number), firstValidArrayIndex: number, lastValidArrayIndex: number, lastIndex: (*|number)}}
+   * @private
+   */
+  _getExistingElsRange() {
+    const p = this._p,existingEls = p.existingEls;
+
+    let firstValidArrayIndex = -1,lastValidArrayIndex = -1;
+
+    for (let i = 0, len = existingEls.length; i < len; i++) {
+      if (false === hasOwnProperty$1.call(existingEls[i], ItemIndexSymbol))
+      continue;
+      firstValidArrayIndex = i;
+      break;
+    }
+
+    for (let i = existingEls.length - 1; i >= 0; i--) {
+      if (false === hasOwnProperty$1.call(existingEls[i], ItemIndexSymbol))
+      continue;
+      lastValidArrayIndex = i;
+      break;
+    }
+
+    let firstIndex = firstValidArrayIndex !== -1 ? existingEls[firstValidArrayIndex][ItemIndexSymbol] : -1;
+    let lastIndex = lastValidArrayIndex !== -1 ? existingEls[lastValidArrayIndex][ItemIndexSymbol] : -1;
+
+    return {
+      firstValidArrayIndex: firstValidArrayIndex,
+      lastValidArrayIndex: lastValidArrayIndex,
+      firstIndex: firstIndex,
+      lastIndex: lastIndex
+    };
+  }
+}
+
+/** Marks the item index associated with an item element */
+const ItemIndexSymbol = Symbol('index');
+
+/** Marks an element for reuse */
+const ReuseElSymbol = Symbol('reuse');
+
+/**
+ * The default element creator
+ * @returns {HTMLLIElement}
+ */
+const defaultElementCreator = () => {
+  return document.createElement('li');
+};
+
+/**
+ * Will look for the index in the `positions` array closest to the specified `pos` value (<= pos).
+ * @param {number[]} positions
+ * @param {number} pos
+ * @param {number} [start=0]
+ * @param {number} [end=-1]
+ * @returns {number}
+ */
+const binarySearchPosition = (positions, pos, start = 0, end = -1) => {
+  let total = positions.length;
+  if (end < 0)
+  end += total;
+  if (end <= start) return end; // 0 or 1 length array
+
+  while (start <= end) {
+    let mid = Math.floor(start + (end - start) / 2);
+    let midPos = positions[mid];
+
+    if (midPos === pos || midPos <= pos && mid < total && positions[mid + 1] > pos) {
+      while (mid > 0 && positions[mid - 1] === midPos) // avoid bugs on 0-height items
+      mid--;
+
+      return mid;
+    }
+
+    if (midPos < pos)
+    start = mid + 1;else
+
+    end = mid - 1;
+  }
+
+  return end === -1 ? 0 : total - 1;
+};
+
+/**
+ * Will look for the index in a virtual list of positions supplied by `total` and `fn`,
+ *   closest to the specified `pos` value (<= pos).
+ * @param {number} total
+ * @param {function(index: number):number} fn
+ * @param {number} pos
+ * @param {number} [start=0]
+ * @param {number} [end=-1]
+ * @returns {number}
+ */
+const binarySearchPositionByFn = (total, fn, pos, start = 0, end = -1) => {
+  if (end < 0)
+  end += total;
+  if (end <= start) return end; // 0 or 1 length array
+
+  while (start <= end) {
+    let mid = Math.floor(start + (end - start) / 2);
+    let midPos = fn(mid);
+
+    if (midPos === pos || midPos <= pos && mid < total && fn(mid + 1) > pos) {
+      while (mid > 0 && fn(mid - 1) === midPos) // avoid bugs on 0-height items
+      mid--;
+
+      return mid;
+    }
+
+    if (midPos < pos)
+    start = mid + 1;else
+
+    end = mid - 1;
+  }
+
+  return end === -1 ? 0 : fn(total - 1);
+};
+
+/**
+ * Finds the last item in the array for which `fn` returns a truthy value
+ * @param {Array} array
+ * @param {Function} fn
+ * @returns {undefined|*}
+ */
+const findLast = (array, fn) => {
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (fn(array[i])) {
+      return array[i];
+    }
+  }
+  return undefined;
+};
+
+let _isTransformSupported = null;
+
+const getSupportedTransform = () => {
+  if (_isTransformSupported === null) {
+    let prefixes = ['transform', 'WebkitTransform', 'MozTransform', 'OTransform', 'msTransform'];
+    let div = document.createElement('div');
+    _isTransformSupported = false;
+    for (let item of prefixes) {
+      if (div && div.style[item] !== undefined) {
+        _isTransformSupported = item;
+        break;
+      }
+    }
   }
-}
+  return _isTransformSupported;
+};
 
 function ByColumnFilter(row, args) {
 
@@ -1746,7 +3102,10 @@ let hasIeDragAndDropBug = ieVersion && ieVersion < 10;
 let createElement = document.createElement.bind(document);
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-const IsSafeSymbol = 'safe';
+const IsSafeSymbol = Symbol('safe');
+const HoverInEventSymbol = Symbol('hover_in');
+const HoverOutEventSymbol = Symbol('hover_out');
+const RowClickEventSymbol = Symbol('row_click');
 
 function webkitRenderBugfix(el) {
   // BUGFIX: WebKit has a bug where it does not relayout, and this affects us because scrollbars
@@ -1839,9 +3198,7 @@ DGTable.prototype.initialize = function (options) {
   data('dgtable', that);
 
   // For jQuery.UI or jquery.removeevent
-  $el.on('remove', function () {
-    that.destroy();
-  });
+  $el.on('remove', () => that.destroy());
 
   p.onMouseMoveResizeAreaBound = this._onMouseMoveResizeArea.bind(this);
   p.onEndDragColumnHeaderBound = this._onEndDragColumnHeader.bind(this);
@@ -1851,92 +3208,97 @@ DGTable.prototype.initialize = function (options) {
 
   /**
    * @private
-   * @field {Boolean} _tableSkeletonNeedsRendering */
+   * @field {boolean} _tableSkeletonNeedsRendering */
   p.tableSkeletonNeedsRendering = true;
 
   /**
    * @private
-   * @field {Boolean} virtualTable */
+   * @field {boolean} virtualTable */
   o.virtualTable = options.virtualTable === undefined ? true : !!options.virtualTable;
 
   /**
    * @private
-   * @field {Number} rowsBufferSize */
+   * @field {number} estimatedRowHeight */
+  o.estimatedRowHeight = options.estimatedRowHeight === undefined ? 40 : options.estimatedRowHeight;
+
+  /**
+   * @private
+   * @field {number} rowsBufferSize */
   o.rowsBufferSize = options.rowsBufferSize || 3;
 
   /**
    * @private
-   * @field {Number} minColumnWidth */
+   * @field {number} minColumnWidth */
   o.minColumnWidth = Math.max(options.minColumnWidth || 35, 0);
 
   /**
    * @private
-   * @field {Number} resizeAreaWidth */
+   * @field {number} resizeAreaWidth */
   o.resizeAreaWidth = options.resizeAreaWidth || 8;
 
   /**
    * @private
-   * @field {Boolean} resizableColumns */
+   * @field {boolean} resizableColumns */
   o.resizableColumns = options.resizableColumns === undefined ? true : !!options.resizableColumns;
 
   /**
    * @private
-   * @field {Boolean} movableColumns */
+   * @field {boolean} movableColumns */
   o.movableColumns = options.movableColumns === undefined ? true : !!options.movableColumns;
 
   /**
    * @private
-   * @field {Number} sortableColumns */
+   * @field {number} sortableColumns */
   o.sortableColumns = options.sortableColumns === undefined ? 1 : parseInt(options.sortableColumns, 10) || 1;
 
   /**
    * @private
-   * @field {Boolean} adjustColumnWidthForSortArrow */
+   * @field {boolean} adjustColumnWidthForSortArrow */
   o.adjustColumnWidthForSortArrow = options.adjustColumnWidthForSortArrow === undefined ? true : !!options.adjustColumnWidthForSortArrow;
 
   /**
    * @private
-   * @field {Boolean} convertColumnWidthsToRelative */
+   * @field {boolean} convertColumnWidthsToRelative */
   o.convertColumnWidthsToRelative = options.convertColumnWidthsToRelative === undefined ? false : !!options.convertColumnWidthsToRelative;
 
   /**
    * @private
-   * @field {Boolean} autoFillTableWidth */
+   * @field {boolean} autoFillTableWidth */
   o.autoFillTableWidth = options.autoFillTableWidth === undefined ? false : !!options.autoFillTableWidth;
 
   /**
    * @private
-   * @field {String} cellClasses */
+   * @field {string} cellClasses */
   o.cellClasses = options.cellClasses === undefined ? '' : options.cellClasses;
 
   /**
    * @private
-   * @field {String} resizerClassName */
+   * @field {string} resizerClassName */
   o.resizerClassName = options.resizerClassName === undefined ? 'dgtable-resize' : options.resizerClassName;
 
   /**
    * @private
-   * @field {String} tableClassName */
+   * @field {string} tableClassName */
   o.tableClassName = options.tableClassName === undefined ? 'dgtable' : options.tableClassName;
 
   /**
    * @private
-   * @field {Boolean} allowCellPreview */
+   * @field {boolean} allowCellPreview */
   o.allowCellPreview = options.allowCellPreview === undefined ? true : options.allowCellPreview;
 
   /**
    * @private
-   * @field {Boolean} allowHeaderCellPreview */
+   * @field {boolean} allowHeaderCellPreview */
   o.allowHeaderCellPreview = options.allowHeaderCellPreview === undefined ? true : options.allowHeaderCellPreview;
 
   /**
    * @private
-   * @field {String} cellPreviewClassName */
+   * @field {string} cellPreviewClassName */
   o.cellPreviewClassName = options.cellPreviewClassName === undefined ? 'dgtable-cell-preview' : options.cellPreviewClassName;
 
   /**
    * @private
-   * @field {Boolean} cellPreviewAutoBackground */
+   * @field {boolean} cellPreviewAutoBackground */
   o.cellPreviewAutoBackground = options.cellPreviewAutoBackground === undefined ? true : options.cellPreviewAutoBackground;
 
   /**
@@ -1949,17 +3311,17 @@ DGTable.prototype.initialize = function (options) {
 
   /**
    * @private
-   * @field {Boolean} width */
+   * @field {boolean} width */
   o.width = options.width === undefined ? DGTable.Width.NONE : options.width;
 
   /**
    * @private
-   * @field {Boolean} relativeWidthGrowsToFillWidth */
+   * @field {boolean} relativeWidthGrowsToFillWidth */
   o.relativeWidthGrowsToFillWidth = options.relativeWidthGrowsToFillWidth === undefined ? true : !!options.relativeWidthGrowsToFillWidth;
 
   /**
    * @private
-   * @field {Boolean} relativeWidthShrinksToFillWidth */
+   * @field {boolean} relativeWidthShrinksToFillWidth */
   o.relativeWidthShrinksToFillWidth = options.relativeWidthShrinksToFillWidth === undefined ? false : !!options.relativeWidthShrinksToFillWidth;
 
   this.setCellFormatter(options.cellFormatter);
@@ -1967,7 +3329,7 @@ DGTable.prototype.initialize = function (options) {
   this.setFilter(options.filter);
 
   /** @private
-   * @field {Number} height */
+   * @field {number} height */
   o.height = options.height;
 
   // Prepare columns
@@ -2014,6 +3376,12 @@ DGTable.prototype.initialize = function (options) {
    * @field {RowCollection} _filteredRows */
   p.filteredRows = null;
 
+  this._setupHovers();
+};
+
+DGTable.prototype._setupHovers = function () {
+  const that = this,p = that.p;
+
   /*
    Setup hover mechanism.
    We need this to be high performance, as there may be MANY cells to call this on, on creation and destruction.
@@ -2021,12 +3389,11 @@ DGTable.prototype.initialize = function (options) {
    */
 
   /**
-   * @param {MouseEvent} evt
+   * @param {MouseEvent} event
    * @this {HTMLElement}
    * */
-  let hoverMouseOverHandler = function (evt) {
-    evt = evt || event;
-    let relatedTarget = evt.fromElement || evt.relatedTarget;
+  let hoverMouseOverHandler = function (event) {
+    let relatedTarget = event.fromElement || event.relatedTarget;
     if (relatedTarget === this || $.contains(this, relatedTarget)) return;
     if (this['__previewCell'] && (relatedTarget === this['__previewCell'] || $.contains(this['__previewCell'], relatedTarget))) return;
     that._cellMouseOverEvent.call(that, this);
@@ -2044,100 +3411,141 @@ DGTable.prototype.initialize = function (options) {
     that._cellMouseOutEvent.call(that, this);
   };
 
-  if ('addEventListener' in window) {
+  /**
+   * @param {HTMLElement} el cell or header-cell
+   * */
+  p._bindCellHoverIn = function (el) {
+    if (!el[HoverInEventSymbol]) {
+      el.addEventListener('mouseover', el[HoverInEventSymbol] = hoverMouseOverHandler.bind(el));
+    }
+  };
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * */
-    p._bindCellHoverIn = function (el) {
-      if (!el['__hoverIn']) {
-        el.addEventListener('mouseover', el['__hoverIn'] = hoverMouseOverHandler.bind(el));
-      }
-    };
+  /**
+   * @param {HTMLElement} el cell or header-cell
+   * */
+  p._unbindCellHoverIn = function (el) {
+    if (el[HoverInEventSymbol]) {
+      el.removeEventListener('mouseover', el[HoverInEventSymbol]);
+      el[HoverInEventSymbol] = null;
+    }
+  };
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * */
-    p._unbindCellHoverIn = function (el) {
-      if (el['__hoverIn']) {
-        el.removeEventListener('mouseover', el['__hoverIn']);
-        el['__hoverIn'] = null;
-      }
-    };
+  /**
+   * @param {HTMLElement} el cell or header-cell
+   * @returns {DGTable} self
+   * */
+  p._bindCellHoverOut = function (el) {
+    if (!el[HoverOutEventSymbol]) {
+      el.addEventListener('mouseout', el[HoverOutEventSymbol] = hoverMouseOutHandler.bind(el['__cell'] || el));
+    }
+    return this;
+  };
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * @returns {DGTable} self
-     * */
-    p._bindCellHoverOut = function (el) {
-      if (!el['__hoverOut']) {
-        el.addEventListener('mouseout', el['__hoverOut'] = hoverMouseOutHandler.bind(el['__cell'] || el));
-      }
-      return this;
-    };
+  /**
+   * @param {HTMLElement} el cell or header-cell
+   * @returns {DGTable} self
+   * */
+  p._unbindCellHoverOut = function (el) {
+    if (el[HoverOutEventSymbol]) {
+      el.removeEventListener('mouseout', el[HoverOutEventSymbol]);
+      el[HoverOutEventSymbol] = null;
+    }
+    return this;
+  };
+};
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * @returns {DGTable} self
-     * */
-    p._unbindCellHoverOut = function (el) {
-      if (el['__hoverOut']) {
-        el.removeEventListener('mouseout', el['__hoverOut']);
-        el['__hoverOut'] = null;
-      }
-      return this;
-    };
+DGTable.prototype._setupVirtualTable = function () {
+  const that = this,p = that.p,o = that.o;
 
-  } else {
+  const tableClassName = o.tableClassName,
+    rowClassName = tableClassName + '-row',
+    altRowClassName = tableClassName + '-row-alt',
+    cellClassName = tableClassName + '-cell';
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * */
-    p._bindCellHoverIn = function (el) {
-      if (!el['__hoverIn']) {
-        el.attachEvent('mouseover', el['__hoverIn'] = hoverMouseOverHandler.bind(el));
-      }
-    };
+  let visibleColumns = p.visibleColumns,
+    colCount = visibleColumns.length;
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * */
-    p._unbindCellHoverIn = function (el) {
-      if (el['__hoverIn']) {
-        el.detachEvent('mouseover', el['__hoverIn']);
-        el['__hoverIn'] = null;
-      }
-    };
+  p.notifyRendererOfColumnsConfig = () => {
+    visibleColumns = p.visibleColumns;
+    colCount = visibleColumns.length;
+
+    for (let colIndex = 0, column; colIndex < colCount; colIndex++) {
+      column = visibleColumns[colIndex];
+      column._finalWidth = column.actualWidthConsideringScrollbarWidth || column.actualWidth;
+    }
+  };
+
+  p.virtualListHelper = new VirtualListHelper({
+    list: p.table,
+    itemsParent: p.tbody,
+    autoVirtualWrapperWidth: false,
+    virtual: true,
+    buffer: o.rowsBufferSize,
+    estimatedItemHeight: o.estimatedRowHeight || 40,
+    itemElementCreatorFn: () => {
+      return createElement('div');
+    },
+    onItemRender: (row, index) => {
+      const rows = p.filteredRows || p.rows,
+        isDataFiltered = !!p.filteredRows,
+        allowCellPreview = p.allowCellPreview;
+
+      row.className = rowClassName;
+      if (index % 2 === 1)
+      row.className += ' ' + altRowClassName;
+
+      let rowData = rows[index];
+      let physicalRowIndex = isDataFiltered ? rowData['__i'] : index;
+
+      row['rowIndex'] = index;
+      row['physicalRowIndex'] = physicalRowIndex;
+
+      for (let colIndex = 0; colIndex < colCount; colIndex++) {
+        let column = visibleColumns[colIndex];
+        let cell = createElement('div');
+        cell['columnName'] = column.name;
+        cell.setAttribute('data-column', column.name);
+        cell.className = cellClassName;
+        cell.style.width = column._finalWidth + 'px';
+        if (column.cellClasses) cell.className += ' ' + column.cellClasses;
+        if (allowCellPreview) {
+          p._bindCellHoverIn(cell);
+        }
+
+        let cellInner = cell.appendChild(createElement('div'));
+        cellInner.innerHTML = this._getHtmlForCell(rowData, column);
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * */
-    p._bindCellHoverOut = function (el) {
-      if (!el['__hoverOut']) {
-        el.attachEvent('mouseout', el['__hoverOut'] = hoverMouseOutHandler.bind(el['__cell'] || el));
+        row.appendChild(cell);
       }
-    };
 
-    /**
-     * @param {HTMLElement} el cell or header-cell
-     * @returns {DGTable} self
-     * */
-    p._unbindCellHoverOut = function (el) {
-      if (el['__hoverOut']) {
-        el.detachEvent('mouseout', el['__hoverOut']);
-        el['__hoverOut'] = null;
+      row.addEventListener('click', row[RowClickEventSymbol] = (event) => {
+        that.trigger('rowclick', event, index, physicalRowIndex, row, rowData);
+      });
+
+      that.trigger('rowcreate', index, physicalRowIndex, row, rowData);
+    },
+
+    onItemUnrender: (row) => {
+      if (row[RowClickEventSymbol]) {
+        row.removeEventListener('click', row[RowClickEventSymbol]);
       }
-      return this;
-    };
 
-  }
+      that._unbindCellEventsForRow(row);
+
+      that.trigger('rowdestroy', row);
+    }
+  });
+
+  p.virtualListHelper.setCount(p.rows.length);
+
+  p.notifyRendererOfColumnsConfig();
 };
 
 /**
  * Add an event listener
  * @public
  * @expose
- * @param {String} eventName
+ * @param {string} eventName
  * @param {Function} callback
  * @returns {DGTable}
  */
@@ -2162,7 +3570,7 @@ DGTable.prototype.on = function (eventName, callback) {
  * Add an event listener for a one shot
  * @public
  * @expose
- * @param {String} eventName
+ * @param {string} eventName
  * @param {Function} callback
  * @returns {DGTable}
  */
@@ -2187,7 +3595,7 @@ DGTable.prototype.once = function (eventName, callback) {
  * Remove an event listener
  * @public
  * @expose
- * @param {String} eventName
+ * @param {string} eventName
  * @param {Function} callback
  * @returns {DGTable}
  */
@@ -2230,8 +3638,8 @@ DGTable.prototype.trigger = function (eventName) {
 /**
  * Detect column width mode
  * @private
- * @param {Number|String} width
- * @param {Number} minWidth
+ * @param {Number|string} width
+ * @param {number} minWidth
  * @returns {Object} parsed width
  */
 DGTable.prototype._parseColumnWidth = function (width, minWidth) {
@@ -2303,7 +3711,7 @@ DGTable.prototype._initColumnFromData = function (columnData) {
  * @public
  * @expose
  */
-DGTable.prototype.close = DGTable.prototype.remove = DGTable.prototype.destroy = function () {
+DGTable.prototype.close = DGTable.prototype.remove = DGTable.prototype.destroy = function () {var _p$virtualListHelper;
 
   let that = this,
     p = that.p || {},
@@ -2318,16 +3726,15 @@ DGTable.prototype.close = DGTable.prototype.remove = DGTable.prototype.destroy =
     p.$resizer = null;
   }
 
-  if (p.$tbody) {
-    let trs = p.$tbody[0].childNodes;
-    for (let i = 0, len = trs.length; i < len; i++) {
-      that.trigger('rowdestroy', trs[i]);
-    }
-  }
+  (_p$virtualListHelper = p.virtualListHelper) === null || _p$virtualListHelper === void 0 ? void 0 : _p$virtualListHelper.destroy();
+  p.virtualListHelper = null;
 
   // Using quotes for __super__ because Google Closure Compiler has a bug...
 
-  this._destroyHeaderCells()._unbindCellEventsForTable();
+  this._destroyHeaderCells();
+
+  p.virtualListHelper.destroy();
+
   if (p.$table) {
     p.$table.empty();
   }
@@ -2381,12 +3788,6 @@ DGTable.prototype._unbindCellEventsForTable = function () {
     }
   }
 
-  if (p.tbody) {
-    for (let i = 0, rows = p.tbody.childNodes, rowCount = rows.length; i < rowCount; i++) {
-      this._unbindCellEventsForRow(rows[i]);
-    }
-  }
-
   return this;
 };
 
@@ -2424,8 +3825,6 @@ DGTable.prototype.render = function () {
     return this;
   }
 
-  let renderedRows, rowCount;
-
   if (p.tableSkeletonNeedsRendering === true) {
     p.tableSkeletonNeedsRendering = false;
 
@@ -2442,12 +3841,7 @@ DGTable.prototype.render = function () {
     tableWidthChanged(true, false) // Take this chance to calculate required column widths
     ._renderSkeletonHeaderCells();
 
-    if (!o.virtualTable) {
-      let rows = p.filteredRows || p.rows;
-      rowCount = rows.length;
-      renderedRows = this.renderRows(0, rowCount - 1);
-      p.$tbody.html('').append(renderedRows);
-    }
+    p.virtualListHelper.invalidate();
 
     this._updateLastCellWidthFromScrollbar(true);
 
@@ -2472,63 +3866,10 @@ DGTable.prototype.render = function () {
     }
 
     this.trigger('renderskeleton');
+  }
 
-    if (o.virtualTable) {
-      p.$table.on('scroll', this._onVirtualTableScrolled.bind(this));
-      this.render();
-    }
-
-  } else if (o.virtualTable) {
-    rowCount = (p.filteredRows || p.rows).length;
-    let scrollTop = p.table.scrollTop;
-    let firstVisible = Math.floor((scrollTop - p.virtualRowHeightFirst) / p.virtualRowHeight) + 1 - o.rowsBufferSize;
-    let lastVisible = Math.ceil((scrollTop - p.virtualRowHeightFirst + p.visibleHeight) / p.virtualRowHeight) + o.rowsBufferSize;
-    if (firstVisible < 0) firstVisible = 0;
-    if (lastVisible >= rowCount) {
-      lastVisible = rowCount - 1;
-    }
-
-    let oldFirstVisible = -1,oldLastVisible = -1;
-    let tbodyChildNodes = p.tbody.childNodes;
-    if (tbodyChildNodes.length) {
-      oldFirstVisible = tbodyChildNodes[0]['rowIndex'];
-      oldLastVisible = tbodyChildNodes[tbodyChildNodes.length - 1]['rowIndex'];
-    }
-
-    let countToRemove;
-
-    if (oldFirstVisible !== -1 && oldFirstVisible < firstVisible) {
-      countToRemove = Math.min(oldLastVisible + 1, firstVisible) - oldFirstVisible;
-      for (let i = 0; i < countToRemove; i++) {
-        this.trigger('rowdestroy', tbodyChildNodes[0]);
-        this._unbindCellEventsForRow(tbodyChildNodes[0]);
-        p.tbody.removeChild(tbodyChildNodes[0]);
-      }
-      oldFirstVisible += countToRemove;
-      if (oldFirstVisible > oldLastVisible) {
-        oldFirstVisible = oldLastVisible = -1;
-      }
-    } else if (oldLastVisible !== -1 && oldLastVisible > lastVisible) {
-      countToRemove = oldLastVisible - Math.max(oldFirstVisible - 1, lastVisible);
-      for (let i = 0; i < countToRemove; i++) {
-        this.trigger('rowdestroy', tbodyChildNodes[tbodyChildNodes.length - 1]);
-        this._unbindCellEventsForRow(tbodyChildNodes[tbodyChildNodes.length - 1]);
-        p.tbody.removeChild(tbodyChildNodes[tbodyChildNodes.length - 1]);
-      }
-      if (oldLastVisible < oldFirstVisible) {
-        oldFirstVisible = oldLastVisible = -1;
-      }
-    }
+  p.virtualListHelper.render();
 
-    if (firstVisible < oldFirstVisible) {
-      renderedRows = this.renderRows(firstVisible, Math.min(lastVisible, oldFirstVisible - 1));
-      p.$tbody.prepend(renderedRows);
-    }
-    if (lastVisible > oldLastVisible || oldLastVisible === -1) {
-      renderedRows = this.renderRows(oldLastVisible === -1 ? firstVisible : oldLastVisible + 1, lastVisible);
-      p.$tbody.append(renderedRows);
-    }
-  }
   this.trigger('render');
   return this;
 };
@@ -2537,13 +3878,14 @@ DGTable.prototype.render = function () {
  * Forces a full render of the table
  * @public
  * @expose
- * @param {Boolean=true} render - Should render now?
+ * @param {boolean=true} render - Should render now?
  * @returns {DGTable} self
  */
-DGTable.prototype.clearAndRender = function (render) {
+DGTable.prototype.clearAndRender = function (render) {var _p$notifyRendererOfCo;
   let p = this.p;
 
   p.tableSkeletonNeedsRendering = true;
+  (_p$notifyRendererOfCo = p.notifyRendererOfColumnsConfig) === null || _p$notifyRendererOfCo === void 0 ? void 0 : _p$notifyRendererOfCo.call(p);
 
   if (render === undefined || render) {
     this.render();
@@ -2552,129 +3894,10 @@ DGTable.prototype.clearAndRender = function (render) {
   return this;
 };
 
-/**
- * Render rows
- * @private
- * @param {Number} first first row to render
- * @param {Number} last last row to render
- * @returns {DocumentFragment} fragment containing all rendered rows
- */
-DGTable.prototype.renderRows = function (first, last) {
-  const o = this.o,p = this.p;
-
-  let tableClassName = o.tableClassName,
-    rowClassName = tableClassName + '-row',
-    altRowClassName = tableClassName + '-row-alt',
-    cellClassName = tableClassName + '-cell',
-    rows = p.filteredRows || p.rows,
-    isDataFiltered = !!p.filteredRows,
-    allowCellPreview = o.allowCellPreview,
-    visibleColumns = p.visibleColumns,
-    isVirtual = o.virtualTable,
-    virtualRowHeightFirst = p.virtualRowHeightFirst,
-    virtualRowHeight = p.virtualRowHeight,
-    top;
-
-  let colCount = visibleColumns.length;
-  for (let colIndex = 0, column; colIndex < colCount; colIndex++) {
-    column = visibleColumns[colIndex];
-    column._finalWidth = column.actualWidthConsideringScrollbarWidth || column.actualWidth;
-  }
-
-  let bodyFragment = document.createDocumentFragment();
-
-  let isRtl = this._isTableRtl(),
-    virtualRowXAttr = isRtl ? 'right' : 'left';
-
-  const supportedTransform = CssUtil.getSupportedTransform();
-
-  for (let i = first, rowCount = rows.length;
-  i < rowCount && i <= last;
-  i++) {
-
-    let rowData = rows[i];
-    let physicalRowIndex = isDataFiltered ? rowData['__i'] : i;
-
-    let row = createElement('div');
-    row.className = rowClassName;
-    if (i % 2 === 1)
-    row.className += ' ' + altRowClassName;
-
-    row['rowIndex'] = i;
-    row['physicalRowIndex'] = physicalRowIndex;
-
-    for (let colIndex = 0; colIndex < colCount; colIndex++) {
-      let column = visibleColumns[colIndex];
-      let cell = createElement('div');
-      cell['columnName'] = column.name;
-      cell.setAttribute('data-column', column.name);
-      cell.className = cellClassName;
-      cell.style.width = column._finalWidth + 'px';
-      if (column.cellClasses) cell.className += ' ' + column.cellClasses;
-      if (allowCellPreview) {
-        p._bindCellHoverIn(cell);
-      }
-
-      let cellInner = cell.appendChild(createElement('div'));
-      cellInner.innerHTML = this._getHtmlForCell(rowData, column);
-
-      row.appendChild(cell);
-    }
-
-    if (isVirtual) {
-      top = i > 0 ? virtualRowHeightFirst + (i - 1) * virtualRowHeight : 0;
-      row.style.position = 'absolute';
-      row.style[virtualRowXAttr] = 0;
-
-      if (supportedTransform === false) {
-        row.style.top = `${top}px`;
-      } else {
-        row.style.top = '0px';
-        row.style[supportedTransform] = `translateY(${top}px)`;
-      }
-    }
-
-    bodyFragment.appendChild(row);
-
-    this.trigger('rowcreate', i, physicalRowIndex, row, rowData);
-
-    let rowIndex = i;
-    row.addEventListener('click', (event) => {
-      this.trigger('rowclick', event, rowIndex, physicalRowIndex, row, rowData);
-    });
-  }
-
-  return bodyFragment;
-};
-
-/**
- * Calculate virtual table height for scrollbar
- * @private
- * @returns {DGTable} self
- */
-DGTable.prototype._calculateVirtualHeight = function () {
-  let p = this.p;
-
-  if (p.tbody) {
-    let rowCount = (p.filteredRows || p.rows).length;
-    let height = p.virtualRowHeight * rowCount;
-    if (rowCount) {
-      height += p.virtualRowHeightFirst - p.virtualRowHeight;
-      height += p.virtualRowHeightLast - p.virtualRowHeight;
-    }
-    // At least 1 pixel - to show scrollers correctly.
-    if (height < 1) {
-      height = 1;
-    }
-    p.tbody.style.height = height + 'px';
-  }
-  return this;
-};
-
 /**
  * Calculate the size required for the table body width (which is the row's width)
  * @private
- * @returns {Number} calculated width
+ * @returns {number} calculated width
  */
 DGTable.prototype._calculateTbodyWidth = function () {
   const p = this.p;
@@ -2736,7 +3959,7 @@ DGTable.prototype._calculateTbodyWidth = function () {
  * @public
  * @expose
  * @param {COLUMN_OPTIONS[]} columns - Column definitions array
- * @param {Boolean=true} render - Should render now?
+ * @param {boolean=true} render - Should render now?
  * @returns {DGTable} self
  */
 DGTable.prototype.setColumns = function (columns, render) {
@@ -2776,8 +3999,8 @@ DGTable.prototype.setColumns = function (columns, render) {
  * @public
  * @expose
  * @param {COLUMN_OPTIONS} columnData column properties
- * @param {String|Number} [before=-1] column name or order to be inserted before
- * @param {Boolean=true} render - Should render now?
+ * @param {string|number} [before=-1] column name or order to be inserted before
+ * @param {boolean=true} render - Should render now?
  * @returns {DGTable} self
  */
 DGTable.prototype.addColumn = function (columnData, before, render) {
@@ -2815,8 +4038,8 @@ DGTable.prototype.addColumn = function (columnData, before, render) {
  * Remove a column from the table
  * @public
  * @expose
- * @param {String} column column name
- * @param {Boolean=true} render - Should render now?
+ * @param {string} column column name
+ * @param {boolean=true} render - Should render now?
  * @returns {DGTable} self
  */
 DGTable.prototype.removeColumn = function (column, render) {
@@ -2840,7 +4063,7 @@ DGTable.prototype.removeColumn = function (column, render) {
  * Sets a new cell formatter.
  * @public
  * @expose
- * @param {function(value: *, columnName: String, row: Object):String|null} [formatter=null] - The cell formatter. Should return an HTML.
+ * @param {function(value: *, columnName: string, row: Object):string|null} [formatter=null] - The cell formatter. Should return an HTML.
  * @returns {DGTable} self
  */
 DGTable.prototype.setCellFormatter = function (formatter) {
@@ -2861,7 +4084,7 @@ DGTable.prototype.setCellFormatter = function (formatter) {
  * Sets a new header cell formatter.
  * @public
  * @expose
- * @param {function(label: String, columnName: String):String|null} [formatter=null] - The cell formatter. Should return an HTML.
+ * @param {function(label: string, columnName: string):string|null} [formatter=null] - The cell formatter. Should return an HTML.
  * @returns {DGTable} self
  */
 DGTable.prototype.setHeaderCellFormatter = function (formatter) {
@@ -2878,7 +4101,7 @@ DGTable.prototype.setHeaderCellFormatter = function (formatter) {
 /**
  * @public
  * @expose
- * @param {function(row:Object,args:Object):Boolean|null} [filterFunc=null] - The filter function to work with filters. Default is a by-colum filter.
+ * @param {function(row:Object,args:Object):boolean|null} [filterFunc=null] - The filter function to work with filters. Default is a by-colum filter.
  * @returns {DGTable} self
  */
 DGTable.prototype.setFilter = function (filterFunc) {
@@ -2970,8 +4193,8 @@ DGTable.prototype._refilter = function () {
  * Set a new label to a column
  * @public
  * @expose
- * @param {String} column Name of the column
- * @param {String} label New label for the column
+ * @param {string} column Name of the column
+ * @param {string} label New label for the column
  * @returns {DGTable} self
  */
 DGTable.prototype.setColumnLabel = function (column, label) {
@@ -3047,7 +4270,7 @@ DGTable.prototype.moveColumn = function (src, dest, visibleOnly = true) {
         let destWidth = p.visibleColumns[destOrder];
         destWidth = (destWidth.actualWidthConsideringScrollbarWidth || destWidth.actualWidth) + 'px';
 
-        let tbodyChildren = p.$tbody[0].childNodes;
+        let tbodyChildren = p.tbody.childNodes;
         for (let i = 0, count = tbodyChildren.length; i < count; i++) {
           let row = tbodyChildren[i];
           if (row.nodeType !== 1) continue;
@@ -3067,9 +4290,9 @@ DGTable.prototype.moveColumn = function (src, dest, visibleOnly = true) {
  * Sort the table
  * @public
  * @expose
- * @param {String?} column Name of the column to sort on (or null to remove sort arrow)
- * @param {Boolean=} descending Sort in descending order
- * @param {Boolean} [add=false] Should this sort be on top of the existing sort? (For multiple column sort)
+ * @param {string?} column Name of the column to sort on (or null to remove sort arrow)
+ * @param {boolean=} descending Sort in descending order
+ * @param {boolean} [add=false] Should this sort be on top of the existing sort? (For multiple column sort)
  * @returns {DGTable} self
  */
 DGTable.prototype.sort = function (column, descending, add) {
@@ -3126,20 +4349,10 @@ DGTable.prototype.sort = function (column, descending, add) {
     this._showSortArrow(currentSort[i].column, currentSort[i].descending);
   }
 
-  if (o.adjustColumnWidthForSortArrow && !o._tableSkeletonNeedsRendering) {
+  if (o.adjustColumnWidthForSortArrow && !p.tableSkeletonNeedsRendering) {
     this.tableWidthChanged(true);
   }
 
-  if (o.virtualTable) {
-    while (p.tbody && p.tbody.firstChild) {
-      this.trigger('rowdestroy', p.tbody.firstChild);
-      this._unbindCellEventsForRow(p.tbody.firstChild);
-      p.tbody.removeChild(p.tbody.firstChild);
-    }
-  } else {
-    p.tableSkeletonNeedsRendering = true;
-  }
-
   p.rows.sortColumn = currentSort;
 
   let comparator;
@@ -3150,6 +4363,8 @@ DGTable.prototype.sort = function (column, descending, add) {
     }
   }
 
+  p.virtualListHelper.invalidate().render();
+
   // Build output for event, with option names that will survive compilers
   let sorts = [];
   for (let i = 0; i < currentSort.length; i++) {
@@ -3213,6 +4428,7 @@ DGTable.prototype._ensureVisibleColumns = function () {
     p.visibleColumns.push(p.columns[0]);
     this.trigger('showcolumn', p.columns[0].name);
   }
+
   return this;
 };
 
@@ -3220,8 +4436,8 @@ DGTable.prototype._ensureVisibleColumns = function () {
  * Show or hide a column
  * @public
  * @expose
- * @param {String} column Unique column name
- * @param {Boolean} visible New visibility mode for the column
+ * @param {string} column Unique column name
+ * @param {boolean} visible New visibility mode for the column
  * @returns {DGTable} self
  */
 DGTable.prototype.setColumnVisible = function (column, visible) {
@@ -3246,7 +4462,7 @@ DGTable.prototype.setColumnVisible = function (column, visible) {
  * Get the visibility mode of a column
  * @public
  * @expose
- * @returns {Boolean} true if visible
+ * @returns {boolean} true if visible
  */
 DGTable.prototype.isColumnVisible = function (column) {
   const p = this.p;
@@ -3261,7 +4477,7 @@ DGTable.prototype.isColumnVisible = function (column) {
  * Globally set the minimum column width
  * @public
  * @expose
- * @param {Number} minColumnWidth Minimum column width
+ * @param {number} minColumnWidth Minimum column width
  * @returns {DGTable} self
  */
 DGTable.prototype.setMinColumnWidth = function (minColumnWidth) {
@@ -3278,7 +4494,7 @@ DGTable.prototype.setMinColumnWidth = function (minColumnWidth) {
  * Get the current minimum column width
  * @public
  * @expose
- * @returns {Number} Minimum column width
+ * @returns {number} Minimum column width
  */
 DGTable.prototype.getMinColumnWidth = function () {
   return this.o.minColumnWidth;
@@ -3288,7 +4504,7 @@ DGTable.prototype.getMinColumnWidth = function () {
  * Set the limit on concurrent columns sorted
  * @public
  * @expose
- * @param {Number} sortableColumns How many sortable columns to allow?
+ * @param {number} sortableColumns How many sortable columns to allow?
  * @returns {DGTable} self
  */
 DGTable.prototype.setSortableColumns = function (sortableColumns) {
@@ -3309,7 +4525,7 @@ DGTable.prototype.setSortableColumns = function (sortableColumns) {
  * Get the limit on concurrent columns sorted
  * @public
  * @expose
- * @returns {Number} How many sortable columns are allowed?
+ * @returns {number} How many sortable columns are allowed?
  */
 DGTable.prototype.getSortableColumns = function () {
   return this.o.sortableColumns;
@@ -3318,7 +4534,7 @@ DGTable.prototype.getSortableColumns = function () {
 /**
  * @public
  * @expose
- * @param {Boolean?} movableColumns=true are the columns movable?
+ * @param {boolean?} movableColumns=true are the columns movable?
  * @returns {DGTable} self
  */
 DGTable.prototype.setMovableColumns = function (movableColumns) {
@@ -3334,7 +4550,7 @@ DGTable.prototype.setMovableColumns = function (movableColumns) {
 /**
  * @public
  * @expose
- * @returns {Boolean} are the columns movable?
+ * @returns {boolean} are the columns movable?
  */
 DGTable.prototype.getMovableColumns = function () {
   return this.o.movableColumns;
@@ -3343,7 +4559,7 @@ DGTable.prototype.getMovableColumns = function () {
 /**
  * @public
  * @expose
- * @param {Boolean} resizableColumns=true are the columns resizable?
+ * @param {boolean} resizableColumns=true are the columns resizable?
  * @returns {DGTable} self
  */
 DGTable.prototype.setResizableColumns = function (resizableColumns) {
@@ -3359,7 +4575,7 @@ DGTable.prototype.setResizableColumns = function (resizableColumns) {
 /**
  * @public
  * @expose
- * @returns {Boolean} are the columns resizable?
+ * @returns {boolean} are the columns resizable?
  */
 DGTable.prototype.getResizableColumns = function () {
   return this.o.resizableColumns;
@@ -3383,8 +4599,8 @@ DGTable.prototype.setComparatorCallback = function (comparatorCallback) {
  * Set a new width to a column
  * @public
  * @expose
- * @param {String} column name of the column to resize
- * @param {Number|String} width new column as pixels, or relative size (0.5, 50%)
+ * @param {string} column name of the column to resize
+ * @param {number|string} width new column as pixels, or relative size (0.5, 50%)
  * @returns {DGTable} self
  */
 DGTable.prototype.setColumnWidth = function (column, width) {
@@ -3415,8 +4631,8 @@ DGTable.prototype.setColumnWidth = function (column, width) {
 /**
  * @public
  * @expose
- * @param {String} column name of the column
- * @returns {String|null} the serialized width of the specified column, or null if column not found
+ * @param {string} column name of the column
+ * @returns {string|null} the serialized width of the specified column, or null if column not found
  */
 DGTable.prototype.getColumnWidth = function (column) {
   const p = this.p;
@@ -3431,7 +4647,7 @@ DGTable.prototype.getColumnWidth = function (column) {
 /**
  * @public
  * @expose
- * @param {String} column name of the column
+ * @param {string} column name of the column
  * @returns {SERIALIZED_COLUMN|null} configuration for all columns
  */
 DGTable.prototype.getColumnConfig = function (column) {
@@ -3559,25 +4775,20 @@ DGTable.prototype._getHtmlForCell = function (rowData, column) {
  * Returns the y pos of a row by index
  * @public
  * @expose
- * @param {Number} rowIndex - index of the row
- * @returns {Number|null} Y pos
+ * @param {number} rowIndex - index of the row
+ * @returns {number|null} Y pos
  */
 DGTable.prototype.getRowYPos = function (rowIndex) {
   const p = this.p;
 
-  if (this.o.virtualTable) {
-    return rowIndex > 0 ? p.virtualRowHeightFirst + (rowIndex - 1) * p.virtualRowHeight : 0;
-  } else {
-    let row = p.tbody.childNodes[rowIndex];
-    return row ? row.offsetTop : null;
-  }
+  return p.virtualListHelper.getItemPosition(rowIndex) || null;
 };
 
 /**
  * Returns the row data for a specific row
  * @public
  * @expose
- * @param {Number} row index of the row
+ * @param {number} row index of the row
  * @returns {Object} Row data
  */
 DGTable.prototype.getDataForRow = function (row) {
@@ -3591,7 +4802,7 @@ DGTable.prototype.getDataForRow = function (row) {
  * Gets the number of rows
  * @public
  * @expose
- * @returns {Number} Row count
+ * @returns {number} Row count
  */
 DGTable.prototype.getRowCount = function () {
   const p = this.p;
@@ -3603,7 +4814,7 @@ DGTable.prototype.getRowCount = function () {
  * @public
  * @expose
  * @param {Object} rowData - Row data to find
- * @returns {Number} Row index
+ * @returns {number} Row index
  */
 DGTable.prototype.getIndexForRow = function (rowData) {
   const p = this.p;
@@ -3614,7 +4825,7 @@ DGTable.prototype.getIndexForRow = function (rowData) {
  * Gets the number of filtered rows
  * @public
  * @expose
- * @returns {Number} Filtered row count
+ * @returns {number} Filtered row count
  */
 DGTable.prototype.getFilteredRowCount = function () {
   const p = this.p;
@@ -3626,7 +4837,7 @@ DGTable.prototype.getFilteredRowCount = function () {
  * @public
  * @expose
  * @param {Object} rowData - Row data to find
- * @returns {Number} Row index
+ * @returns {number} Row index
  */
 DGTable.prototype.getIndexForFilteredRow = function (rowData) {
   const p = this.p;
@@ -3637,7 +4848,7 @@ DGTable.prototype.getIndexForFilteredRow = function (rowData) {
  * Returns the row data for a specific row
  * @public
  * @expose
- * @param {Number} row index of the filtered row
+ * @param {number} row index of the filtered row
  * @returns {Object} Row data
  */
 DGTable.prototype.getDataForFilteredRow = function (row) {
@@ -3659,7 +4870,7 @@ DGTable.prototype.getHeaderRowElement = function () {
 /**
  * @private
  * @param {Element} el
- * @returns {Number} width
+ * @returns {number} width
  */
 DGTable.prototype._horizontalPadding = function (el) {
   return (parseFloat($.css(el, 'padding-left')) || 0) + (
@@ -3669,7 +4880,7 @@ DGTable.prototype._horizontalPadding = function (el) {
 /**
  * @private
  * @param {Element} el
- * @returns {Number} width
+ * @returns {number} width
  */
 DGTable.prototype._horizontalBorderWidth = function (el) {
   return (parseFloat($.css(el, 'border-left')) || 0) + (
@@ -3678,28 +4889,28 @@ DGTable.prototype._horizontalBorderWidth = function (el) {
 
 /**
  * @private
- * @returns {Number} width
+ * @returns {number} width
  */
 DGTable.prototype._calculateWidthAvailableForColumns = function () {
   const o = this.o,p = this.p;
 
   // Changing display mode briefly, to prevent taking in account the  parent's scrollbar width when we are the cause for it
   let oldDisplay, lastScrollTop, lastScrollLeft;
-  if (p.$table) {
+  if (p.table) {
     lastScrollTop = p.table ? p.table.scrollTop : 0;
     lastScrollLeft = p.table ? p.table.scrollLeft : 0;
 
     if (o.virtualTable) {
-      oldDisplay = p.$table[0].style.display;
-      p.$table[0].style.display = 'none';
+      oldDisplay = p.table.style.display;
+      p.table.style.display = 'none';
     }
   }
 
   let detectedWidth = Css.getElementWidth(this.$el[0]);
 
-  if (p.$table) {
+  if (p.table) {
     if (o.virtualTable) {
-      p.$table[0].style.display = oldDisplay;
+      p.table.style.display = oldDisplay;
     }
 
     p.table.scrollTop = lastScrollTop;
@@ -3773,8 +4984,8 @@ DGTable.prototype.tableWidthChanged = function () {
   /**
    * @public
    * @expose
-   * @param {Boolean} [forceUpdate=false]
-   * @param {Boolean} [renderColumns=true]
+   * @param {boolean} [forceUpdate=false]
+   * @param {boolean} [renderColumns=true]
    * @returns {DGTable} self
    */
   return function (forceUpdate, renderColumns) {
@@ -3800,7 +5011,7 @@ DGTable.prototype.tableWidthChanged = function () {
       tableWidthBeforeCalculations = parseFloat(p.tbody.style.minWidth) || 0;
     }
 
-    if (sizeLeft !== lastDetectedWidth || forceUpdate) {
+    if (sizeLeft !== lastDetectedWidth || forceUpdate) {var _p$notifyRendererOfCo2;
       lastDetectedWidth = detectedWidth;
 
       let absWidthTotal = 0,changedColumnIndexes = [],totalRelativePercentage = 0;
@@ -3975,6 +5186,8 @@ DGTable.prototype.tableWidthChanged = function () {
         p.visibleColumns[p.visibleColumns.length - 1].actualWidth - (p.scrollbarWidth || 0);
       }
 
+      (_p$notifyRendererOfCo2 = p.notifyRendererOfColumnsConfig) === null || _p$notifyRendererOfCo2 === void 0 ? void 0 : _p$notifyRendererOfCo2.call(p);
+
       if (renderColumns) {
         let tableWidth = this._calculateTbodyWidth();
 
@@ -4037,9 +5250,9 @@ DGTable.prototype.tableHeightChanged = function () {
  * @public
  * @expose
  * @param {Object[]} data - array of rows to add to the table
- * @param {Number} [at=-1] - where to add the rows at
- * @param {Boolean} [resort=false] - should resort all rows?
- * @param {Boolean} [render=true]
+ * @param {number} [at=-1] - where to add the rows at
+ * @param {boolean} [resort=false] - should resort all rows?
+ * @param {boolean} [render=true]
  * @returns {DGTable} self
  */
 DGTable.prototype.addRows = function (data, at, resort, render) {
@@ -4079,39 +5292,18 @@ DGTable.prototype.addRows = function (data, at, resort, render) {
       }
 
     } else if (render) {
-      let childNodes = p.tbody.childNodes;
+      p.virtualListHelper.addItemsAt(data.length, at);
 
       if (that.o.virtualTable) {
-
-        while (p.tbody.firstChild) {
-          this.trigger('rowdestroy', p.tbody.firstChild);
-          this._unbindCellEventsForRow(p.tbody.firstChild);
-          p.tbody.removeChild(p.tbody.firstChild);
-        }
-
-        this._calculateVirtualHeight() // Calculate virtual height
-        ._updateLastCellWidthFromScrollbar() // Detect vertical scrollbar height
+        this._updateVirtualHeight().
+        _updateLastCellWidthFromScrollbar() // Detect vertical scrollbar height
         .render().
         _updateTableWidth(false); // Update table width to suit the required width considering vertical scrollbar
 
-      } else if (p.$tbody) {
-
-        let firstRow = at,
-          lastRow = at + data.length - 1;
-
-        let renderedRows = that.renderRows(firstRow, lastRow);
-        p.tbody.insertBefore(renderedRows, childNodes[at] || null);
-
-        for (let i = lastRow + 1; i < childNodes.length; i++) {
-          let row = childNodes[i];
-          row['rowIndex'] += data.length;
-          row['physicalRowIndex'] += data.length;
-        }
-
+      } else if (p.tbody) {
         this.render().
         _updateLastCellWidthFromScrollbar() // Detect vertical scrollbar height, and update existing last cells
         ._updateTableWidth(true); // Update table width to suit the required width considering vertical scrollbar
-
       }
     }
 
@@ -4124,9 +5316,9 @@ DGTable.prototype.addRows = function (data, at, resort, render) {
  * Removes a row from the table
  * @public
  * @expose
- * @param {Number} physicalRowIndex - index
- * @param {Number} count - how many rows to remove
- * @param {Boolean=true} render
+ * @param {number} physicalRowIndex - index
+ * @param {number} count - how many rows to remove
+ * @param {boolean=true} render
  * @returns {DGTable} self
  */
 DGTable.prototype.removeRows = function (physicalRowIndex, count, render) {
@@ -4152,49 +5344,19 @@ DGTable.prototype.removeRows = function (physicalRowIndex, count, render) {
     }
 
   } else if (render) {
-
-    let childNodes = p.tbody.childNodes;
+    p.virtualListHelper.removeItemsAt(count, physicalRowIndex);
 
     if (this.o.virtualTable) {
-
-      while (p.tbody.firstChild) {
-        this.trigger('rowdestroy', p.tbody.firstChild);
-        this._unbindCellEventsForRow(p.tbody.firstChild);
-        p.tbody.removeChild(p.tbody.firstChild);
-      }
-
-      this._calculateVirtualHeight().
+      this._updateVirtualHeight().
       _updateLastCellWidthFromScrollbar().
       render().
       _updateTableWidth(false); // Update table width to suit the required width considering vertical scrollbar
 
 
     } else {
-
-      let lastRowIndex = physicalRowIndex + count - 1;
-
-      for (let i = 0; i < childNodes.length; i++) {
-        let row = childNodes[i];
-        let index = row['physicalRowIndex'];
-
-        if (index >= physicalRowIndex) {
-          if (index <= lastRowIndex) {
-            this.trigger('rowdestroy', row);
-            this._unbindCellEventsForRow(row);
-            p.tbody.removeChild(row);
-            i--;
-          } else {
-            row['physicalRowIndex'] -= count;
-          }
-        } else {
-          row['rowIndex'] = i;
-        }
-      }
-
       this.render().
       _updateLastCellWidthFromScrollbar().
       _updateTableWidth(true); // Update table width to suit the required width considering vertical scrollbar
-
     }
   }
 
@@ -4205,8 +5367,8 @@ DGTable.prototype.removeRows = function (physicalRowIndex, count, render) {
  * Removes a row from the table
  * @public
  * @expose
- * @param {Number} physicalRowIndex - index
- * @param {Boolean=true} render
+ * @param {number} physicalRowIndex - index
+ * @param {boolean=true} render
  * @returns {DGTable} self
  */
 DGTable.prototype.removeRow = function (physicalRowIndex, render) {
@@ -4217,7 +5379,7 @@ DGTable.prototype.removeRow = function (physicalRowIndex, render) {
  * Refreshes the row specified
  * @public
  * @expose
- * @param {Number} physicalRowIndex index
+ * @param {number} physicalRowIndex index
  * @returns {DGTable} self
  */
 DGTable.prototype.refreshRow = function (physicalRowIndex) {
@@ -4234,34 +5396,7 @@ DGTable.prototype.refreshRow = function (physicalRowIndex) {
     rowIndex = physicalRowIndex;
   }
 
-  let childNodes = p.tbody.childNodes;
-
-  if (this.o.virtualTable) {
-    // Now make sure that the row actually rendered, as this is a virtual table
-    let isRowVisible = false;
-    let i = 0;
-
-    for (; i < childNodes.length; i++) {
-      if (childNodes[i]['physicalRowIndex'] === physicalRowIndex) {
-        isRowVisible = true;
-        this.trigger('rowdestroy', childNodes[i]);
-        this._unbindCellEventsForRow(childNodes[i]);
-        p.tbody.removeChild(childNodes[i]);
-        break;
-      }
-    }
-
-    if (isRowVisible) {
-      let renderedRow = this.renderRows(rowIndex, rowIndex);
-      p.tbody.insertBefore(renderedRow, childNodes[i] || null);
-    }
-  } else {
-    this.trigger('rowdestroy', childNodes[rowIndex]);
-    this._unbindCellEventsForRow(childNodes[rowIndex]);
-    p.tbody.removeChild(childNodes[rowIndex]);
-    let renderedRow = this.renderRows(rowIndex, rowIndex);
-    p.tbody.insertBefore(renderedRow, childNodes[rowIndex] || null);
-  }
+  p.virtualListHelper.refreshItemAt(rowIndex);
 
   return this;
 };
@@ -4270,7 +5405,7 @@ DGTable.prototype.refreshRow = function (physicalRowIndex) {
  * Get the DOM element for the specified row, if it exists
  * @public
  * @expose
- * @param {Number} physicalRowIndex index
+ * @param {number} physicalRowIndex index
  * @returns {Element|null} row or null
  */
 DGTable.prototype.getRowElement = function (physicalRowIndex) {
@@ -4287,20 +5422,7 @@ DGTable.prototype.getRowElement = function (physicalRowIndex) {
     rowIndex = physicalRowIndex;
   }
 
-  let childNodes = p.tbody.childNodes;
-
-  if (this.o.virtualTable) {
-    // Now make sure that the row actually rendered, as this is a virtual table
-    for (let i = 0; i < childNodes.length; i++) {
-      if (childNodes[i]['physicalRowIndex'] === physicalRowIndex) {
-        return childNodes[i];
-      }
-    }
-  } else {
-    return childNodes[rowIndex];
-  }
-
-  return null;
+  return p.virtualListHelper.getItemElementAt(rowIndex) || null;
 };
 
 /**
@@ -4310,29 +5432,8 @@ DGTable.prototype.getRowElement = function (physicalRowIndex) {
  * @returns {DGTable} self
  */
 DGTable.prototype.refreshAllVirtualRows = function () {
-
   const p = this.p;
-
-  if (this.o.virtualTable) {
-    // Now make sure that the row actually rendered, as this is a virtual table
-    let rowsToRender = [];
-    let childNodes = p.tbody.childNodes;
-
-    for (let i = 0, rowCount = childNodes.length; i < rowCount; i++) {
-      rowsToRender.push(childNodes[i]['physicalRowIndex']);
-      this.trigger('rowdestroy', childNodes[i]);
-      this._unbindCellEventsForRow(childNodes[i]);
-      p.tbody.removeChild(childNodes[i]);
-      i--;
-      rowCount--;
-    }
-
-    for (let i = 0; i < rowsToRender.length; i++) {
-      let renderedRow = this.renderRows(rowsToRender[i], rowsToRender[i]);
-      p.tbody.appendChild(renderedRow);
-    }
-  }
-
+  p.virtualListHelper.invalidate().render();
   return this;
 };
 
@@ -4341,7 +5442,7 @@ DGTable.prototype.refreshAllVirtualRows = function () {
  * @public
  * @expose
  * @param {Object[]} data array of rows to add to the table
- * @param {Boolean} [resort=false] should resort all rows?
+ * @param {boolean} [resort=false] should resort all rows?
  * @returns {DGTable} self
  */
 DGTable.prototype.setRows = function (data, resort) {
@@ -4369,7 +5470,7 @@ DGTable.prototype.setRows = function (data, resort) {
  * @public
  * @expose
  * @param {string} id Id of the element containing your data
- * @returns {String|null} the url, or null if not supported
+ * @returns {string|null} the url, or null if not supported
  */
 DGTable.prototype.getUrlForElementContent = function (id) {
   let blob,
@@ -4395,7 +5496,7 @@ DGTable.prototype.getUrlForElementContent = function (id) {
 /**
  * @public
  * @expose
- * @returns {Boolean} A value indicating whether Web Workers are supported
+ * @returns {boolean} A value indicating whether Web Workers are supported
  */
 DGTable.prototype.isWorkerSupported = function () {
   return window['Worker'] instanceof Function;
@@ -4490,10 +5591,6 @@ DGTable.prototype.cancelColumnResize = function () {
   return this;
 };
 
-DGTable.prototype._onVirtualTableScrolled = function () {
-  this.render();
-};
-
 DGTable.prototype._onTableScrolledHorizontally = function () {
   const p = this.p;
 
@@ -4504,7 +5601,7 @@ DGTable.prototype._onTableScrolledHorizontally = function () {
  * Reverse-calculate the column to resize from mouse position
  * @private
  * @param {jQuery_Event} e jQuery mouse event
- * @returns {String} name of the column which the mouse is over, or null if the mouse is not in resize position
+ * @returns {string} name of the column which the mouse is over, or null if the mouse is not in resize position
  */
 DGTable.prototype._getColumnByResizePosition = function (e) {
 
@@ -5085,12 +6182,12 @@ DGTable.prototype._clearSortArrows = function () {
     let tableClassName = this.o.tableClassName;
     let sortedColumns = p.$headerRow.find('>div.' + tableClassName + '-header-cell.sorted');
     let arrows = sortedColumns.find('>div>.sort-arrow');
-    for (let arrow of arrows) {
+    arrows.each((_, arrow) => {
       let col = p.columns.get(arrow.parentNode.parentNode['columnName']);
       if (col) {
         col.arrowProposedWidth = 0;
       }
-    }
+    });
     arrows.remove();
     sortedColumns.removeClass('sorted').removeClass('desc');
   }
@@ -5099,8 +6196,8 @@ DGTable.prototype._clearSortArrows = function () {
 
 /**
  * @private
- * @param {String} column the name of the sort column
- * @param {Boolean} descending table is sorted descending
+ * @param {string} column the name of the sort column
+ * @param {boolean} descending table is sorted descending
  * @returns {DGTable} self
  */
 DGTable.prototype._showSortArrow = function (column, descending) {
@@ -5128,7 +6225,7 @@ DGTable.prototype._showSortArrow = function (column, descending) {
 
 /**
  * @private
- * @param {Number} cellIndex index of the column in the DOM
+ * @param {number} cellIndex index of the column in the DOM
  * @returns {DGTable} self
  */
 DGTable.prototype._resizeColumnElements = function (cellIndex) {
@@ -5143,11 +6240,11 @@ DGTable.prototype._resizeColumnElements = function (cellIndex) {
     headerCells[cellIndex].style.width = (col.actualWidthConsideringScrollbarWidth || col.actualWidth) + 'px';
 
     let width = (col.actualWidthConsideringScrollbarWidth || col.actualWidth) + 'px';
-    let tbodyChildren = p.$tbody[0].childNodes;
+    let tbodyChildren = p.tbody.childNodes;
     for (let i = 0, count = tbodyChildren.length; i < count; i++) {
-      let headerRow = tbodyChildren[i];
-      if (headerRow.nodeType !== 1) continue;
-      headerRow.childNodes[cellIndex].style.width = width;
+      let rowEl = tbodyChildren[i];
+      if (rowEl.nodeType !== 1) continue;
+      rowEl.childNodes[cellIndex].style.width = width;
     }
   }
 
@@ -5176,22 +6273,18 @@ DGTable.prototype._destroyHeaderCells = function () {
  * @private
  * @returns {DGTable} self
  */
-DGTable.prototype._renderSkeletonBase = function () {
+DGTable.prototype._renderSkeletonBase = function () {var _p$virtualListHelper2;
   let that = this,
     p = that.p,
     o = that.o;
 
   // Clean up old elements
 
+  (_p$virtualListHelper2 = p.virtualListHelper) === null || _p$virtualListHelper2 === void 0 ? void 0 : _p$virtualListHelper2.destroy();
+  p.virtualListHelper = null;
+
   if (p.$table && o.virtualTable) {
     p.$table.remove();
-    if (p.$tbody) {
-      let rows = p.$tbody[0].childNodes;
-      for (let i = 0, len = rows.length; i < len; i++) {
-        that.trigger('rowdestroy', rows[i]);
-        that._unbindCellEventsForRow(rows[i]);
-      }
-    }
     p.$table = p.table = p.$tbody = p.tbody = null;
   }
 
@@ -5324,44 +6417,6 @@ DGTable.prototype._renderSkeletonBody = function () {
 
   let tableClassName = o.tableClassName;
 
-  // Calculate virtual row heights
-  if (o.virtualTable && !p.virtualRowHeight) {
-    let createDummyRow = function () {
-      let row = createElement('div'),
-        cell = row.appendChild(createElement('div')),
-        cellInner = cell.appendChild(createElement('div'));
-      row.className = tableClassName + '-row';
-      cell.className = tableClassName + '-cell';
-      cellInner.innerHTML = '0';
-      row.style.visibility = 'hidden';
-      row.style.position = 'absolute';
-      return row;
-    };
-
-    let $dummyTbody,$dummyWrapper = $('<div>').
-      addClass(that.el.className).
-      css({ 'z-index': -1, 'position': 'absolute', left: '0', top: '-9999px', width: '1px', overflow: 'hidden' }).
-      append(
-      $('<div>').addClass(tableClassName).append(
-      $dummyTbody = $('<div>').addClass(tableClassName + '-body').css('width', 99999)));
-
-
-
-    $dummyWrapper.appendTo(document.body);
-
-    let row1 = createDummyRow(),row2 = createDummyRow(),row3 = createDummyRow();
-    $dummyTbody.append(row1, row2, row3);
-
-    p.virtualRowHeightFirst = Css.getElementHeight(row1, true, true, true);
-    p.virtualRowHeight = Css.getElementHeight(row2, true, true, true);
-    p.virtualRowHeightLast = Css.getElementHeight(row3, true, true, true);
-
-    p.virtualRowHeightMin = Math.min(Math.min(p.virtualRowHeightFirst, p.virtualRowHeight), p.virtualRowHeightLast);
-    p.virtualRowHeightMax = Math.max(Math.max(p.virtualRowHeightFirst, p.virtualRowHeight), p.virtualRowHeightLast);
-
-    $dummyWrapper.remove();
-  }
-
   // Create inner table and tbody
   if (!p.$table) {
 
@@ -5394,22 +6449,19 @@ DGTable.prototype._renderSkeletonBody = function () {
     let tbody = createElement('div');
     let $tbody = $(tbody);
     tbody.className = o.tableClassName + '-body';
+    tbody.style.minHeight = '1px';
     p.table = table;
     p.tbody = tbody;
     p.$table = $table;
     p.$tbody = $tbody;
 
-    if (o.virtualTable) {
-      p.virtualVisibleRows = Math.ceil(p.visibleHeight / p.virtualRowHeightMin);
-    }
-
-    that._calculateVirtualHeight();
-
     relativizeElement($tbody);
     relativizeElement($table);
 
     table.appendChild(tbody);
     that.el.appendChild(fragment);
+
+    this._setupVirtualTable();
   }
 
   return this;
@@ -5424,6 +6476,25 @@ DGTable.prototype._renderSkeleton = function () {
   return this;
 };
 
+/**
+ * @private
+ * @returns {DGTable} self
+ */
+DGTable.prototype._updateVirtualHeight = function () {
+  const o = this.o,p = this.p;
+
+  if (!p.tbody)
+  return this;
+
+  if (o.virtualTable) {
+    p.tbody.style.height = p.virtualListHelper.estimateFullHeight() + 'px';
+  } else {
+    p.tbody.style.height = '';
+  }
+
+  return this;
+};
+
 /**
  * @private
  * @returns {DGTable} self
@@ -5434,7 +6505,7 @@ DGTable.prototype._updateLastCellWidthFromScrollbar = function (force) {
 
   // Calculate scrollbar's width and reduce from lat column's width
   let scrollbarWidth = p.table.offsetWidth - p.table.clientWidth;
-  if (scrollbarWidth !== p.scrollbarWidth || force) {
+  if (scrollbarWidth !== p.scrollbarWidth || force) {var _p$notifyRendererOfCo3;
     p.scrollbarWidth = scrollbarWidth;
     for (let i = 0; i < p.columns.length; i++) {
       p.columns[i].actualWidthConsideringScrollbarWidth = null;
@@ -5455,7 +6526,10 @@ DGTable.prototype._updateLastCellWidthFromScrollbar = function (force) {
 
       p.headerRow.childNodes[lastColIndex].style.width = lastColWidth;
     }
+
+    (_p$notifyRendererOfCo3 = p.notifyRendererOfColumnsConfig) === null || _p$notifyRendererOfCo3 === void 0 ? void 0 : _p$notifyRendererOfCo3.call(p);
   }
+
   return this;
 };
 
@@ -5477,7 +6551,7 @@ DGTable.prototype._updateTableWidth = function (parentSizeMayHaveChanged) {
   if (o.width === DGTable.Width.AUTO) {
     // Update wrapper element's size to fully contain the table body
 
-    Css.setElementWidth(p.$table[0], Css.getElementWidth(p.$tbody[0], true, true, true));
+    Css.setElementWidth(p.$table[0], Css.getElementWidth(p.tbody, true, true, true));
     Css.setElementWidth(this.$el[0], Css.getElementWidth(p.$table[0], true, true, true));
 
   } else if (o.width === DGTable.Width.SCROLL) {
@@ -5502,7 +6576,7 @@ DGTable.prototype._updateTableWidth = function (parentSizeMayHaveChanged) {
 
 /**
  * @private
- * @returns {Boolean}
+ * @returns {boolean}
  */
 DGTable.prototype._isTableRtl = function () {
   return this.p.$table.css('direction') === 'rtl';
@@ -5511,7 +6585,7 @@ DGTable.prototype._isTableRtl = function () {
 /**
  * @private
  * @param {Object} column column object
- * @returns {String}
+ * @returns {string}
  */
 DGTable.prototype._serializeColumnWidth = function (column) {
   return column.widthMode === ColumnWidthMode.AUTO ? 'auto' :
@@ -5797,15 +6871,15 @@ DGTable.prototype.hideCellPreview = function () {
 
 /**
  * @typedef {Object} SERIALIZED_COLUMN
- * @property {Number|null|undefined} [order=0]
- * @property {String|null|undefined} [width='auto']
- * @property {Boolean|null|undefined} [visible=true]
+ * @property {number|null|undefined} [order=0]
+ * @property {string|null|undefined} [width='auto']
+ * @property {boolean|null|undefined} [visible=true]
  * */
 
 /**
  * @typedef {Object} SERIALIZED_COLUMN_SORT
- * @property {String|null|undefined} [column='']
- * @property {Boolean|null|undefined} [descending=false]
+ * @property {string|null|undefined} [column='']
+ * @property {boolean|null|undefined} [descending=false]
  * */
 
 /**
@@ -5820,7 +6894,7 @@ const ColumnWidthMode = {
 };
 
 /**
- * @enum {DGTable.Width|String|undefined}
+ * @enum {DGTable.Width|string|undefined}
  * @const
  * @typedef {DGTable.Width}
  */
@@ -5833,57 +6907,58 @@ DGTable.Width = {
 /**
  * @expose
  * @typedef {Object} COLUMN_SORT_OPTIONS
- * @property {String|null|undefined} column
- * @property {Boolean|null|undefined} [descending=false]
+ * @property {string|null|undefined} column
+ * @property {boolean|null|undefined} [descending=false]
  * */
 
 /**
  * @expose
  * @typedef {Object} COLUMN_OPTIONS
- * @property {String|null|undefined} width
- * @property {String|null|undefined} name
- * @property {String|null|undefined} label
- * @property {String|null|undefined} dataPath - defaults to `name`
- * @property {String|null|undefined} comparePath - defaults to `dataPath`
- * @property {Number|String|null|undefined} comparePath
- * @property {Boolean|null|undefined} [resizable=true]
- * @property {Boolean|null|undefined} [movable=true]
- * @property {Boolean|null|undefined} [sortable=true]
- * @property {Boolean|null|undefined} [visible=true]
- * @property {String|null|undefined} [cellClasses]
- * @property {Boolean|null|undefined} [ignoreMin=false]
+ * @property {string|null|undefined} width
+ * @property {string|null|undefined} name
+ * @property {string|null|undefined} label
+ * @property {string|null|undefined} dataPath - defaults to `name`
+ * @property {string|null|undefined} comparePath - defaults to `dataPath`
+ * @property {number|string|null|undefined} comparePath
+ * @property {boolean|null|undefined} [resizable=true]
+ * @property {boolean|null|undefined} [movable=true]
+ * @property {boolean|null|undefined} [sortable=true]
+ * @property {boolean|null|undefined} [visible=true]
+ * @property {string|null|undefined} [cellClasses]
+ * @property {boolean|null|undefined} [ignoreMin=false]
  * */
 
 /**
  * @typedef {Object} DGTable.Options
  * @property {COLUMN_OPTIONS[]} [columns]
- * @property {Number} [height]
+ * @property {number} [height]
  * @property {DGTable.Width} [width]
- * @property {Boolean|null|undefined} [virtualTable=true]
- * @property {Boolean|null|undefined} [resizableColumns=true]
- * @property {Boolean|null|undefined} [movableColumns=true]
- * @property {Number|null|undefined} [sortableColumns=1]
- * @property {Boolean|null|undefined} [adjustColumnWidthForSortArrow=true]
- * @property {Boolean|null|undefined} [relativeWidthGrowsToFillWidth=true]
- * @property {Boolean|null|undefined} [relativeWidthShrinksToFillWidth=false]
- * @property {Boolean|null|undefined} [convertColumnWidthsToRelative=false]
- * @property {Boolean|null|undefined} [autoFillTableWidth=false]
- * @property {String|null|undefined} [cellClasses]
- * @property {String|String[]|COLUMN_SORT_OPTIONS|COLUMN_SORT_OPTIONS[]} [sortColumn]
+ * @property {boolean|null|undefined} [virtualTable=true]
+ * @property {number|null|undefined} [estimatedRowHeight=40]
+ * @property {boolean|null|undefined} [resizableColumns=true]
+ * @property {boolean|null|undefined} [movableColumns=true]
+ * @property {number|null|undefined} [sortableColumns=1]
+ * @property {boolean|null|undefined} [adjustColumnWidthForSortArrow=true]
+ * @property {boolean|null|undefined} [relativeWidthGrowsToFillWidth=true]
+ * @property {boolean|null|undefined} [relativeWidthShrinksToFillWidth=false]
+ * @property {boolean|null|undefined} [convertColumnWidthsToRelative=false]
+ * @property {boolean|null|undefined} [autoFillTableWidth=false]
+ * @property {string|null|undefined} [cellClasses]
+ * @property {string|string[]|COLUMN_SORT_OPTIONS|COLUMN_SORT_OPTIONS[]} [sortColumn]
  * @property {Function|null|undefined} [cellFormatter=null]
  * @property {Function|null|undefined} [headerCellFormatter=null]
- * @property {Number|null|undefined} [rowsBufferSize=10]
- * @property {Number|null|undefined} [minColumnWidth=35]
- * @property {Number|null|undefined} [resizeAreaWidth=8]
+ * @property {number|null|undefined} [rowsBufferSize=10]
+ * @property {number|null|undefined} [minColumnWidth=35]
+ * @property {number|null|undefined} [resizeAreaWidth=8]
  * @property {{function(string,boolean):{function(a:*,b:*):boolean}}} [onComparatorRequired]
- * @property {String|null|undefined} [resizerClassName=undefined]
- * @property {String|null|undefined} [tableClassName=undefined]
- * @property {Boolean|null|undefined} [allowCellPreview=true]
- * @property {Boolean|null|undefined} [allowHeaderCellPreview=true]
- * @property {String|null|undefined} [cellPreviewClassName=undefined]
- * @property {Boolean|null|undefined} [cellPreviewAutoBackground=true]
+ * @property {string|null|undefined} [resizerClassName=undefined]
+ * @property {string|null|undefined} [tableClassName=undefined]
+ * @property {boolean|null|undefined} [allowCellPreview=true]
+ * @property {boolean|null|undefined} [allowHeaderCellPreview=true]
+ * @property {string|null|undefined} [cellPreviewClassName=undefined]
+ * @property {boolean|null|undefined} [cellPreviewAutoBackground=true]
  * @property {Element|null|undefined} [el=undefined]
- * @property {String|null|undefined} [className=undefined]
+ * @property {string|null|undefined} [className=undefined]
  * @property {Function|null|undefined} [filter=undefined]
  * */
 
@@ -5892,13 +6967,13 @@ DGTable.Width = {
      *  currentTarget: Element,
      *  data: Object.<string, *>,
      *  delegateTarget: Element,
-     *  isDefaultPrevented: Boolean,
-     *  isImmediatePropagationStopped: Boolean,
-     *  isPropagationStopped: Boolean,
+     *  isDefaultPrevented: boolean,
+     *  isImmediatePropagationStopped: boolean,
+     *  isPropagationStopped: boolean,
      *  namespace: string,
      *  originalEvent: MouseEvent|TouchEvent|Event,
-     *  pageX: Number,
-     *  pageY: Number,
+     *  pageX: number,
+     *  pageY: number,
      *  preventDefault: Function,
      *  props: Object.<string, *>,
      *  relatedTarget: Element,
@@ -5906,9 +6981,9 @@ DGTable.Width = {
      *  stopImmediatePropagation: Function,
      *  stopPropagation: Function,
      *  target: Element,
-     *  timeStamp: Number,
+     *  timeStamp: number,
      *  type: string,
-     *  which: Number
+     *  which: number
      * }} jQuery_Event
  * */