jquery.dgtable 0.6.19 → 2.0.1

package/dist/lib.cjs.js

@@ -0,0 +1,3935 @@
+'use strict';
+
+var jQuery = require('jquery');
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var es_symbol_description = {};
+
+var globalThis_1;
+var hasRequiredGlobalThis;
+
+function requireGlobalThis () {
+	if (hasRequiredGlobalThis) return globalThis_1;
+	hasRequiredGlobalThis = 1;
+	var check = function (it) {
+	  return it && it.Math === Math && it;
+	};
+
+	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+	globalThis_1 =
+	  // eslint-disable-next-line es/no-global-this -- safe
+	  check(typeof globalThis == 'object' && globalThis) ||
+	  check(typeof window == 'object' && window) ||
+	  // eslint-disable-next-line no-restricted-globals -- safe
+	  check(typeof self == 'object' && self) ||
+	  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+	  check(typeof globalThis_1 == 'object' && globalThis_1) ||
+	  // eslint-disable-next-line no-new-func -- fallback
+	  (function () { return this; })() || Function('return this')();
+	return globalThis_1;
+}
+
+var objectGetOwnPropertyDescriptor = {};
+
+var fails;
+var hasRequiredFails;
+
+function requireFails () {
+	if (hasRequiredFails) return fails;
+	hasRequiredFails = 1;
+	fails = function (exec) {
+	  try {
+	    return !!exec();
+	  } catch (error) {
+	    return true;
+	  }
+	};
+	return fails;
+}
+
+var descriptors;
+var hasRequiredDescriptors;
+
+function requireDescriptors () {
+	if (hasRequiredDescriptors) return descriptors;
+	hasRequiredDescriptors = 1;
+	var fails = requireFails();
+
+	// Detect IE8's incomplete defineProperty implementation
+	descriptors = !fails(function () {
+	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+	  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
+	});
+	return descriptors;
+}
+
+var functionBindNative;
+var hasRequiredFunctionBindNative;
+
+function requireFunctionBindNative () {
+	if (hasRequiredFunctionBindNative) return functionBindNative;
+	hasRequiredFunctionBindNative = 1;
+	var fails = requireFails();
+
+	functionBindNative = !fails(function () {
+	  // eslint-disable-next-line es/no-function-prototype-bind -- safe
+	  var test = (function () { /* empty */ }).bind();
+	  // eslint-disable-next-line no-prototype-builtins -- safe
+	  return typeof test != 'function' || test.hasOwnProperty('prototype');
+	});
+	return functionBindNative;
+}
+
+var functionCall;
+var hasRequiredFunctionCall;
+
+function requireFunctionCall () {
+	if (hasRequiredFunctionCall) return functionCall;
+	hasRequiredFunctionCall = 1;
+	var NATIVE_BIND = requireFunctionBindNative();
+
+	var call = Function.prototype.call;
+	// eslint-disable-next-line es/no-function-prototype-bind -- safe
+	functionCall = NATIVE_BIND ? call.bind(call) : function () {
+	  return call.apply(call, arguments);
+	};
+	return functionCall;
+}
+
+var objectPropertyIsEnumerable = {};
+
+var hasRequiredObjectPropertyIsEnumerable;
+
+function requireObjectPropertyIsEnumerable () {
+	if (hasRequiredObjectPropertyIsEnumerable) return objectPropertyIsEnumerable;
+	hasRequiredObjectPropertyIsEnumerable = 1;
+	var $propertyIsEnumerable = {}.propertyIsEnumerable;
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+	// Nashorn ~ JDK8 bug
+	var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+
+	// `Object.prototype.propertyIsEnumerable` method implementation
+	// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+	objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+	  var descriptor = getOwnPropertyDescriptor(this, V);
+	  return !!descriptor && descriptor.enumerable;
+	} : $propertyIsEnumerable;
+	return objectPropertyIsEnumerable;
+}
+
+var createPropertyDescriptor;
+var hasRequiredCreatePropertyDescriptor;
+
+function requireCreatePropertyDescriptor () {
+	if (hasRequiredCreatePropertyDescriptor) return createPropertyDescriptor;
+	hasRequiredCreatePropertyDescriptor = 1;
+	createPropertyDescriptor = function (bitmap, value) {
+	  return {
+	    enumerable: !(bitmap & 1),
+	    configurable: !(bitmap & 2),
+	    writable: !(bitmap & 4),
+	    value: value
+	  };
+	};
+	return createPropertyDescriptor;
+}
+
+var functionUncurryThis;
+var hasRequiredFunctionUncurryThis;
+
+function requireFunctionUncurryThis () {
+	if (hasRequiredFunctionUncurryThis) return functionUncurryThis;
+	hasRequiredFunctionUncurryThis = 1;
+	var NATIVE_BIND = requireFunctionBindNative();
+
+	var FunctionPrototype = Function.prototype;
+	var call = FunctionPrototype.call;
+	// eslint-disable-next-line es/no-function-prototype-bind -- safe
+	var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+
+	functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
+	  return function () {
+	    return call.apply(fn, arguments);
+	  };
+	};
+	return functionUncurryThis;
+}
+
+var classofRaw;
+var hasRequiredClassofRaw;
+
+function requireClassofRaw () {
+	if (hasRequiredClassofRaw) return classofRaw;
+	hasRequiredClassofRaw = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	var toString = uncurryThis({}.toString);
+	var stringSlice = uncurryThis(''.slice);
+
+	classofRaw = function (it) {
+	  return stringSlice(toString(it), 8, -1);
+	};
+	return classofRaw;
+}
+
+var indexedObject;
+var hasRequiredIndexedObject;
+
+function requireIndexedObject () {
+	if (hasRequiredIndexedObject) return indexedObject;
+	hasRequiredIndexedObject = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var fails = requireFails();
+	var classof = requireClassofRaw();
+
+	var $Object = Object;
+	var split = uncurryThis(''.split);
+
+	// fallback for non-array-like ES3 and non-enumerable old V8 strings
+	indexedObject = fails(function () {
+	  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+	  // eslint-disable-next-line no-prototype-builtins -- safe
+	  return !$Object('z').propertyIsEnumerable(0);
+	}) ? function (it) {
+	  return classof(it) === 'String' ? split(it, '') : $Object(it);
+	} : $Object;
+	return indexedObject;
+}
+
+var isNullOrUndefined;
+var hasRequiredIsNullOrUndefined;
+
+function requireIsNullOrUndefined () {
+	if (hasRequiredIsNullOrUndefined) return isNullOrUndefined;
+	hasRequiredIsNullOrUndefined = 1;
+	// we can't use just `it == null` since of `document.all` special case
+	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+	isNullOrUndefined = function (it) {
+	  return it === null || it === undefined;
+	};
+	return isNullOrUndefined;
+}
+
+var requireObjectCoercible;
+var hasRequiredRequireObjectCoercible;
+
+function requireRequireObjectCoercible () {
+	if (hasRequiredRequireObjectCoercible) return requireObjectCoercible;
+	hasRequiredRequireObjectCoercible = 1;
+	var isNullOrUndefined = requireIsNullOrUndefined();
+
+	var $TypeError = TypeError;
+
+	// `RequireObjectCoercible` abstract operation
+	// https://tc39.es/ecma262/#sec-requireobjectcoercible
+	requireObjectCoercible = function (it) {
+	  if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
+	  return it;
+	};
+	return requireObjectCoercible;
+}
+
+var toIndexedObject;
+var hasRequiredToIndexedObject;
+
+function requireToIndexedObject () {
+	if (hasRequiredToIndexedObject) return toIndexedObject;
+	hasRequiredToIndexedObject = 1;
+	// toObject with fallback for non-array-like ES3 strings
+	var IndexedObject = requireIndexedObject();
+	var requireObjectCoercible = requireRequireObjectCoercible();
+
+	toIndexedObject = function (it) {
+	  return IndexedObject(requireObjectCoercible(it));
+	};
+	return toIndexedObject;
+}
+
+var isCallable;
+var hasRequiredIsCallable;
+
+function requireIsCallable () {
+	if (hasRequiredIsCallable) return isCallable;
+	hasRequiredIsCallable = 1;
+	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+	var documentAll = typeof document == 'object' && document.all;
+
+	// `IsCallable` abstract operation
+	// https://tc39.es/ecma262/#sec-iscallable
+	// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+	isCallable = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
+	  return typeof argument == 'function' || argument === documentAll;
+	} : function (argument) {
+	  return typeof argument == 'function';
+	};
+	return isCallable;
+}
+
+var isObject;
+var hasRequiredIsObject;
+
+function requireIsObject () {
+	if (hasRequiredIsObject) return isObject;
+	hasRequiredIsObject = 1;
+	var isCallable = requireIsCallable();
+
+	isObject = function (it) {
+	  return typeof it == 'object' ? it !== null : isCallable(it);
+	};
+	return isObject;
+}
+
+var getBuiltIn;
+var hasRequiredGetBuiltIn;
+
+function requireGetBuiltIn () {
+	if (hasRequiredGetBuiltIn) return getBuiltIn;
+	hasRequiredGetBuiltIn = 1;
+	var globalThis = requireGlobalThis();
+	var isCallable = requireIsCallable();
+
+	var aFunction = function (argument) {
+	  return isCallable(argument) ? argument : undefined;
+	};
+
+	getBuiltIn = function (namespace, method) {
+	  return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
+	};
+	return getBuiltIn;
+}
+
+var objectIsPrototypeOf;
+var hasRequiredObjectIsPrototypeOf;
+
+function requireObjectIsPrototypeOf () {
+	if (hasRequiredObjectIsPrototypeOf) return objectIsPrototypeOf;
+	hasRequiredObjectIsPrototypeOf = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	objectIsPrototypeOf = uncurryThis({}.isPrototypeOf);
+	return objectIsPrototypeOf;
+}
+
+var environmentUserAgent;
+var hasRequiredEnvironmentUserAgent;
+
+function requireEnvironmentUserAgent () {
+	if (hasRequiredEnvironmentUserAgent) return environmentUserAgent;
+	hasRequiredEnvironmentUserAgent = 1;
+	var globalThis = requireGlobalThis();
+
+	var navigator = globalThis.navigator;
+	var userAgent = navigator && navigator.userAgent;
+
+	environmentUserAgent = userAgent ? String(userAgent) : '';
+	return environmentUserAgent;
+}
+
+var environmentV8Version;
+var hasRequiredEnvironmentV8Version;
+
+function requireEnvironmentV8Version () {
+	if (hasRequiredEnvironmentV8Version) return environmentV8Version;
+	hasRequiredEnvironmentV8Version = 1;
+	var globalThis = requireGlobalThis();
+	var userAgent = requireEnvironmentUserAgent();
+
+	var process = globalThis.process;
+	var Deno = globalThis.Deno;
+	var versions = process && process.versions || Deno && Deno.version;
+	var v8 = versions && versions.v8;
+	var match, version;
+
+	if (v8) {
+	  match = v8.split('.');
+	  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+	  // but their correct versions are not interesting for us
+	  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+	}
+
+	// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+	// so check `userAgent` even if `.v8` exists, but 0
+	if (!version && userAgent) {
+	  match = userAgent.match(/Edge\/(\d+)/);
+	  if (!match || match[1] >= 74) {
+	    match = userAgent.match(/Chrome\/(\d+)/);
+	    if (match) version = +match[1];
+	  }
+	}
+
+	environmentV8Version = version;
+	return environmentV8Version;
+}
+
+var symbolConstructorDetection;
+var hasRequiredSymbolConstructorDetection;
+
+function requireSymbolConstructorDetection () {
+	if (hasRequiredSymbolConstructorDetection) return symbolConstructorDetection;
+	hasRequiredSymbolConstructorDetection = 1;
+	/* eslint-disable es/no-symbol -- required for testing */
+	var V8_VERSION = requireEnvironmentV8Version();
+	var fails = requireFails();
+	var globalThis = requireGlobalThis();
+
+	var $String = globalThis.String;
+
+	// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+	symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails(function () {
+	  var symbol = Symbol('symbol detection');
+	  // Chrome 38 Symbol has incorrect toString conversion
+	  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+	  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
+	  // of course, fail.
+	  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
+	    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+	    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+	});
+	return symbolConstructorDetection;
+}
+
+var useSymbolAsUid;
+var hasRequiredUseSymbolAsUid;
+
+function requireUseSymbolAsUid () {
+	if (hasRequiredUseSymbolAsUid) return useSymbolAsUid;
+	hasRequiredUseSymbolAsUid = 1;
+	/* eslint-disable es/no-symbol -- required for testing */
+	var NATIVE_SYMBOL = requireSymbolConstructorDetection();
+
+	useSymbolAsUid = NATIVE_SYMBOL &&
+	  !Symbol.sham &&
+	  typeof Symbol.iterator == 'symbol';
+	return useSymbolAsUid;
+}
+
+var isSymbol;
+var hasRequiredIsSymbol;
+
+function requireIsSymbol () {
+	if (hasRequiredIsSymbol) return isSymbol;
+	hasRequiredIsSymbol = 1;
+	var getBuiltIn = requireGetBuiltIn();
+	var isCallable = requireIsCallable();
+	var isPrototypeOf = requireObjectIsPrototypeOf();
+	var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
+
+	var $Object = Object;
+
+	isSymbol = USE_SYMBOL_AS_UID ? function (it) {
+	  return typeof it == 'symbol';
+	} : function (it) {
+	  var $Symbol = getBuiltIn('Symbol');
+	  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+	};
+	return isSymbol;
+}
+
+var tryToString;
+var hasRequiredTryToString;
+
+function requireTryToString () {
+	if (hasRequiredTryToString) return tryToString;
+	hasRequiredTryToString = 1;
+	var $String = String;
+
+	tryToString = function (argument) {
+	  try {
+	    return $String(argument);
+	  } catch (error) {
+	    return 'Object';
+	  }
+	};
+	return tryToString;
+}
+
+var aCallable;
+var hasRequiredACallable;
+
+function requireACallable () {
+	if (hasRequiredACallable) return aCallable;
+	hasRequiredACallable = 1;
+	var isCallable = requireIsCallable();
+	var tryToString = requireTryToString();
+
+	var $TypeError = TypeError;
+
+	// `Assert: IsCallable(argument) is true`
+	aCallable = function (argument) {
+	  if (isCallable(argument)) return argument;
+	  throw new $TypeError(tryToString(argument) + ' is not a function');
+	};
+	return aCallable;
+}
+
+var getMethod;
+var hasRequiredGetMethod;
+
+function requireGetMethod () {
+	if (hasRequiredGetMethod) return getMethod;
+	hasRequiredGetMethod = 1;
+	var aCallable = requireACallable();
+	var isNullOrUndefined = requireIsNullOrUndefined();
+
+	// `GetMethod` abstract operation
+	// https://tc39.es/ecma262/#sec-getmethod
+	getMethod = function (V, P) {
+	  var func = V[P];
+	  return isNullOrUndefined(func) ? undefined : aCallable(func);
+	};
+	return getMethod;
+}
+
+var ordinaryToPrimitive;
+var hasRequiredOrdinaryToPrimitive;
+
+function requireOrdinaryToPrimitive () {
+	if (hasRequiredOrdinaryToPrimitive) return ordinaryToPrimitive;
+	hasRequiredOrdinaryToPrimitive = 1;
+	var call = requireFunctionCall();
+	var isCallable = requireIsCallable();
+	var isObject = requireIsObject();
+
+	var $TypeError = TypeError;
+
+	// `OrdinaryToPrimitive` abstract operation
+	// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+	ordinaryToPrimitive = function (input, pref) {
+	  var fn, val;
+	  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+	  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
+	  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+	  throw new $TypeError("Can't convert object to primitive value");
+	};
+	return ordinaryToPrimitive;
+}
+
+var sharedStore = {exports: {}};
+
+var isPure;
+var hasRequiredIsPure;
+
+function requireIsPure () {
+	if (hasRequiredIsPure) return isPure;
+	hasRequiredIsPure = 1;
+	isPure = false;
+	return isPure;
+}
+
+var defineGlobalProperty;
+var hasRequiredDefineGlobalProperty;
+
+function requireDefineGlobalProperty () {
+	if (hasRequiredDefineGlobalProperty) return defineGlobalProperty;
+	hasRequiredDefineGlobalProperty = 1;
+	var globalThis = requireGlobalThis();
+
+	// eslint-disable-next-line es/no-object-defineproperty -- safe
+	var defineProperty = Object.defineProperty;
+
+	defineGlobalProperty = function (key, value) {
+	  try {
+	    defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
+	  } catch (error) {
+	    globalThis[key] = value;
+	  } return value;
+	};
+	return defineGlobalProperty;
+}
+
+var hasRequiredSharedStore;
+
+function requireSharedStore () {
+	if (hasRequiredSharedStore) return sharedStore.exports;
+	hasRequiredSharedStore = 1;
+	var IS_PURE = requireIsPure();
+	var globalThis = requireGlobalThis();
+	var defineGlobalProperty = requireDefineGlobalProperty();
+
+	var SHARED = '__core-js_shared__';
+	var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
+
+	(store.versions || (store.versions = [])).push({
+	  version: '3.47.0',
+	  mode: IS_PURE ? 'pure' : 'global',
+	  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru), 2025 CoreJS Company (core-js.io)',
+	  license: 'https://github.com/zloirock/core-js/blob/v3.47.0/LICENSE',
+	  source: 'https://github.com/zloirock/core-js'
+	});
+	return sharedStore.exports;
+}
+
+var shared;
+var hasRequiredShared;
+
+function requireShared () {
+	if (hasRequiredShared) return shared;
+	hasRequiredShared = 1;
+	var store = requireSharedStore();
+
+	shared = function (key, value) {
+	  return store[key] || (store[key] = value || {});
+	};
+	return shared;
+}
+
+var toObject;
+var hasRequiredToObject;
+
+function requireToObject () {
+	if (hasRequiredToObject) return toObject;
+	hasRequiredToObject = 1;
+	var requireObjectCoercible = requireRequireObjectCoercible();
+
+	var $Object = Object;
+
+	// `ToObject` abstract operation
+	// https://tc39.es/ecma262/#sec-toobject
+	toObject = function (argument) {
+	  return $Object(requireObjectCoercible(argument));
+	};
+	return toObject;
+}
+
+var hasOwnProperty_1;
+var hasRequiredHasOwnProperty;
+
+function requireHasOwnProperty () {
+	if (hasRequiredHasOwnProperty) return hasOwnProperty_1;
+	hasRequiredHasOwnProperty = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var toObject = requireToObject();
+
+	var hasOwnProperty = uncurryThis({}.hasOwnProperty);
+
+	// `HasOwnProperty` abstract operation
+	// https://tc39.es/ecma262/#sec-hasownproperty
+	// eslint-disable-next-line es/no-object-hasown -- safe
+	hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+	  return hasOwnProperty(toObject(it), key);
+	};
+	return hasOwnProperty_1;
+}
+
+var uid;
+var hasRequiredUid;
+
+function requireUid () {
+	if (hasRequiredUid) return uid;
+	hasRequiredUid = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	var id = 0;
+	var postfix = Math.random();
+	var toString = uncurryThis(1.1.toString);
+
+	uid = function (key) {
+	  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
+	};
+	return uid;
+}
+
+var wellKnownSymbol;
+var hasRequiredWellKnownSymbol;
+
+function requireWellKnownSymbol () {
+	if (hasRequiredWellKnownSymbol) return wellKnownSymbol;
+	hasRequiredWellKnownSymbol = 1;
+	var globalThis = requireGlobalThis();
+	var shared = requireShared();
+	var hasOwn = requireHasOwnProperty();
+	var uid = requireUid();
+	var NATIVE_SYMBOL = requireSymbolConstructorDetection();
+	var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
+
+	var Symbol = globalThis.Symbol;
+	var WellKnownSymbolsStore = shared('wks');
+	var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
+
+	wellKnownSymbol = function (name) {
+	  if (!hasOwn(WellKnownSymbolsStore, name)) {
+	    WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
+	      ? Symbol[name]
+	      : createWellKnownSymbol('Symbol.' + name);
+	  } return WellKnownSymbolsStore[name];
+	};
+	return wellKnownSymbol;
+}
+
+var toPrimitive;
+var hasRequiredToPrimitive;
+
+function requireToPrimitive () {
+	if (hasRequiredToPrimitive) return toPrimitive;
+	hasRequiredToPrimitive = 1;
+	var call = requireFunctionCall();
+	var isObject = requireIsObject();
+	var isSymbol = requireIsSymbol();
+	var getMethod = requireGetMethod();
+	var ordinaryToPrimitive = requireOrdinaryToPrimitive();
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var $TypeError = TypeError;
+	var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+
+	// `ToPrimitive` abstract operation
+	// https://tc39.es/ecma262/#sec-toprimitive
+	toPrimitive = function (input, pref) {
+	  if (!isObject(input) || isSymbol(input)) return input;
+	  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+	  var result;
+	  if (exoticToPrim) {
+	    if (pref === undefined) pref = 'default';
+	    result = call(exoticToPrim, input, pref);
+	    if (!isObject(result) || isSymbol(result)) return result;
+	    throw new $TypeError("Can't convert object to primitive value");
+	  }
+	  if (pref === undefined) pref = 'number';
+	  return ordinaryToPrimitive(input, pref);
+	};
+	return toPrimitive;
+}
+
+var toPropertyKey;
+var hasRequiredToPropertyKey;
+
+function requireToPropertyKey () {
+	if (hasRequiredToPropertyKey) return toPropertyKey;
+	hasRequiredToPropertyKey = 1;
+	var toPrimitive = requireToPrimitive();
+	var isSymbol = requireIsSymbol();
+
+	// `ToPropertyKey` abstract operation
+	// https://tc39.es/ecma262/#sec-topropertykey
+	toPropertyKey = function (argument) {
+	  var key = toPrimitive(argument, 'string');
+	  return isSymbol(key) ? key : key + '';
+	};
+	return toPropertyKey;
+}
+
+var documentCreateElement;
+var hasRequiredDocumentCreateElement;
+
+function requireDocumentCreateElement () {
+	if (hasRequiredDocumentCreateElement) return documentCreateElement;
+	hasRequiredDocumentCreateElement = 1;
+	var globalThis = requireGlobalThis();
+	var isObject = requireIsObject();
+
+	var document = globalThis.document;
+	// typeof document.createElement is 'object' in old IE
+	var EXISTS = isObject(document) && isObject(document.createElement);
+
+	documentCreateElement = function (it) {
+	  return EXISTS ? document.createElement(it) : {};
+	};
+	return documentCreateElement;
+}
+
+var ie8DomDefine;
+var hasRequiredIe8DomDefine;
+
+function requireIe8DomDefine () {
+	if (hasRequiredIe8DomDefine) return ie8DomDefine;
+	hasRequiredIe8DomDefine = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var fails = requireFails();
+	var createElement = requireDocumentCreateElement();
+
+	// Thanks to IE8 for its funny defineProperty
+	ie8DomDefine = !DESCRIPTORS && !fails(function () {
+	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+	  return Object.defineProperty(createElement('div'), 'a', {
+	    get: function () { return 7; }
+	  }).a !== 7;
+	});
+	return ie8DomDefine;
+}
+
+var hasRequiredObjectGetOwnPropertyDescriptor;
+
+function requireObjectGetOwnPropertyDescriptor () {
+	if (hasRequiredObjectGetOwnPropertyDescriptor) return objectGetOwnPropertyDescriptor;
+	hasRequiredObjectGetOwnPropertyDescriptor = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var call = requireFunctionCall();
+	var propertyIsEnumerableModule = requireObjectPropertyIsEnumerable();
+	var createPropertyDescriptor = requireCreatePropertyDescriptor();
+	var toIndexedObject = requireToIndexedObject();
+	var toPropertyKey = requireToPropertyKey();
+	var hasOwn = requireHasOwnProperty();
+	var IE8_DOM_DEFINE = requireIe8DomDefine();
+
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+	// `Object.getOwnPropertyDescriptor` method
+	// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+	objectGetOwnPropertyDescriptor.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+	  O = toIndexedObject(O);
+	  P = toPropertyKey(P);
+	  if (IE8_DOM_DEFINE) try {
+	    return $getOwnPropertyDescriptor(O, P);
+	  } catch (error) { /* empty */ }
+	  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+	};
+	return objectGetOwnPropertyDescriptor;
+}
+
+var objectDefineProperty = {};
+
+var v8PrototypeDefineBug;
+var hasRequiredV8PrototypeDefineBug;
+
+function requireV8PrototypeDefineBug () {
+	if (hasRequiredV8PrototypeDefineBug) return v8PrototypeDefineBug;
+	hasRequiredV8PrototypeDefineBug = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var fails = requireFails();
+
+	// V8 ~ Chrome 36-
+	// https://bugs.chromium.org/p/v8/issues/detail?id=3334
+	v8PrototypeDefineBug = DESCRIPTORS && fails(function () {
+	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+	  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
+	    value: 42,
+	    writable: false
+	  }).prototype !== 42;
+	});
+	return v8PrototypeDefineBug;
+}
+
+var anObject;
+var hasRequiredAnObject;
+
+function requireAnObject () {
+	if (hasRequiredAnObject) return anObject;
+	hasRequiredAnObject = 1;
+	var isObject = requireIsObject();
+
+	var $String = String;
+	var $TypeError = TypeError;
+
+	// `Assert: Type(argument) is Object`
+	anObject = function (argument) {
+	  if (isObject(argument)) return argument;
+	  throw new $TypeError($String(argument) + ' is not an object');
+	};
+	return anObject;
+}
+
+var hasRequiredObjectDefineProperty;
+
+function requireObjectDefineProperty () {
+	if (hasRequiredObjectDefineProperty) return objectDefineProperty;
+	hasRequiredObjectDefineProperty = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var IE8_DOM_DEFINE = requireIe8DomDefine();
+	var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
+	var anObject = requireAnObject();
+	var toPropertyKey = requireToPropertyKey();
+
+	var $TypeError = TypeError;
+	// eslint-disable-next-line es/no-object-defineproperty -- safe
+	var $defineProperty = Object.defineProperty;
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+	var ENUMERABLE = 'enumerable';
+	var CONFIGURABLE = 'configurable';
+	var WRITABLE = 'writable';
+
+	// `Object.defineProperty` method
+	// https://tc39.es/ecma262/#sec-object.defineproperty
+	objectDefineProperty.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+	  anObject(O);
+	  P = toPropertyKey(P);
+	  anObject(Attributes);
+	  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+	    var current = $getOwnPropertyDescriptor(O, P);
+	    if (current && current[WRITABLE]) {
+	      O[P] = Attributes.value;
+	      Attributes = {
+	        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+	        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+	        writable: false
+	      };
+	    }
+	  } return $defineProperty(O, P, Attributes);
+	} : $defineProperty : function defineProperty(O, P, Attributes) {
+	  anObject(O);
+	  P = toPropertyKey(P);
+	  anObject(Attributes);
+	  if (IE8_DOM_DEFINE) try {
+	    return $defineProperty(O, P, Attributes);
+	  } catch (error) { /* empty */ }
+	  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
+	  if ('value' in Attributes) O[P] = Attributes.value;
+	  return O;
+	};
+	return objectDefineProperty;
+}
+
+var createNonEnumerableProperty;
+var hasRequiredCreateNonEnumerableProperty;
+
+function requireCreateNonEnumerableProperty () {
+	if (hasRequiredCreateNonEnumerableProperty) return createNonEnumerableProperty;
+	hasRequiredCreateNonEnumerableProperty = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var definePropertyModule = requireObjectDefineProperty();
+	var createPropertyDescriptor = requireCreatePropertyDescriptor();
+
+	createNonEnumerableProperty = DESCRIPTORS ? function (object, key, value) {
+	  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+	} : function (object, key, value) {
+	  object[key] = value;
+	  return object;
+	};
+	return createNonEnumerableProperty;
+}
+
+var makeBuiltIn = {exports: {}};
+
+var functionName;
+var hasRequiredFunctionName;
+
+function requireFunctionName () {
+	if (hasRequiredFunctionName) return functionName;
+	hasRequiredFunctionName = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var hasOwn = requireHasOwnProperty();
+
+	var FunctionPrototype = Function.prototype;
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+
+	var EXISTS = hasOwn(FunctionPrototype, 'name');
+	// additional protection from minified / mangled / dropped function names
+	var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+	var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
+
+	functionName = {
+	  EXISTS: EXISTS,
+	  PROPER: PROPER,
+	  CONFIGURABLE: CONFIGURABLE
+	};
+	return functionName;
+}
+
+var inspectSource;
+var hasRequiredInspectSource;
+
+function requireInspectSource () {
+	if (hasRequiredInspectSource) return inspectSource;
+	hasRequiredInspectSource = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var isCallable = requireIsCallable();
+	var store = requireSharedStore();
+
+	var functionToString = uncurryThis(Function.toString);
+
+	// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+	if (!isCallable(store.inspectSource)) {
+	  store.inspectSource = function (it) {
+	    return functionToString(it);
+	  };
+	}
+
+	inspectSource = store.inspectSource;
+	return inspectSource;
+}
+
+var weakMapBasicDetection;
+var hasRequiredWeakMapBasicDetection;
+
+function requireWeakMapBasicDetection () {
+	if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
+	hasRequiredWeakMapBasicDetection = 1;
+	var globalThis = requireGlobalThis();
+	var isCallable = requireIsCallable();
+
+	var WeakMap = globalThis.WeakMap;
+
+	weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
+	return weakMapBasicDetection;
+}
+
+var sharedKey;
+var hasRequiredSharedKey;
+
+function requireSharedKey () {
+	if (hasRequiredSharedKey) return sharedKey;
+	hasRequiredSharedKey = 1;
+	var shared = requireShared();
+	var uid = requireUid();
+
+	var keys = shared('keys');
+
+	sharedKey = function (key) {
+	  return keys[key] || (keys[key] = uid(key));
+	};
+	return sharedKey;
+}
+
+var hiddenKeys;
+var hasRequiredHiddenKeys;
+
+function requireHiddenKeys () {
+	if (hasRequiredHiddenKeys) return hiddenKeys;
+	hasRequiredHiddenKeys = 1;
+	hiddenKeys = {};
+	return hiddenKeys;
+}
+
+var internalState;
+var hasRequiredInternalState;
+
+function requireInternalState () {
+	if (hasRequiredInternalState) return internalState;
+	hasRequiredInternalState = 1;
+	var NATIVE_WEAK_MAP = requireWeakMapBasicDetection();
+	var globalThis = requireGlobalThis();
+	var isObject = requireIsObject();
+	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+	var hasOwn = requireHasOwnProperty();
+	var shared = requireSharedStore();
+	var sharedKey = requireSharedKey();
+	var hiddenKeys = requireHiddenKeys();
+
+	var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+	var TypeError = globalThis.TypeError;
+	var WeakMap = globalThis.WeakMap;
+	var set, get, has;
+
+	var enforce = function (it) {
+	  return has(it) ? get(it) : set(it, {});
+	};
+
+	var getterFor = function (TYPE) {
+	  return function (it) {
+	    var state;
+	    if (!isObject(it) || (state = get(it)).type !== TYPE) {
+	      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
+	    } return state;
+	  };
+	};
+
+	if (NATIVE_WEAK_MAP || shared.state) {
+	  var store = shared.state || (shared.state = new WeakMap());
+	  /* eslint-disable no-self-assign -- prototype methods protection */
+	  store.get = store.get;
+	  store.has = store.has;
+	  store.set = store.set;
+	  /* eslint-enable no-self-assign -- prototype methods protection */
+	  set = function (it, metadata) {
+	    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+	    metadata.facade = it;
+	    store.set(it, metadata);
+	    return metadata;
+	  };
+	  get = function (it) {
+	    return store.get(it) || {};
+	  };
+	  has = function (it) {
+	    return store.has(it);
+	  };
+	} else {
+	  var STATE = sharedKey('state');
+	  hiddenKeys[STATE] = true;
+	  set = function (it, metadata) {
+	    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+	    metadata.facade = it;
+	    createNonEnumerableProperty(it, STATE, metadata);
+	    return metadata;
+	  };
+	  get = function (it) {
+	    return hasOwn(it, STATE) ? it[STATE] : {};
+	  };
+	  has = function (it) {
+	    return hasOwn(it, STATE);
+	  };
+	}
+
+	internalState = {
+	  set: set,
+	  get: get,
+	  has: has,
+	  enforce: enforce,
+	  getterFor: getterFor
+	};
+	return internalState;
+}
+
+var hasRequiredMakeBuiltIn;
+
+function requireMakeBuiltIn () {
+	if (hasRequiredMakeBuiltIn) return makeBuiltIn.exports;
+	hasRequiredMakeBuiltIn = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var fails = requireFails();
+	var isCallable = requireIsCallable();
+	var hasOwn = requireHasOwnProperty();
+	var DESCRIPTORS = requireDescriptors();
+	var CONFIGURABLE_FUNCTION_NAME = requireFunctionName().CONFIGURABLE;
+	var inspectSource = requireInspectSource();
+	var InternalStateModule = requireInternalState();
+
+	var enforceInternalState = InternalStateModule.enforce;
+	var getInternalState = InternalStateModule.get;
+	var $String = String;
+	// eslint-disable-next-line es/no-object-defineproperty -- safe
+	var defineProperty = Object.defineProperty;
+	var stringSlice = uncurryThis(''.slice);
+	var replace = uncurryThis(''.replace);
+	var join = uncurryThis([].join);
+
+	var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
+	  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
+	});
+
+	var TEMPLATE = String(String).split('String');
+
+	var makeBuiltIn$1 = makeBuiltIn.exports = function (value, name, options) {
+	  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
+	    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
+	  }
+	  if (options && options.getter) name = 'get ' + name;
+	  if (options && options.setter) name = 'set ' + name;
+	  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+	    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
+	    else value.name = name;
+	  }
+	  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
+	    defineProperty(value, 'length', { value: options.arity });
+	  }
+	  try {
+	    if (options && hasOwn(options, 'constructor') && options.constructor) {
+	      if (DESCRIPTORS) defineProperty(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(state, 'source')) {
+	    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
+	  } return value;
+	};
+
+	// 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(this) && getInternalState(this).source || inspectSource(this);
+	}, 'toString');
+	return makeBuiltIn.exports;
+}
+
+var defineBuiltIn;
+var hasRequiredDefineBuiltIn;
+
+function requireDefineBuiltIn () {
+	if (hasRequiredDefineBuiltIn) return defineBuiltIn;
+	hasRequiredDefineBuiltIn = 1;
+	var isCallable = requireIsCallable();
+	var definePropertyModule = requireObjectDefineProperty();
+	var makeBuiltIn = requireMakeBuiltIn();
+	var defineGlobalProperty = requireDefineGlobalProperty();
+
+	defineBuiltIn = function (O, key, value, options) {
+	  if (!options) options = {};
+	  var simple = options.enumerable;
+	  var name = options.name !== undefined ? options.name : key;
+	  if (isCallable(value)) makeBuiltIn(value, name, options);
+	  if (options.global) {
+	    if (simple) O[key] = value;
+	    else defineGlobalProperty(key, value);
+	  } else {
+	    try {
+	      if (!options.unsafe) delete O[key];
+	      else if (O[key]) simple = true;
+	    } catch (error) { /* empty */ }
+	    if (simple) O[key] = value;
+	    else definePropertyModule.f(O, key, {
+	      value: value,
+	      enumerable: false,
+	      configurable: !options.nonConfigurable,
+	      writable: !options.nonWritable
+	    });
+	  } return O;
+	};
+	return defineBuiltIn;
+}
+
+var objectGetOwnPropertyNames = {};
+
+var mathTrunc;
+var hasRequiredMathTrunc;
+
+function requireMathTrunc () {
+	if (hasRequiredMathTrunc) return mathTrunc;
+	hasRequiredMathTrunc = 1;
+	var ceil = Math.ceil;
+	var floor = Math.floor;
+
+	// `Math.trunc` method
+	// https://tc39.es/ecma262/#sec-math.trunc
+	// eslint-disable-next-line es/no-math-trunc -- safe
+	mathTrunc = Math.trunc || function trunc(x) {
+	  var n = +x;
+	  return (n > 0 ? floor : ceil)(n);
+	};
+	return mathTrunc;
+}
+
+var toIntegerOrInfinity;
+var hasRequiredToIntegerOrInfinity;
+
+function requireToIntegerOrInfinity () {
+	if (hasRequiredToIntegerOrInfinity) return toIntegerOrInfinity;
+	hasRequiredToIntegerOrInfinity = 1;
+	var trunc = requireMathTrunc();
+
+	// `ToIntegerOrInfinity` abstract operation
+	// https://tc39.es/ecma262/#sec-tointegerorinfinity
+	toIntegerOrInfinity = function (argument) {
+	  var number = +argument;
+	  // eslint-disable-next-line no-self-compare -- NaN check
+	  return number !== number || number === 0 ? 0 : trunc(number);
+	};
+	return toIntegerOrInfinity;
+}
+
+var toAbsoluteIndex;
+var hasRequiredToAbsoluteIndex;
+
+function requireToAbsoluteIndex () {
+	if (hasRequiredToAbsoluteIndex) return toAbsoluteIndex;
+	hasRequiredToAbsoluteIndex = 1;
+	var toIntegerOrInfinity = requireToIntegerOrInfinity();
+
+	var max = Math.max;
+	var min = Math.min;
+
+	// Helper for a popular repeating case of the spec:
+	// Let integer be ? ToInteger(index).
+	// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+	toAbsoluteIndex = function (index, length) {
+	  var integer = toIntegerOrInfinity(index);
+	  return integer < 0 ? max(integer + length, 0) : min(integer, length);
+	};
+	return toAbsoluteIndex;
+}
+
+var toLength;
+var hasRequiredToLength;
+
+function requireToLength () {
+	if (hasRequiredToLength) return toLength;
+	hasRequiredToLength = 1;
+	var toIntegerOrInfinity = requireToIntegerOrInfinity();
+
+	var min = Math.min;
+
+	// `ToLength` abstract operation
+	// https://tc39.es/ecma262/#sec-tolength
+	toLength = function (argument) {
+	  var len = toIntegerOrInfinity(argument);
+	  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+	};
+	return toLength;
+}
+
+var lengthOfArrayLike;
+var hasRequiredLengthOfArrayLike;
+
+function requireLengthOfArrayLike () {
+	if (hasRequiredLengthOfArrayLike) return lengthOfArrayLike;
+	hasRequiredLengthOfArrayLike = 1;
+	var toLength = requireToLength();
+
+	// `LengthOfArrayLike` abstract operation
+	// https://tc39.es/ecma262/#sec-lengthofarraylike
+	lengthOfArrayLike = function (obj) {
+	  return toLength(obj.length);
+	};
+	return lengthOfArrayLike;
+}
+
+var arrayIncludes;
+var hasRequiredArrayIncludes;
+
+function requireArrayIncludes () {
+	if (hasRequiredArrayIncludes) return arrayIncludes;
+	hasRequiredArrayIncludes = 1;
+	var toIndexedObject = requireToIndexedObject();
+	var toAbsoluteIndex = requireToAbsoluteIndex();
+	var lengthOfArrayLike = requireLengthOfArrayLike();
+
+	// `Array.prototype.{ indexOf, includes }` methods implementation
+	var createMethod = function (IS_INCLUDES) {
+	  return function ($this, el, fromIndex) {
+	    var O = toIndexedObject($this);
+	    var length = lengthOfArrayLike(O);
+	    if (length === 0) return !IS_INCLUDES && -1;
+	    var index = toAbsoluteIndex(fromIndex, length);
+	    var value;
+	    // Array#includes uses SameValueZero equality algorithm
+	    // eslint-disable-next-line no-self-compare -- NaN check
+	    if (IS_INCLUDES && el !== el) while (length > index) {
+	      value = O[index++];
+	      // eslint-disable-next-line no-self-compare -- NaN check
+	      if (value !== value) return true;
+	    // Array#indexOf ignores holes, Array#includes - not
+	    } else for (;length > index; index++) {
+	      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+	    } return !IS_INCLUDES && -1;
+	  };
+	};
+
+	arrayIncludes = {
+	  // `Array.prototype.includes` method
+	  // https://tc39.es/ecma262/#sec-array.prototype.includes
+	  includes: createMethod(true),
+	  // `Array.prototype.indexOf` method
+	  // https://tc39.es/ecma262/#sec-array.prototype.indexof
+	  indexOf: createMethod(false)
+	};
+	return arrayIncludes;
+}
+
+var objectKeysInternal;
+var hasRequiredObjectKeysInternal;
+
+function requireObjectKeysInternal () {
+	if (hasRequiredObjectKeysInternal) return objectKeysInternal;
+	hasRequiredObjectKeysInternal = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var hasOwn = requireHasOwnProperty();
+	var toIndexedObject = requireToIndexedObject();
+	var indexOf = requireArrayIncludes().indexOf;
+	var hiddenKeys = requireHiddenKeys();
+
+	var push = uncurryThis([].push);
+
+	objectKeysInternal = function (object, names) {
+	  var O = toIndexedObject(object);
+	  var i = 0;
+	  var result = [];
+	  var key;
+	  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
+	  // Don't enum bug & hidden keys
+	  while (names.length > i) if (hasOwn(O, key = names[i++])) {
+	    ~indexOf(result, key) || push(result, key);
+	  }
+	  return result;
+	};
+	return objectKeysInternal;
+}
+
+var enumBugKeys;
+var hasRequiredEnumBugKeys;
+
+function requireEnumBugKeys () {
+	if (hasRequiredEnumBugKeys) return enumBugKeys;
+	hasRequiredEnumBugKeys = 1;
+	// IE8- don't enum bug keys
+	enumBugKeys = [
+	  'constructor',
+	  'hasOwnProperty',
+	  'isPrototypeOf',
+	  'propertyIsEnumerable',
+	  'toLocaleString',
+	  'toString',
+	  'valueOf'
+	];
+	return enumBugKeys;
+}
+
+var hasRequiredObjectGetOwnPropertyNames;
+
+function requireObjectGetOwnPropertyNames () {
+	if (hasRequiredObjectGetOwnPropertyNames) return objectGetOwnPropertyNames;
+	hasRequiredObjectGetOwnPropertyNames = 1;
+	var internalObjectKeys = requireObjectKeysInternal();
+	var enumBugKeys = requireEnumBugKeys();
+
+	var hiddenKeys = enumBugKeys.concat('length', 'prototype');
+
+	// `Object.getOwnPropertyNames` method
+	// https://tc39.es/ecma262/#sec-object.getownpropertynames
+	// eslint-disable-next-line es/no-object-getownpropertynames -- safe
+	objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+	  return internalObjectKeys(O, hiddenKeys);
+	};
+	return objectGetOwnPropertyNames;
+}
+
+var objectGetOwnPropertySymbols = {};
+
+var hasRequiredObjectGetOwnPropertySymbols;
+
+function requireObjectGetOwnPropertySymbols () {
+	if (hasRequiredObjectGetOwnPropertySymbols) return objectGetOwnPropertySymbols;
+	hasRequiredObjectGetOwnPropertySymbols = 1;
+	// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+	objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
+	return objectGetOwnPropertySymbols;
+}
+
+var ownKeys;
+var hasRequiredOwnKeys;
+
+function requireOwnKeys () {
+	if (hasRequiredOwnKeys) return ownKeys;
+	hasRequiredOwnKeys = 1;
+	var getBuiltIn = requireGetBuiltIn();
+	var uncurryThis = requireFunctionUncurryThis();
+	var getOwnPropertyNamesModule = requireObjectGetOwnPropertyNames();
+	var getOwnPropertySymbolsModule = requireObjectGetOwnPropertySymbols();
+	var anObject = requireAnObject();
+
+	var concat = uncurryThis([].concat);
+
+	// all object keys, includes non-enumerable and symbols
+	ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+	  var keys = getOwnPropertyNamesModule.f(anObject(it));
+	  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+	  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+	};
+	return ownKeys;
+}
+
+var copyConstructorProperties;
+var hasRequiredCopyConstructorProperties;
+
+function requireCopyConstructorProperties () {
+	if (hasRequiredCopyConstructorProperties) return copyConstructorProperties;
+	hasRequiredCopyConstructorProperties = 1;
+	var hasOwn = requireHasOwnProperty();
+	var ownKeys = requireOwnKeys();
+	var getOwnPropertyDescriptorModule = requireObjectGetOwnPropertyDescriptor();
+	var definePropertyModule = requireObjectDefineProperty();
+
+	copyConstructorProperties = function (target, source, exceptions) {
+	  var keys = ownKeys(source);
+	  var defineProperty = definePropertyModule.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))) {
+	      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+	    }
+	  }
+	};
+	return copyConstructorProperties;
+}
+
+var isForced_1;
+var hasRequiredIsForced;
+
+function requireIsForced () {
+	if (hasRequiredIsForced) return isForced_1;
+	hasRequiredIsForced = 1;
+	var fails = requireFails();
+	var isCallable = requireIsCallable();
+
+	var replacement = /#|\.prototype\./;
+
+	var isForced = function (feature, detection) {
+	  var value = data[normalize(feature)];
+	  return value === POLYFILL ? true
+	    : value === NATIVE ? false
+	    : isCallable(detection) ? fails(detection)
+	    : !!detection;
+	};
+
+	var normalize = isForced.normalize = function (string) {
+	  return String(string).replace(replacement, '.').toLowerCase();
+	};
+
+	var data = isForced.data = {};
+	var NATIVE = isForced.NATIVE = 'N';
+	var POLYFILL = isForced.POLYFILL = 'P';
+
+	isForced_1 = isForced;
+	return isForced_1;
+}
+
+var _export;
+var hasRequired_export;
+
+function require_export () {
+	if (hasRequired_export) return _export;
+	hasRequired_export = 1;
+	var globalThis = requireGlobalThis();
+	var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
+	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+	var defineBuiltIn = requireDefineBuiltIn();
+	var defineGlobalProperty = requireDefineGlobalProperty();
+	var copyConstructorProperties = requireCopyConstructorProperties();
+	var isForced = requireIsForced();
+
+	/*
+	  options.target         - name of the target object
+	  options.global         - target is the global object
+	  options.stat           - export as static methods of target
+	  options.proto          - export as prototype methods of target
+	  options.real           - real prototype method for the `pure` version
+	  options.forced         - export even if the native feature is available
+	  options.bind           - bind methods to the target, required for the `pure` version
+	  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
+	  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
+	  options.sham           - add a flag to not completely full polyfills
+	  options.enumerable     - export as enumerable property
+	  options.dontCallGetSet - prevent calling a getter on target
+	  options.name           - the .name of the function if it does not match the key
+	*/
+	_export = function (options, source) {
+	  var TARGET = options.target;
+	  var GLOBAL = options.global;
+	  var STATIC = options.stat;
+	  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+	  if (GLOBAL) {
+	    target = globalThis;
+	  } else if (STATIC) {
+	    target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
+	  } else {
+	    target = globalThis[TARGET] && globalThis[TARGET].prototype;
+	  }
+	  if (target) for (key in source) {
+	    sourceProperty = source[key];
+	    if (options.dontCallGetSet) {
+	      descriptor = getOwnPropertyDescriptor(target, key);
+	      targetProperty = descriptor && descriptor.value;
+	    } else targetProperty = target[key];
+	    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+	    // contained in target
+	    if (!FORCED && targetProperty !== undefined) {
+	      if (typeof sourceProperty == typeof targetProperty) continue;
+	      copyConstructorProperties(sourceProperty, targetProperty);
+	    }
+	    // add a flag to not completely full polyfills
+	    if (options.sham || (targetProperty && targetProperty.sham)) {
+	      createNonEnumerableProperty(sourceProperty, 'sham', true);
+	    }
+	    defineBuiltIn(target, key, sourceProperty, options);
+	  }
+	};
+	return _export;
+}
+
+var toStringTagSupport;
+var hasRequiredToStringTagSupport;
+
+function requireToStringTagSupport () {
+	if (hasRequiredToStringTagSupport) return toStringTagSupport;
+	hasRequiredToStringTagSupport = 1;
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+	var test = {};
+	// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
+	test[TO_STRING_TAG] = 'z';
+
+	toStringTagSupport = String(test) === '[object z]';
+	return toStringTagSupport;
+}
+
+var classof;
+var hasRequiredClassof;
+
+function requireClassof () {
+	if (hasRequiredClassof) return classof;
+	hasRequiredClassof = 1;
+	var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
+	var isCallable = requireIsCallable();
+	var classofRaw = requireClassofRaw();
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+	var $Object = Object;
+
+	// ES3 wrong here
+	var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
+
+	// fallback for IE11 Script Access Denied error
+	var tryGet = function (it, key) {
+	  try {
+	    return it[key];
+	  } catch (error) { /* empty */ }
+	};
+
+	// getting tag from ES6+ `Object.prototype.toString`
+	classof = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+	  var O, tag, result;
+	  return it === undefined ? 'Undefined' : it === null ? 'Null'
+	    // @@toStringTag case
+	    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
+	    // builtinTag case
+	    : CORRECT_ARGUMENTS ? classofRaw(O)
+	    // ES3 arguments fallback
+	    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
+	};
+	return classof;
+}
+
+var toString;
+var hasRequiredToString;
+
+function requireToString () {
+	if (hasRequiredToString) return toString;
+	hasRequiredToString = 1;
+	var classof = requireClassof();
+
+	var $String = String;
+
+	toString = function (argument) {
+	  if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
+	  return $String(argument);
+	};
+	return toString;
+}
+
+var defineBuiltInAccessor;
+var hasRequiredDefineBuiltInAccessor;
+
+function requireDefineBuiltInAccessor () {
+	if (hasRequiredDefineBuiltInAccessor) return defineBuiltInAccessor;
+	hasRequiredDefineBuiltInAccessor = 1;
+	var makeBuiltIn = requireMakeBuiltIn();
+	var defineProperty = requireObjectDefineProperty();
+
+	defineBuiltInAccessor = function (target, name, descriptor) {
+	  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
+	  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
+	  return defineProperty.f(target, name, descriptor);
+	};
+	return defineBuiltInAccessor;
+}
+
+var hasRequiredEs_symbol_description;
+
+function requireEs_symbol_description () {
+	if (hasRequiredEs_symbol_description) return es_symbol_description;
+	hasRequiredEs_symbol_description = 1;
+	var $ = require_export();
+	var DESCRIPTORS = requireDescriptors();
+	var globalThis = requireGlobalThis();
+	var uncurryThis = requireFunctionUncurryThis();
+	var hasOwn = requireHasOwnProperty();
+	var isCallable = requireIsCallable();
+	var isPrototypeOf = requireObjectIsPrototypeOf();
+	var toString = requireToString();
+	var defineBuiltInAccessor = requireDefineBuiltInAccessor();
+	var copyConstructorProperties = requireCopyConstructorProperties();
+
+	var NativeSymbol = globalThis.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(arguments[0]);
+	    var result = isPrototypeOf(SymbolPrototype, this)
+	      // eslint-disable-next-line sonarjs/inconsistent-function-call -- ok
+	      ? 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('description detection')) === 'Symbol(description detection)';
+	  var thisSymbolValue = uncurryThis(SymbolPrototype.valueOf);
+	  var symbolDescriptiveString = uncurryThis(SymbolPrototype.toString);
+	  var regexp = /^Symbol\((.*)\)[^)]+$/;
+	  var replace = uncurryThis(''.replace);
+	  var stringSlice = uncurryThis(''.slice);
+
+	  defineBuiltInAccessor(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;
+	    }
+	  });
+
+	  $({ global: true, constructor: true, forced: true }, {
+	    Symbol: SymbolWrapper
+	  });
+	}
+	return es_symbol_description;
+}
+
+requireEs_symbol_description();
+
+var es_array_sort = {};
+
+var deletePropertyOrThrow;
+var hasRequiredDeletePropertyOrThrow;
+
+function requireDeletePropertyOrThrow () {
+	if (hasRequiredDeletePropertyOrThrow) return deletePropertyOrThrow;
+	hasRequiredDeletePropertyOrThrow = 1;
+	var tryToString = requireTryToString();
+
+	var $TypeError = TypeError;
+
+	deletePropertyOrThrow = function (O, P) {
+	  if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
+	};
+	return deletePropertyOrThrow;
+}
+
+var arraySlice;
+var hasRequiredArraySlice;
+
+function requireArraySlice () {
+	if (hasRequiredArraySlice) return arraySlice;
+	hasRequiredArraySlice = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	arraySlice = uncurryThis([].slice);
+	return arraySlice;
+}
+
+var arraySort;
+var hasRequiredArraySort;
+
+function requireArraySort () {
+	if (hasRequiredArraySort) return arraySort;
+	hasRequiredArraySort = 1;
+	var arraySlice = requireArraySlice();
+
+	var floor = Math.floor;
+
+	var sort = function (array, comparefn) {
+	  var length = array.length;
+
+	  if (length < 8) {
+	    // insertion sort
+	    var i = 1;
+	    var element, j;
+
+	    while (i < length) {
+	      j = i;
+	      element = array[i];
+	      while (j && comparefn(array[j - 1], element) > 0) {
+	        array[j] = array[--j];
+	      }
+	      if (j !== i++) array[j] = element;
+	    }
+	  } else {
+	    // merge sort
+	    var middle = floor(length / 2);
+	    var left = sort(arraySlice(array, 0, middle), comparefn);
+	    var right = sort(arraySlice(array, middle), comparefn);
+	    var llength = left.length;
+	    var rlength = right.length;
+	    var lindex = 0;
+	    var rindex = 0;
+
+	    while (lindex < llength || rindex < rlength) {
+	      array[lindex + rindex] = (lindex < llength && rindex < rlength)
+	        ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]
+	        : lindex < llength ? left[lindex++] : right[rindex++];
+	    }
+	  }
+
+	  return array;
+	};
+
+	arraySort = sort;
+	return arraySort;
+}
+
+var arrayMethodIsStrict;
+var hasRequiredArrayMethodIsStrict;
+
+function requireArrayMethodIsStrict () {
+	if (hasRequiredArrayMethodIsStrict) return arrayMethodIsStrict;
+	hasRequiredArrayMethodIsStrict = 1;
+	var fails = requireFails();
+
+	arrayMethodIsStrict = function (METHOD_NAME, argument) {
+	  var method = [][METHOD_NAME];
+	  return !!method && fails(function () {
+	    // eslint-disable-next-line no-useless-call -- required for testing
+	    method.call(null, argument || function () { return 1; }, 1);
+	  });
+	};
+	return arrayMethodIsStrict;
+}
+
+var environmentFfVersion;
+var hasRequiredEnvironmentFfVersion;
+
+function requireEnvironmentFfVersion () {
+	if (hasRequiredEnvironmentFfVersion) return environmentFfVersion;
+	hasRequiredEnvironmentFfVersion = 1;
+	var userAgent = requireEnvironmentUserAgent();
+
+	var firefox = userAgent.match(/firefox\/(\d+)/i);
+
+	environmentFfVersion = !!firefox && +firefox[1];
+	return environmentFfVersion;
+}
+
+var environmentIsIeOrEdge;
+var hasRequiredEnvironmentIsIeOrEdge;
+
+function requireEnvironmentIsIeOrEdge () {
+	if (hasRequiredEnvironmentIsIeOrEdge) return environmentIsIeOrEdge;
+	hasRequiredEnvironmentIsIeOrEdge = 1;
+	var UA = requireEnvironmentUserAgent();
+
+	environmentIsIeOrEdge = /MSIE|Trident/.test(UA);
+	return environmentIsIeOrEdge;
+}
+
+var environmentWebkitVersion;
+var hasRequiredEnvironmentWebkitVersion;
+
+function requireEnvironmentWebkitVersion () {
+	if (hasRequiredEnvironmentWebkitVersion) return environmentWebkitVersion;
+	hasRequiredEnvironmentWebkitVersion = 1;
+	var userAgent = requireEnvironmentUserAgent();
+
+	var webkit = userAgent.match(/AppleWebKit\/(\d+)\./);
+
+	environmentWebkitVersion = !!webkit && +webkit[1];
+	return environmentWebkitVersion;
+}
+
+var hasRequiredEs_array_sort;
+
+function requireEs_array_sort () {
+	if (hasRequiredEs_array_sort) return es_array_sort;
+	hasRequiredEs_array_sort = 1;
+	var $ = require_export();
+	var uncurryThis = requireFunctionUncurryThis();
+	var aCallable = requireACallable();
+	var toObject = requireToObject();
+	var lengthOfArrayLike = requireLengthOfArrayLike();
+	var deletePropertyOrThrow = requireDeletePropertyOrThrow();
+	var toString = requireToString();
+	var fails = requireFails();
+	var internalSort = requireArraySort();
+	var arrayMethodIsStrict = requireArrayMethodIsStrict();
+	var FF = requireEnvironmentFfVersion();
+	var IE_OR_EDGE = requireEnvironmentIsIeOrEdge();
+	var V8 = requireEnvironmentV8Version();
+	var WEBKIT = requireEnvironmentWebkitVersion();
+
+	var test = [];
+	var nativeSort = uncurryThis(test.sort);
+	var push = uncurryThis(test.push);
+
+	// IE8-
+	var FAILS_ON_UNDEFINED = fails(function () {
+	  test.sort(undefined);
+	});
+	// V8 bug
+	var FAILS_ON_NULL = fails(function () {
+	  test.sort(null);
+	});
+	// Old WebKit
+	var STRICT_METHOD = arrayMethodIsStrict('sort');
+
+	var STABLE_SORT = !fails(function () {
+	  // feature detection can be too slow, so check engines versions
+	  if (V8) return V8 < 70;
+	  if (FF && FF > 3) return;
+	  if (IE_OR_EDGE) return true;
+	  if (WEBKIT) return WEBKIT < 603;
+
+	  var result = '';
+	  var code, chr, value, index;
+
+	  // generate an array with more 512 elements (Chakra and old V8 fails only in this case)
+	  for (code = 65; code < 76; code++) {
+	    chr = String.fromCharCode(code);
+
+	    switch (code) {
+	      case 66: case 69: case 70: case 72: value = 3; break;
+	      case 68: case 71: value = 4; break;
+	      default: value = 2;
+	    }
+
+	    for (index = 0; index < 47; index++) {
+	      test.push({ k: chr + index, v: value });
+	    }
+	  }
+
+	  test.sort(function (a, b) { return b.v - a.v; });
+
+	  for (index = 0; index < test.length; index++) {
+	    chr = test[index].k.charAt(0);
+	    if (result.charAt(result.length - 1) !== chr) result += chr;
+	  }
+
+	  return result !== 'DGBEFHACIJK';
+	});
+
+	var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;
+
+	var getSortCompare = function (comparefn) {
+	  return function (x, y) {
+	    if (y === undefined) return -1;
+	    if (x === undefined) return 1;
+	    if (comparefn !== undefined) return +comparefn(x, y) || 0;
+	    return toString(x) > toString(y) ? 1 : -1;
+	  };
+	};
+
+	// `Array.prototype.sort` method
+	// https://tc39.es/ecma262/#sec-array.prototype.sort
+	$({ target: 'Array', proto: true, forced: FORCED }, {
+	  sort: function sort(comparefn) {
+	    if (comparefn !== undefined) aCallable(comparefn);
+
+	    var array = toObject(this);
+
+	    if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);
+
+	    var items = [];
+	    var arrayLength = lengthOfArrayLike(array);
+	    var itemsLength, index;
+
+	    for (index = 0; index < arrayLength; index++) {
+	      if (index in array) push(items, array[index]);
+	    }
+
+	    internalSort(items, getSortCompare(comparefn));
+
+	    itemsLength = lengthOfArrayLike(items);
+	    index = 0;
+
+	    while (index < itemsLength) array[index] = items[index++];
+	    while (index < arrayLength) deletePropertyOrThrow(array, index++);
+
+	    return array;
+	  }
+	});
+	return es_array_sort;
+}
+
+requireEs_array_sort();
+
+var esnext_globalThis = {};
+
+var es_globalThis = {};
+
+var hasRequiredEs_globalThis;
+
+function requireEs_globalThis () {
+	if (hasRequiredEs_globalThis) return es_globalThis;
+	hasRequiredEs_globalThis = 1;
+	var $ = require_export();
+	var globalThis = requireGlobalThis();
+
+	// `globalThis` object
+	// https://tc39.es/ecma262/#sec-globalthis
+	$({ global: true, forced: globalThis.globalThis !== globalThis }, {
+	  globalThis: globalThis
+	});
+	return es_globalThis;
+}
+
+var hasRequiredEsnext_globalThis;
+
+function requireEsnext_globalThis () {
+	if (hasRequiredEsnext_globalThis) return esnext_globalThis;
+	hasRequiredEsnext_globalThis = 1;
+	// TODO: Remove from `core-js@4`
+	requireEs_globalThis();
+	return esnext_globalThis;
+}
+
+requireEsnext_globalThis();
+
+let rtlScrollType;
+
+const detectRtlScrollType = () => {
+  const definer = document.createElement('div');
+  definer.dir = 'rtl';
+  Object.assign(definer.style, {
+    direction: 'rtl',
+    fontSize: '14px',
+    width: '1px',
+    height: '1px',
+    position: 'absolute',
+    top: '-1000px',
+    overflow: 'scroll'
+  });
+  definer.textContent = 'A';
+  document.body.appendChild(definer);
+
+  let type = 'reverse';
+
+  if (definer.scrollLeft > 0) {
+    type = 'default';
+  } else {
+    definer.scrollLeft = 1;
+
+    // bug: on some machines, chrome will have a positive delta of less than 1.
+    //       a full scroll will still be in the negative direction.
+    //       let's use Math.floor() to account for that bug.
+    if (Math.floor(definer.scrollLeft) === 0) {
+      type = 'negative';
+    }
+  }
+
+  definer.parentNode.removeChild(definer);
+
+  return type;
+};
+
+/**
+ * @param {Element} el
+ * @param {number} left
+ * @param {boolean|undefined} [rtl] if unspecified, then it's automatically detected.
+ * @returns {number}
+ */
+function calculateNativeScrollLeftForLeft(el, left, rtl) {
+  if (rtl === undefined) {
+    rtl = getComputedStyle(el).direction === 'rtl';
+  }
+
+  if (rtl === true && rtlScrollType === undefined) {
+    rtlScrollType = detectRtlScrollType();
+  }
+
+  if (rtl) {
+    switch (rtlScrollType) {
+      case 'negative':
+        return left - el.scrollWidth + el.clientWidth;
+
+      case 'reverse':
+        return el.scrollWidth - left - el.clientWidth;
+
+      default:
+        return left;
+    }
+  } else {
+    return left;
+  }
+}
+
+/**
+ * @param {Element} el
+ * @param {boolean|undefined} [rtl] if unspecified, then it's automatically detected.
+ * @returns {number}
+ */
+function getScrollLeft(el, rtl) {
+  if (rtl === undefined) {
+    rtl = getComputedStyle(el).direction === 'rtl';
+  }
+
+  if (rtl === true && rtlScrollType === undefined) {
+    rtlScrollType = detectRtlScrollType();
+  }
+
+  if (rtl) {
+    switch (rtlScrollType) {
+      case 'negative':
+        return el.scrollLeft + el.scrollWidth - el.clientWidth;
+
+      case 'reverse':
+        return el.scrollWidth - el.scrollLeft - el.clientWidth;
+
+      default:
+        return el.scrollLeft;
+    }
+  } else {
+    return el.scrollLeft;
+  }
+}
+
+/**
+ * @param {Element} el
+ * @param {number} value
+ * @param {boolean|undefined} [rtl] if unspecified, then it's automatically detected.
+ * @returns {number}
+ */
+function calculateNativeScrollLeftForHorz(el, value, rtl) {
+  if (rtl === undefined) {
+    rtl = getComputedStyle(el).direction === 'rtl';
+  }
+
+  if (rtl) {
+    return calculateNativeScrollLeftForLeft(el, el.scrollWidth - el.clientWidth - value, rtl);
+  } else {
+    return calculateNativeScrollLeftForLeft(el, value, rtl);
+  }
+}
+
+/**
+ * @param {Element} el
+ * @param {boolean|undefined} [rtl] if unspecified, then it's automatically detected.
+ * @returns {number}
+ */
+function getScrollHorz(el, rtl) {
+  if (rtl === undefined) {
+    rtl = getComputedStyle(el).direction === 'rtl';
+  }
+  if (rtl) {
+    return el.scrollWidth - el.clientWidth - getScrollLeft(el, rtl);
+  } else {
+    return getScrollLeft(el, rtl);
+  }
+}
+
+/**
+ * @param {Element} el
+ * @param {number} horz
+ * @param {boolean|undefined} [rtl] if unspecified, then it's automatically detected.
+ */
+function setScrollHorz(el, horz, rtl) {
+  el.scrollLeft = calculateNativeScrollLeftForHorz(el, horz, rtl);
+}
+
+/**
+ * @param {Element} el
+ * @param {string[]} props
+ * @returns {Object<string, string>}
+ */
+
+/**
+ * @param {ElementCSSInlineStyle} el
+ * @param {Object<string, string>} props
+ */
+const setCssProps = function (el, props) {
+  for (let [key, value] of Object.entries(props))
+  el.style[key] = value === undefined || value === null ? '' : String(value);
+};
+
+const generateGetElementSizeFn = function (pseudo, dim, dimCased, startDim, endDim) {
+  return (...args) => {
+    let /**Element|ElementCSSInlineStyle*/el = args[0],
+      /**string*/pseudoSelector,
+      /**boolean*/paddings,
+      /**boolean*/borders,
+      /**boolean*/margins;
+
+    if (pseudo) {
+      pseudoSelector = args[1];
+      paddings = !!args[2];
+      borders = !!args[3];
+      margins = !!args[4];
+    } else {
+      paddings = !!args[1];
+      borders = !!args[2];
+      margins = !!args[3];
+    }
+
+    if ((/**@type Window*/el) === window) {
+      return (/**@type Window*/el).document.documentElement[`client${dimCased}`];
+    } else
+    if (el.nodeType === 9) {// document
+      const doc = (/**@type Document*/el).documentElement;
+      const body = (/**@type Document*/el).body;
+
+      return Math.max(
+        body[`scroll${dimCased}`],
+        doc[`scroll${dimCased}`],
+        body[`offset${dimCased}`],
+        doc[`offset${dimCased}`],
+        doc[`client${dimCased}`]
+      );
+    } else
+    {
+      let value;
+      let style;
+      let includesPadding = false,includesBorders = false;
+
+      if (!pseudo && 'getBoundingClientRect' in el) {
+        value = el.getBoundingClientRect()[dim];
+        includesPadding = true;
+        includesBorders = true;
+      }
+
+      if (value === undefined || margins || includesPadding !== paddings || includesBorders !== borders) {
+        style = pseudo ? getComputedStyle(el, pseudoSelector) : getComputedStyle(el);
+      }
+
+      if (value === undefined) {
+        let raw = style[dim];
+        if (raw === 'auto') {// computedStyle is no good here, probably an 'inline' element
+          value = el[`client${dimCased}`]; // take clientWidth/clientHeight (damn it, it's rounded)
+          includesPadding = true;
+        } else {
+          value = parseFloat(raw);
+        }
+
+        if (style.boxSizing === 'border-box') {
+          includesPadding = true;
+          includesBorders = true;
+        }
+      }
+
+      if (paddings !== includesPadding) {
+        let totalPadding = parseFloat(style[`padding-${startDim}`] || 0) +
+        parseFloat(style[`padding-${endDim}`] || 0);
+        if (paddings) value += totalPadding;else
+        value -= totalPadding;
+      }
+
+      if (borders !== includesBorders) {
+        let totalBorders = parseFloat(style[`border-${startDim}-width`] || 0) +
+        parseFloat(style[`border-${endDim}-width`] || 0);
+        if (borders) value += totalBorders;else
+        value -= totalBorders;
+      }
+
+      if (value < 0)
+      value = 0;
+
+      if (margins) {
+        let totalMargins = parseFloat(style[`margin-${startDim}`] || 0) +
+        parseFloat(style[`margin-${endDim}`] || 0);
+        value += totalMargins;
+      }
+
+      return value;
+    }
+  };
+};
+
+const generateSetElementSizeFn = (dim, dimCased, startDim, endDim) => {
+  return (/**Element|ElementCSSInlineStyle*/el,
+  /**number*/value,
+  paddings = false, borders = false, margins = false) => {
+
+    if ((/**@type Window*/el) === window) {
+      return;
+    }
+
+    if (el.nodeType === 9) {// document
+      return;
+    }
+
+    const style = getComputedStyle(el);
+
+    let includesPaddingAndBorders = false;
+
+    if (style.boxSizing === 'border-box') {
+      includesPaddingAndBorders = true;
+    }
+
+    paddings = !!paddings;
+    borders = !!borders;
+    margins = !!margins;
+
+    if (margins)
+    value -= (parseFloat(style[`margin-${startDim}`]) || 0) + (parseFloat(style[`margin-${endDim}`]) || 0);
+
+    if (paddings !== includesPaddingAndBorders) {
+      let totalPadding = parseFloat(style[`padding-${startDim}`] || 0) +
+      parseFloat(style[`padding-${endDim}`] || 0);
+      if (paddings) value -= totalPadding;else
+      value += totalPadding;
+    }
+
+    if (borders !== includesPaddingAndBorders) {
+      let totalBorders = (parseFloat(style[`border-${startDim}-width`]) || 0) + (
+      parseFloat(style[`border-${endDim}-width`]) || 0);
+      if (borders) value -= totalBorders;else
+      value += totalBorders;
+    }
+
+    if (value < 0)
+    value = 0;
+
+    el.style[dim] = value + 'px';
+  };
+};
+
+/**
+ * Gets the width of an element, with fractions
+ * @function getElementWidth
+ * @param {Element} el
+ * @param {boolean} [paddings=false] - include paddings
+ * @param {boolean} [borders=false] - include borders
+ * @param {boolean} [margins=false] - include margins
+ * @returns {number}
+ */
+const getElementWidth = generateGetElementSizeFn(false, 'width', 'Width', 'left', 'right');
+
+/**
+ * Gets the width of an element, with fractions
+ * @function getElementHeight
+ * @param {Element} el
+ * @param {boolean} [paddings=false] - include paddings
+ * @param {boolean} [borders=false] - include borders
+ * @param {boolean} [margins=false] - include margins
+ * @returns {number}
+ */
+const getElementHeight = generateGetElementSizeFn(false, 'height', 'Height', 'top', 'bottom');
+
+/**
+ * Sets the width of an element
+ * @function setElementWidth
+ * @param {Element} el
+ * @param {number} value
+ * @param {boolean} [paddings=false] - include paddings
+ * @param {boolean} [borders=false] - include borders
+ * @param {boolean} [margins=false] - include margins
+ */
+const setElementWidth = generateSetElementSizeFn('width', 'Width', 'left', 'right');
+
+/**
+ * Find offset of an element relative to the document, considering scroll offsets
+ * @param {Element} el
+ * @returns {{top: number, left: number}}
+ */
+const getElementOffset = (el) => {
+  if (!el.getClientRects().length) {
+    return { top: 0, left: 0 };
+  }
+
+  let rect = el.getBoundingClientRect();
+  let view = el.ownerDocument.defaultView;
+
+  return {
+    top: rect.top + view.pageYOffset,
+    left: rect.left + view.pageXOffset
+  };
+};
+
+/**
+ * @param {Node} el
+ * @returns {Node|null}
+ */
+
+let hasScopedQuerySelector = null;
+
+const detectScopedSelectorFeature = () => {
+  try {
+    document.createElement('div').querySelector(':scope > div');
+    hasScopedQuerySelector = true;
+  } catch (ignored) {
+    hasScopedQuerySelector = false;
+  }
+};
+
+/**
+ * @param {Element} el
+ * @param {string} selector
+ * @returns {Element|null}
+ */
+const scopedSelector = function (el, selector) {
+  if (hasScopedQuerySelector === null) {
+    detectScopedSelectorFeature();
+  }
+
+  if (hasScopedQuerySelector === true) {
+    return el.querySelector(selector.replace(/((?:^|,)\s*)/g, '$1:scope '));
+  } else {
+    let id = el.id;
+    const uniqueId = 'ID_' + Date.now();
+    el.id = uniqueId;
+    selector = selector.replace(/((?:^|,)\s*)/g, '$1#' + uniqueId);
+    try {
+      return el.querySelector(selector);
+    } finally {
+      this.id = id;
+    }
+  }
+};
+
+/**
+ * @param {Element} el
+ * @param {string} selector
+ * @returns {NodeListOf<Element>}
+ */
+const scopedSelectorAll = function (el, selector) {
+  if (hasScopedQuerySelector === null) {
+    detectScopedSelectorFeature();
+  }
+
+  if (hasScopedQuerySelector === true) {
+    return el.querySelectorAll(selector.replace(/((?:^|,)\s*)/g, '$1:scope '));
+  } else {
+    let id = el.id;
+    const uniqueId = 'ID_' + Date.now();
+    el.id = uniqueId;
+    selector = selector.replace(/((?:^|,)\s*)/g, '$1#' + uniqueId);
+    try {
+      return el.querySelectorAll(selector);
+    } finally {
+      this.id = id;
+    }
+  }
+};
+
+/**
+ * @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
+ * @property {function(height: number)} [onScrollHeightChange] a function to be notified when scroll height changes
+ *
+ */
+
+/** */
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+const hasInsertAdjacentElement = Element.prototype.insertAdjacentElement !== undefined;
+
+function insertBefore(el, before, parent) {
+  if (!before)
+  parent.appendChild(el);else
+  if (hasInsertAdjacentElement === false || el instanceof DocumentFragment)
+  parent.insertBefore(el, before);else
+  before.insertAdjacentElement('beforebegin', el);
+}
+
+/**
+ *
+ * @param {Element} itemEl
+ * @param {DocumentFragment|null} fragment
+ * @param {Node|undefined} before
+ * @param {Element} itemParent
+ * @returns {DocumentFragment|null}
+ */
+function insertBeforeWithFragment(itemEl, fragment, before, itemParent) {
+  if (itemEl.parentNode !== itemParent) {
+    if (!fragment)
+    fragment = document.createDocumentFragment();
+    fragment.appendChild(itemEl);
+  } else {
+    // insert fragment
+    if (fragment && fragment.childNodes.length > 0) {
+      insertBefore(fragment, before, itemParent);
+      fragment = null;
+    }
+
+    // insert element
+    if (itemEl.nextSibling !== before) {
+      insertBefore(itemEl, before, itemParent);
+    }
+  }
+
+  return fragment;
+}
+
+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,
+
+      /** @type {function(height: number)|null} */
+      onScrollHeightChange: 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;
+
+    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);
+
+    if (typeof opts.onScrollHeightChange === 'function')
+    this.setOnScrollHeightChange(opts.onScrollHeightChange);
+  }
+
+  /**
+   * 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.invalidate();
+  }
+
+  /**
+   * @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;
+  }
+
+  /**
+   * The `onScrollHeightChange` is a function called when the scroll height changes.
+   * @param {function(height: number)} fn
+   * @returns {VirtualListHelper}
+   */
+  setOnScrollHeightChange(fn) {
+    const p = this._p;
+    p.onScrollHeightChange = 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();
+
+    if (!p.virtual) {
+      this._destroyElements();
+    }
+
+    for (let el of p.existingEls)
+    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 itemParent = p.currentItemsParent;
+    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();
+        itemParent = p.currentItemsParent;
+
+        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;
+
+      // we want to render until viewport's bottom + buffer items
+      let maxIndexToRender = Math.max(index, binarySearchPosition(p.cachedItemPositions, visibleBottom - 1) + 1 + buffer);
+
+      let insertedItems = [];
+
+      /** @type DocumentFragment|null */
+      let fragment = null;
+
+      // Find the element to insert before
+      let before = virtualWrapper.childNodes[0];
+
+      const findElementToReuse = function (index) {
+        // 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.call(x, ItemIndexSymbol)) &&
+          x[ReuseElSymbol] === true) :
+          undefined) ||
+          findLast(existingEls, (x) => x[ReuseElSymbol] === true);
+        }
+
+        if (existingEl !== undefined) {
+          delete existingEl[ReuseElSymbol];
+        }
+
+        return existingEl;
+      };
+
+      // First we iterate and try to add all at once in a fragment, as much as we can.
+      // And then reflow the at once.
+      for (; index < count && index < maxIndexToRender; index++) {
+        let existingEl = findElementToReuse(index);
+
+        if (before && before === existingEl)
+        before = before.nextSibling;
+
+        // Dequeue the element by reusing or creating a new one
+        const itemEl = this._dequeueElementForIndex(existingEl, index, before, true);
+        insertedItems.push([itemEl, index]);
+
+        fragment = insertBeforeWithFragment(itemEl, fragment, before, itemParent);
+      }
+
+      // Insert any remaining fragment
+      if (fragment && fragment.childNodes.length > 0) {
+        insertBefore(fragment, before, itemParent);
+      }
+
+      // Iterate on inserted items and reflow them
+      for (let item of insertedItems) {
+        const index = item[1];
+        this._insertItemAndFlow(item[0], index, false /* inserted already */);
+        renderPos = p.cachedItemPositions[index] + p.cachedItemHeights[index];
+      }
+
+      // See if we still need to insert more items
+      if (renderPos < visibleBottom) {
+        for (; (renderPos < visibleBottom || bufferEnd-- > 0) && index < count; index++) {
+          let existingEl = findElementToReuse(index);
+
+          if (before && before === existingEl)
+          before = before.nextSibling;
+
+          // Dequeue the element by reusing or creating a new one
+          this._dequeueElementForIndex(existingEl, index, before, false);
+
+          // Increment pointers
+          renderPos = p.cachedItemPositions[index] + p.cachedItemHeights[index];
+        }
+      }
+
+      // Calculate up-to-date scroll height
+      let scrollHeight = this.estimateFullHeight();
+      let scrollHeightPx = scrollHeight + 'px';
+
+      if (virtualWrapper.style.height !== scrollHeightPx) {var _p$onScrollHeightChan;
+        p.virtualWrapper.style.height = scrollHeightPx;
+        (_p$onScrollHeightChan = p.onScrollHeightChange) === null || _p$onScrollHeightChan === void 0 || _p$onScrollHeightChan.call(p, scrollHeight);
+      }
+
+      if (originalWidth !== list.clientWidth)
+      this.render();
+    } else {// non-virtual
+      if (count !== existingEls.length) {
+        for (let i = 0; i < existingCount; i++) {
+          existingEls[i][ReuseElSymbol] = true;
+        }
+
+        // Find the element to insert before
+        let before = itemParent.childNodes[0];
+
+        /** @type DocumentFragment|null */
+        let fragment = null;
+
+        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];
+          }
+
+          if (before && before === existingEl)
+          before = before.nextSibling;
+
+          // Dequeue the element by reusing or creating a new one
+          const itemEl = this._dequeueElementForIndex(existingEl, index, before, true);
+
+          fragment = insertBeforeWithFragment(itemEl, fragment, before, itemParent);
+        }
+
+        // Insert any remaining fragment
+        if (fragment && fragment.childNodes.length > 0) {
+          insertBefore(fragment, before, itemParent);
+        }
+      }
+    }
+
+    // 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 < 0 || 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;
+
+      const itemParent = p.currentItemsParent;
+
+      let startIndex = existingRange.firstValidArrayIndex + atIndex - existingRange.firstIndex;
+
+      this._pushItemIndexesAt(atIndex, count);
+
+      /** @type Node|undefined */
+      let before = existingEls[startIndex - 1] ?
+      existingEls[startIndex - 1].nextSibling :
+      existingEls[0];
+
+      /** @type DocumentFragment|null */
+      let fragment = null;
+
+      for (let index = atIndex, end = atIndex + count; index < end; index++) {
+        const itemEl = this._dequeueElementForIndex(undefined, index, before, true);
+        fragment = insertBeforeWithFragment(itemEl, fragment, before, itemParent);
+      }
+
+      // Insert any remaining fragment
+      if (fragment && fragment.childNodes.length > 0) {
+        insertBefore(fragment, before, itemParent);
+      }
+    }
+
+    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, false);
+      }
+    }
+
+    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 getElementOffset(itemEl).top - 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, true);
+    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
+   * @param {boolean|undefined} avoidDomReflow
+   * @returns {Element}
+   * @private
+   */
+  _dequeueElementForIndex(itemEl, index, insertBefore, avoidDomReflow) {
+    const p = this._p;
+    const virtualWrapper = p.virtualWrapper;
+    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;
+
+      // 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 (!avoidDomReflow) {
+        this._insertItemAndFlow(itemEl, index, insertBefore);
+      }
+    }
+
+    // Add index metadata to item
+    itemEl[ItemIndexSymbol] = index;
+
+    return itemEl;
+  }
+
+  /**
+   * Insert item element into the DOM, set it's flow in the DOM, and update the item's position. <br />
+   * @param {Element|undefined} itemEl
+   * @param {number} index
+   * @param {Node|boolean|undefined} before
+   * @private
+   */
+  _insertItemAndFlow(itemEl, index, before) {
+    const p = this._p;
+    const virtualWrapper = p.virtualWrapper;
+    const itemParent = p.currentItemsParent;
+
+    if (before !== false) {
+      if (!(before instanceof Node))
+      before = null;
+
+      // Insert into DOM
+      if (itemEl.parentNode !== itemParent ||
+      itemEl.nextSibling !== before) {
+        insertBefore(itemEl, before, itemParent);
+      }
+    }
+
+    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)`;
+      }
+    }
+  }
+
+  /**
+   * 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.call(existingEls[i], ItemIndexSymbol))
+      continue;
+      firstValidArrayIndex = i;
+      break;
+    }
+
+    for (let i = existingEls.length - 1; i >= 0; i--) {
+      if (false === hasOwnProperty.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;
+};
+
+class DomEventsSink {
+  constructor() {
+    /**
+     * @type {{el: EventTarget, name: string, handler: EventListenerOrEventListenerObject, useCapture: boolean}[]}
+     * @private
+     */
+    this._events = [];
+  }
+
+  /**
+   * @param {EventTarget} el
+   * @param {string} eventName
+   * @param {EventListenerOrEventListenerObject} handler
+   * @param {boolean|AddEventListenerOptions} [optionsOrCapture=undefined]
+   * @returns {DomEventsSink}
+   */
+  add(el, eventName, handler, optionsOrCapture) {
+    let parts = eventName.split('.');
+    let name = parts[0];
+    let namespace = parts[1];
+
+    el.addEventListener(name, handler, optionsOrCapture ? optionsOrCapture : false);
+    let useCapture = optionsOrCapture === true || typeof optionsOrCapture === 'object' && optionsOrCapture.capture === true;
+    this._events.push({ el: el, name: name, namespace: namespace, handler: handler, useCapture: useCapture });
+    return this;
+  }
+
+  /**
+   * @param {EventTarget} [el=undefined]
+   * @param {string} [eventName=undefined]
+   * @param {EventListenerOrEventListenerObject} [handler=undefined]
+   * @param {boolean|EventListenerOptions} [optionsOrCapture=undefined]
+   * @returns {DomEventsSink}
+   */
+  remove(el, eventName, handler, optionsOrCapture) {
+    let parts = eventName ? eventName.split('.') : '';
+    let name = parts[0];
+    let namespace = parts[1];
+
+    let useCapture = optionsOrCapture === true || typeof optionsOrCapture === 'object' && optionsOrCapture.capture === true;
+
+    let keep = [];
+    let remove = [];
+
+    if (el || name || namespace || handler || optionsOrCapture !== undefined) {
+      for (let item of this._events) {
+        if (el && item.el !== el ||
+        name && item.name !== name ||
+        namespace && item.namespace !== namespace ||
+        handler && item.handler !== handler ||
+        optionsOrCapture !== undefined && item.useCapture !== useCapture) {
+          keep.push(item);
+        } else {
+          remove.push(item);
+        }
+      }
+    } else {
+      remove = this._events;
+    }
+
+    this._events = keep;
+
+    for (let item of remove) {
+      item.el.removeEventListener(item.name, item.handler, item.useCapture);
+    }
+    return this;
+  }
+}
+
+var h,c,m = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : {},f = {};function p() {if (c) return h;c = 1;var e = function (e) {return e && e.Math === Math && e;};return h = e("object" == typeof globalThis && globalThis) || e("object" == typeof window && window) || e("object" == typeof self && self) || e("object" == typeof m && m) || e("object" == typeof h && h) || function () {return this;}() || Function("return this")();}var v,g,b,C,w,y,_,S,W = {};function R() {return g ? v : (g = 1, v = function (e) {try {return !!e();} catch (e) {return true;}});}function N() {if (C) return b;C = 1;var e = R();return b = !e(function () {return 7 !== Object.defineProperty({}, 1, { get: function () {return 7;} })[1];});}function T() {if (y) return w;y = 1;var e = R();return w = !e(function () {var e = function () {}.bind();return "function" != typeof e || e.hasOwnProperty("prototype");});}function L() {if (S) return _;S = 1;var e = T(),t = Function.prototype.call;return _ = e ? t.bind(t) : function () {return t.apply(t, arguments);}, _;}var E,x,z,P,F,O,H,M,A,k,I,B,j,D,V,$,U,q,X,Y,G,J,K,Q,Z,ee,te,re,ie,le,oe,ne,se,ae,de,ue,he,ce,me,fe,pe,ve = {};function ge() {return z ? x : (z = 1, x = function (e, t) {return { enumerable: !(1 & e), configurable: !(2 & e), writable: !(4 & e), value: t };});}function be() {if (F) return P;F = 1;var e = T(),t = Function.prototype,r = t.call,i = e && t.bind.bind(r, r);return P = e ? i : function (e) {return function () {return r.apply(e, arguments);};}, P;}function Ce() {if (H) return O;H = 1;var e = be(),t = e({}.toString),r = e("".slice);return O = function (e) {return r(t(e), 8, -1);};}function we() {return I ? k : (I = 1, k = function (e) {return null == e;});}function ye() {if (j) return B;j = 1;var e = we(),t = TypeError;return B = function (r) {if (e(r)) throw new t("Can't call method on " + r);return r;};}function _e() {if (V) return D;V = 1;var e = function () {if (A) return M;A = 1;var e = be(),t = R(),r = Ce(),i = Object,l = e("".split);return M = t(function () {return !i("z").propertyIsEnumerable(0);}) ? function (e) {return "String" === r(e) ? l(e, "") : i(e);} : i;}(),t = ye();return D = function (r) {return e(t(r));};}function Se() {if (U) return $;U = 1;var e = "object" == typeof document && document.all;return $ = void 0 === e && void 0 !== e ? function (t) {return "function" == typeof t || t === e;} : function (e) {return "function" == typeof e;};}function We() {if (X) return q;X = 1;var e = Se();return q = function (t) {return "object" == typeof t ? null !== t : e(t);};}function Re() {if (G) return Y;G = 1;var e = p(),t = Se();return Y = function (r, i) {return arguments.length < 2 ? (l = e[r], t(l) ? l : void 0) : e[r] && e[r][i];var l;}, Y;}function Ne() {if (K) return J;K = 1;var e = be();return J = e({}.isPrototypeOf);}function Te() {if (Z) return Q;Z = 1;var e = p().navigator,t = e && e.userAgent;return Q = t ? String(t) : "";}function Le() {if (te) return ee;te = 1;var e,t,r = p(),i = Te(),l = r.process,o = r.Deno,n = l && l.versions || o && o.version,s = n && n.v8;return s && (t = (e = s.split("."))[0] > 0 && e[0] < 4 ? 1 : +(e[0] + e[1])), !t && i && (!(e = i.match(/Edge\/(\d+)/)) || e[1] >= 74) && (e = i.match(/Chrome\/(\d+)/)) && (t = +e[1]), ee = t;}function Ee() {if (ie) return re;ie = 1;var e = Le(),t = R(),r = p().String;return re = !!Object.getOwnPropertySymbols && !t(function () {var t = Symbol("symbol detection");return !r(t) || !(Object(t) instanceof Symbol) || !Symbol.sham && e && e < 41;});}function xe() {if (oe) return le;oe = 1;var e = Ee();return le = e && !Symbol.sham && "symbol" == typeof Symbol.iterator;}function ze() {if (se) return ne;se = 1;var e = Re(),t = Se(),r = Ne(),i = xe(),l = Object;return ne = i ? function (e) {return "symbol" == typeof e;} : function (i) {var o = e("Symbol");return t(o) && r(o.prototype, l(i));};}function Pe() {if (de) return ae;de = 1;var e = String;return ae = function (t) {try {return e(t);} catch (e) {return "Object";}};}function Fe() {if (he) return ue;he = 1;var e = Se(),t = Pe(),r = TypeError;return ue = function (i) {if (e(i)) return i;throw new r(t(i) + " is not a function");};}function Oe() {if (me) return ce;me = 1;var e = Fe(),t = we();return ce = function (r, i) {var l = r[i];return t(l) ? void 0 : e(l);};}function He() {if (pe) return fe;pe = 1;var e = L(),t = Se(),r = We(),i = TypeError;return fe = function (l, o) {var n, s;if ("string" === o && t(n = l.toString) && !r(s = e(n, l))) return s;if (t(n = l.valueOf) && !r(s = e(n, l))) return s;if ("string" !== o && t(n = l.toString) && !r(s = e(n, l))) return s;throw new i("Can't convert object to primitive value");};}var Me,Ae,ke,Ie,Be,je,De,Ve,$e,Ue,qe,Xe,Ye,Ge,Je,Ke,Qe,Ze,et,tt,rt,it,lt,ot,nt = { exports: {} };function st() {if (Ie) return ke;Ie = 1;var e = p(),t = Object.defineProperty;return ke = function (r, i) {try {t(e, r, { value: i, configurable: !0, writable: !0 });} catch (t) {e[r] = i;}return i;};}function at() {if (Be) return nt.exports;Be = 1;var e = Ae ? Me : (Ae = 1, Me = false),t = p(),r = st(),i = "__core-js_shared__",l = nt.exports = t[i] || r(i, {});return (l.versions || (l.versions = [])).push({ version: "3.47.0", mode: e ? "pure" : "global", copyright: "© 2014-2025 Denis Pushkarev (zloirock.ru), 2025 CoreJS Company (core-js.io)", license: "https://github.com/zloirock/core-js/blob/v3.47.0/LICENSE", source: "https://github.com/zloirock/core-js" }), nt.exports;}function dt() {if (De) return je;De = 1;var e = at();return je = function (t, r) {return e[t] || (e[t] = r || {});};}function ut() {if ($e) return Ve;$e = 1;var e = ye(),t = Object;return Ve = function (r) {return t(e(r));};}function ht() {if (qe) return Ue;qe = 1;var e = be(),t = ut(),r = e({}.hasOwnProperty);return Ue = Object.hasOwn || function (e, i) {return r(t(e), i);};}function ct() {if (Ye) return Xe;Ye = 1;var e = be(),t = 0,r = Math.random(),i = e(1.1.toString);return Xe = function (e) {return "Symbol(" + (void 0 === e ? "" : e) + ")_" + i(++t + r, 36);};}function mt() {if (Je) return Ge;Je = 1;var e = p(),t = dt(),r = ht(),i = ct(),l = Ee(),o = xe(),n = e.Symbol,s = t("wks"),a = o ? n.for || n : n && n.withoutSetter || i;return Ge = function (e) {return r(s, e) || (s[e] = l && r(n, e) ? n[e] : a("Symbol." + e)), s[e];};}function ft() {if (Qe) return Ke;Qe = 1;var e = L(),t = We(),r = ze(),i = Oe(),l = He(),o = mt(),n = TypeError,s = o("toPrimitive");return Ke = function (o, a) {if (!t(o) || r(o)) return o;var d,u = i(o, s);if (u) {if (void 0 === a && (a = "default"), d = e(u, o, a), !t(d) || r(d)) return d;throw new n("Can't convert object to primitive value");}return void 0 === a && (a = "number"), l(o, a);};}function pt() {if (et) return Ze;et = 1;var e = ft(),t = ze();return Ze = function (r) {var i = e(r, "string");return t(i) ? i : i + "";};}function vt() {if (lt) return it;lt = 1;var e = N(),t = R(),r = function () {if (rt) return tt;rt = 1;var e = p(),t = We(),r = e.document,i = t(r) && t(r.createElement);return tt = function (e) {return i ? r.createElement(e) : {};};}();return it = !e && !t(function () {return 7 !== Object.defineProperty(r("div"), "a", { get: function () {return 7;} }).a;});}function gt() {if (ot) return W;ot = 1;var e = N(),t = L(),r = function () {if (E) return ve;E = 1;var e = {}.propertyIsEnumerable,t = Object.getOwnPropertyDescriptor,r = t && !e.call({ 1: 2 }, 1);return ve.f = r ? function (e) {var r = t(this, e);return !!r && r.enumerable;} : e, ve;}(),i = ge(),l = _e(),o = pt(),n = ht(),s = vt(),a = Object.getOwnPropertyDescriptor;return W.f = e ? a : function (e, d) {if (e = l(e), d = o(d), s) try {return a(e, d);} catch (e) {}if (n(e, d)) return i(!t(r.f, e, d), e[d]);}, W;}var bt,Ct,wt,yt,_t,St,Wt,Rt = {};function Nt() {if (yt) return wt;yt = 1;var e = We(),t = String,r = TypeError;return wt = function (i) {if (e(i)) return i;throw new r(t(i) + " is not an object");};}function Tt() {if (_t) return Rt;_t = 1;var e = N(),t = vt(),r = function () {if (Ct) return bt;Ct = 1;var e = N(),t = R();return bt = e && t(function () {return 42 !== Object.defineProperty(function () {}, "prototype", { value: 42, writable: false }).prototype;});}(),i = Nt(),l = pt(),o = TypeError,n = Object.defineProperty,s = Object.getOwnPropertyDescriptor,a = "enumerable",d = "configurable",u = "writable";return Rt.f = e ? r ? function (e, t, r) {if (i(e), t = l(t), i(r), "function" == typeof e && "prototype" === t && "value" in r && u in r && !r[u]) {var o = s(e, t);o && o[u] && (e[t] = r.value, r = { configurable: d in r ? r[d] : o[d], enumerable: a in r ? r[a] : o[a], writable: false });}return n(e, t, r);} : n : function (e, r, s) {if (i(e), r = l(r), i(s), t) try {return n(e, r, s);} catch (e) {}if ("get" in s || "set" in s) throw new o("Accessors not supported");return "value" in s && (e[r] = s.value), e;}, Rt;}function Lt() {if (Wt) return St;Wt = 1;var e = N(),t = Tt(),r = ge();return St = e ? function (e, i, l) {return t.f(e, i, r(1, l));} : function (e, t, r) {return e[t] = r, e;};}var Et,xt,zt,Pt,Ft,Ot,Ht,Mt,At,kt,It,Bt,jt,Dt,Vt,$t = { exports: {} };function Ut() {if (Pt) return zt;Pt = 1;var e = be(),t = Se(),r = at(),i = e(Function.toString);return t(r.inspectSource) || (r.inspectSource = function (e) {return i(e);}), zt = r.inspectSource;}function qt() {if (Mt) return Ht;Mt = 1;var e = dt(),t = ct(),r = e("keys");return Ht = function (e) {return r[e] || (r[e] = t(e));};}function Xt() {return kt ? At : (kt = 1, At = {});}function Yt() {if (jt) return $t.exports;jt = 1;var e = be(),t = R(),r = Se(),i = ht(),l = N(),o = function () {if (xt) return Et;xt = 1;var e = N(),t = ht(),r = Function.prototype,i = e && Object.getOwnPropertyDescriptor,l = t(r, "name"),o = l && "something" === function () {}.name,n = l && (!e || e && i(r, "name").configurable);return Et = { EXISTS: l, PROPER: o, CONFIGURABLE: n };}().CONFIGURABLE,n = Ut(),s = function () {if (Bt) return It;Bt = 1;var e,t,r,i = function () {if (Ot) return Ft;Ot = 1;var e = p(),t = Se(),r = e.WeakMap;return Ft = t(r) && /native code/.test(String(r));}(),l = p(),o = We(),n = Lt(),s = ht(),a = at(),d = qt(),u = Xt(),h = "Object already initialized",c = l.TypeError,m = l.WeakMap;if (i || a.state) {var f = a.state || (a.state = new m());f.get = f.get, f.has = f.has, f.set = f.set, e = function (e, t) {if (f.has(e)) throw new c(h);return t.facade = e, f.set(e, t), t;}, t = function (e) {return f.get(e) || {};}, r = function (e) {return f.has(e);};} else {var v = d("state");u[v] = true, e = function (e, t) {if (s(e, v)) throw new c(h);return t.facade = e, n(e, v, t), t;}, t = function (e) {return s(e, v) ? e[v] : {};}, r = function (e) {return s(e, v);};}return It = { set: e, get: t, has: r, enforce: function (i) {return r(i) ? t(i) : e(i, {});}, getterFor: function (e) {return function (r) {var i;if (!o(r) || (i = t(r)).type !== e) throw new c("Incompatible receiver, " + e + " required");return i;};} };}(),a = s.enforce,d = s.get,u = String,h = Object.defineProperty,c = e("".slice),m = e("".replace),f = e([].join),v = l && !t(function () {return 8 !== h(function () {}, "length", { value: 8 }).length;}),g = String(String).split("String"),b = $t.exports = function (e, t, r) {"Symbol(" === c(u(t), 0, 7) && (t = "[" + m(u(t), /^Symbol\(([^)]*)\).*$/, "$1") + "]"), r && r.getter && (t = "get " + t), r && r.setter && (t = "set " + t), (!i(e, "name") || o && e.name !== t) && (l ? h(e, "name", { value: t, configurable: true }) : e.name = t), v && r && i(r, "arity") && e.length !== r.arity && h(e, "length", { value: r.arity });try {r && i(r, "constructor") && r.constructor ? l && h(e, "prototype", { writable: !1 }) : e.prototype && (e.prototype = void 0);} catch (e) {}var n = a(e);return i(n, "source") || (n.source = f(g, "string" == typeof t ? t : "")), e;};return Function.prototype.toString = b(function () {return r(this) && d(this).source || n(this);}, "toString"), $t.exports;}function Gt() {if (Vt) return Dt;Vt = 1;var e = Se(),t = Tt(),r = Yt(),i = st();return Dt = function (l, o, n, s) {s || (s = {});var a = s.enumerable,d = void 0 !== s.name ? s.name : o;if (e(n) && r(n, d, s), s.global) a ? l[o] = n : i(o, n);else {try {s.unsafe ? l[o] && (a = !0) : delete l[o];} catch (e) {}a ? l[o] = n : t.f(l, o, { value: n, enumerable: false, configurable: !s.nonConfigurable, writable: !s.nonWritable });}return l;};}var Jt,Kt,Qt,Zt,er,tr,rr,ir,lr,or,nr,sr,ar,dr,ur,hr,cr,mr = {};function fr() {if (Zt) return Qt;Zt = 1;var e = function () {if (Kt) return Jt;Kt = 1;var e = Math.ceil,t = Math.floor;return Jt = Math.trunc || function (r) {var i = +r;return (i > 0 ? t : e)(i);};}();return Qt = function (t) {var r = +t;return r != r || 0 === r ? 0 : e(r);};}function pr() {if (tr) return er;tr = 1;var e = fr(),t = Math.max,r = Math.min;return er = function (i, l) {var o = e(i);return o < 0 ? t(o + l, 0) : r(o, l);};}function vr() {if (ir) return rr;ir = 1;var e = fr(),t = Math.min;return rr = function (r) {var i = e(r);return i > 0 ? t(i, 9007199254740991) : 0;};}function gr() {if (or) return lr;or = 1;var e = vr();return lr = function (t) {return e(t.length);};}var br,Cr,wr,yr,_r,Sr,Wr,Rr,Nr,Tr,Lr,Er,xr,zr,Pr,Fr,Or,Hr,Mr = {};function Ar() {if (wr) return Cr;wr = 1;var e = Re(),t = be(),r = function () {if (cr) return mr;cr = 1;var e = function () {if (dr) return ar;dr = 1;var e = be(),t = ht(),r = _e(),i = function () {if (sr) return nr;sr = 1;var e = _e(),t = pr(),r = gr(),i = function (i) {return function (l, o, n) {var s = e(l),a = r(s);if (0 === a) return !i && -1;var d,u = t(n, a);if (i && o != o) {for (; a > u;) if ((d = s[u++]) != d) return true;} else for (; a > u; u++) if ((i || u in s) && s[u] === o) return i || u || 0;return !i && -1;};};return nr = { includes: i(true), indexOf: i(false) };}().indexOf,l = Xt(),o = e([].push);return ar = function (e, n) {var s,a = r(e),d = 0,u = [];for (s in a) !t(l, s) && t(a, s) && o(u, s);for (; n.length > d;) t(a, s = n[d++]) && (~i(u, s) || o(u, s));return u;};}(),t = (hr ? ur : (hr = 1, ur = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"])).concat("length", "prototype");return mr.f = Object.getOwnPropertyNames || function (r) {return e(r, t);}, mr;}(),i = (br || (br = 1, Mr.f = Object.getOwnPropertySymbols), Mr),l = Nt(),o = t([].concat);return Cr = e("Reflect", "ownKeys") || function (e) {var t = r.f(l(e)),n = i.f;return n ? o(t, n(e)) : t;};}function kr() {if (_r) return yr;_r = 1;var e = ht(),t = Ar(),r = gt(),i = Tt();return yr = function (l, o, n) {for (var s = t(o), a = i.f, d = r.f, u = 0; u < s.length; u++) {var h = s[u];e(l, h) || n && e(n, h) || a(l, h, d(o, h));}};}function Ir() {if (Nr) return Rr;Nr = 1;var e = p(),t = gt().f,r = Lt(),i = Gt(),l = st(),o = kr(),n = function () {if (Wr) return Sr;Wr = 1;var e = R(),t = Se(),r = /#|\.prototype\./,i = function (r, i) {var a = o[l(r)];return a === s || a !== n && (t(i) ? e(i) : !!i);},l = i.normalize = function (e) {return String(e).replace(r, ".").toLowerCase();},o = i.data = {},n = i.NATIVE = "N",s = i.POLYFILL = "P";return Sr = i;}();return Rr = function (s, a) {var d,u,h,c,m,f = s.target,p = s.global,v = s.stat;if (d = p ? e : v ? e[f] || l(f, {}) : e[f] && e[f].prototype) for (u in a) {if (c = a[u], h = s.dontCallGetSet ? (m = t(d, u)) && m.value : d[u], !n(p ? u : f + (v ? "." : "#") + u, s.forced) && void 0 !== h) {if (typeof c == typeof h) continue;o(c, h);}(s.sham || h && h.sham) && r(c, "sham", true), i(d, u, c, s);}};}function Br() {if (xr) return Er;xr = 1;var e = function () {if (Lr) return Tr;Lr = 1;var e = {};return e[mt()("toStringTag")] = "z", Tr = "[object z]" === String(e);}(),t = Se(),r = Ce(),i = mt()("toStringTag"),l = Object,o = "Arguments" === r(function () {return arguments;}());return Er = e ? r : function (e) {var n, s, a;return void 0 === e ? "Undefined" : null === e ? "Null" : "string" == typeof (s = function (e, t) {try {return e[t];} catch (e) {}}(n = l(e), i)) ? s : o ? r(n) : "Object" === (a = r(n)) && t(n.callee) ? "Arguments" : a;};}function jr() {if (Pr) return zr;Pr = 1;var e = Br(),t = String;return zr = function (r) {if ("Symbol" === e(r)) throw new TypeError("Cannot convert a Symbol value to a string");return t(r);};}function Dr() {if (Or) return Fr;Or = 1;var e = Yt(),t = Tt();return Fr = function (r, i, l) {return l.get && e(l.get, i, { getter: true }), l.set && e(l.set, i, { setter: true }), t.f(r, i, l);};}!function () {if (Hr) return f;Hr = 1;var e = Ir(),t = N(),r = p(),i = be(),l = ht(),o = Se(),n = Ne(),s = jr(),a = Dr(),d = kr(),u = r.Symbol,h = u && u.prototype;if (t && o(u) && (!("description" in h) || void 0 !== u().description)) {var c = {},m = function () {var e = arguments.length < 1 || void 0 === arguments[0] ? void 0 : s(arguments[0]),t = n(h, this) ? new u(e) : void 0 === e ? u() : u(e);return "" === e && (c[t] = true), t;};d(m, u), m.prototype = h, h.constructor = m;var v = "Symbol(description detection)" === String(u("description detection")),g = i(h.valueOf),b = i(h.toString),C = /^Symbol\((.*)\)[^)]+$/,w = i("".replace),y = i("".slice);a(h, "description", { configurable: true, get: function () {var e = g(this);if (l(c, e)) return "";var t = b(e),r = v ? y(t, 7, -1) : w(t, C, "$1");return "" === r ? void 0 : r;} }), e({ global: true, constructor: true, forced: true }, { Symbol: m });}}();var Vr,$r,Ur,qr,Xr,Yr,Gr,Jr,Kr,Qr,Zr,ei,ti,ri,ii,li = {};function oi() {if ($r) return Vr;$r = 1;var e = Pe(),t = TypeError;return Vr = function (r, i) {if (!delete r[i]) throw new t("Cannot delete property " + e(i) + " of " + e(r));};}function ni() {if (qr) return Ur;qr = 1;var e = be();return Ur = e([].slice);}function si() {if (Jr) return Gr;Jr = 1;var e = R();return Gr = function (t, r) {var i = [][t];return !!i && e(function () {i.call(null, r || function () {return 1;}, 1);});};}!function () {if (ii) return li;ii = 1;var e = Ir(),t = be(),r = Fe(),i = ut(),l = gr(),o = oi(),n = jr(),s = R(),a = function () {if (Yr) return Xr;Yr = 1;var e = ni(),t = Math.floor,r = function (i, l) {var o = i.length;if (o < 8) for (var n, s, a = 1; a < o;) {for (s = a, n = i[a]; s && l(i[s - 1], n) > 0;) i[s] = i[--s];s !== a++ && (i[s] = n);} else for (var d = t(o / 2), u = r(e(i, 0, d), l), h = r(e(i, d), l), c = u.length, m = h.length, f = 0, p = 0; f < c || p < m;) i[f + p] = f < c && p < m ? l(u[f], h[p]) <= 0 ? u[f++] : h[p++] : f < c ? u[f++] : h[p++];return i;};return Xr = r;}(),d = si(),u = function () {if (Qr) return Kr;Qr = 1;var e = Te().match(/firefox\/(\d+)/i);return Kr = !!e && +e[1];}(),h = function () {if (ei) return Zr;ei = 1;var e = Te();return Zr = /MSIE|Trident/.test(e);}(),c = Le(),m = function () {if (ri) return ti;ri = 1;var e = Te().match(/AppleWebKit\/(\d+)\./);return ti = !!e && +e[1];}(),f = [],p = t(f.sort),v = t(f.push),g = s(function () {f.sort(void 0);}),b = s(function () {f.sort(null);}),C = d("sort"),w = !s(function () {if (c) return c < 70;if (!(u && u > 3)) {if (h) return true;if (m) return m < 603;var e,t,r,i,l = "";for (e = 65; e < 76; e++) {switch (t = String.fromCharCode(e), e) {case 66:case 69:case 70:case 72:r = 3;break;case 68:case 71:r = 4;break;default:r = 2;}for (i = 0; i < 47; i++) f.push({ k: t + i, v: r });}for (f.sort(function (e, t) {return t.v - e.v;}), i = 0; i < f.length; i++) t = f[i].k.charAt(0), l.charAt(l.length - 1) !== t && (l += t);return "DGBEFHACIJK" !== l;}});e({ target: "Array", proto: true, forced: g || !b || !C || !w }, { sort: function (e) { void 0 !== e && r(e);var t = i(this);if (w) return void 0 === e ? p(t) : p(t, e);var s,d,u = [],h = l(t);for (d = 0; d < h; d++) d in t && v(u, t[d]);for (a(u, function (e) {return function (t, r) {return void 0 === r ? -1 : void 0 === t ? 1 : void 0 !== e ? +e(t, r) || 0 : n(t) > n(r) ? 1 : -1;};}(e)), s = l(u), d = 0; d < s;) t[d] = u[d++];for (; d < h;) o(t, d++);return t;} });}();const ai = function (e, t) {for (let r = 0, i = e.length; r >= 0 && r < i; r += 1) if (t(e[r], r, e)) return e[r];},di = function (e) {return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&#39;").replace(/"/g, "&quot;").replace(/\n/g, "<br />");};function ui() {let e = [];return Object.assign(e, ui.prototype), e.initialize.apply(e, arguments), e;}ui.prototype = [], ui.prototype.initialize = function (e) {e = e || {}, this.sortColumn = null == e.sortColumn ? [] : e.sortColumn;}, ui.prototype.add = function (e, t) {let r, i;if ("splice" in e && "length" in e) {if ("number" == typeof t) for (r = 0, i = e.length; r < i; r++) this.splice(t++, 0, e[r]);else for (r = 0, i = e.length; r < i; r++) this.push(e[r]);} else "number" == typeof t ? this.splice(t, 0, e) : this.push(e);}, ui.prototype.reset = function (e) {this.length = 0, e && this.add(e);}, ui.prototype.filteredCollection = function (e, t) {if (e && t) {let r = new ui({ sortColumn: this.sortColumn, onComparatorRequired: this.onComparatorRequired, customSortingProvider: this.customSortingProvider });for (let i, l = 0, o = this.length; l < o; l++) i = this[l], e(i, t) && (i.__i = l, r.push(i));return r;}return null;}, ui.prototype.onComparatorRequired = null, ui.prototype.customSortingProvider = null;let hi = ui.prototype.sort;function ci(e, t) {let r = e.column,i = e.comparePath || r;"string" == typeof i && (i = i.split("."));let l,o = i.length,n = o > 1,s = t ? 1 : -1,a = t ? -1 : 1;return function (e, t) {let r = e[i[0]],d = t[i[0]];if (n) for (l = 1; l < o; l++) r = r && r[i[l]], d = d && d[i[l]];return r === d ? 0 : null == r ? s : null == d ? a : r < d ? s : a;};}function mi() {let e = [];return Object.assign(e, mi.prototype), e.initialize.apply(e, arguments), e;}ui.prototype.sort = function () {let e;if (this.sortColumn.length) {let t = [];for (let r = 0; r < this.sortColumn.length; r++) {e = null;const i = ci(this.sortColumn[r], this.sortColumn[r].descending);this.onComparatorRequired && (e = this.onComparatorRequired(this.sortColumn[r].column, this.sortColumn[r].descending, i)), e || (e = i), t.push(e.bind(this));}if (1 === t.length) e = t[0];else {let r,i = t.length;e = function (e, l) {for (let o = 0; o < i; o++) if (r = t[o](e, l), 0 !== r) return r;return r;};}const r = (t) => hi.call(t, e);if (this.customSortingProvider) {let e = this.customSortingProvider(this, r);e !== this && this.splice(0, this.length, ...e);} else r(this);}return e;}, mi.prototype = [], mi.prototype.initialize = function () {}, mi.prototype.get = function (e) {for (let t = 0, r = this.length; t < r; t++) if (this[t].name === e) return this[t];return null;}, mi.prototype.indexOf = function (e) {for (let t = 0, r = this.length; t < r; t++) if (this[t].name === e) return t;return -1;}, mi.prototype.getByOrder = function (e) {for (let t = 0, r = this.length; t < r; t++) if (this[t].order === e) return this[t];return null;}, mi.prototype.normalizeOrder = function () {let e,t = [];for (e = 0; e < this.length; e++) t.push(this[e]);for (t.sort(function (e, t) {return e.order < t.order ? -1 : e.order > t.order ? 1 : 0;}), e = 0; e < t.length; e++) t[e].order = e;return this;}, mi.prototype.getColumns = function () {let e = [];for (let t, r = 0; r < this.length; r++) t = this[r], e.push(t);return e.sort((e, t) => e.order < t.order ? -1 : e.order > t.order ? 1 : 0), e;}, mi.prototype.getVisibleColumns = function () {let e = [];for (let t, r = 0; r < this.length; r++) t = this[r], t.visible && e.push(t);return e.sort((e, t) => e.order < t.order ? -1 : e.order > t.order ? 1 : 0), e;}, mi.prototype.getMaxOrder = function () {let e = 0;for (let t, r = 0; r < this.length; r++) t = this[r], t.order > e && (e = t.order);return e;}, mi.prototype.moveColumn = function (e, t) {if (e && t) {let r,i,l = e.order,o = t.order;if (l < o) for (r = l + 1; r <= o; r++) i = this.getByOrder(r), i.order--;else for (r = l - 1; r >= o; r--) i = this.getByOrder(r), i.order++;e.order = o;}return this;};class fi {static saveSelection(e) {let t = window.getSelection().getRangeAt(0);if (e !== t.commonAncestorContainer && !function (e, t) {for (; (e = e.parentNode) && e !== t;);return !!e;}(t.commonAncestorContainer, e)) return null;let r = t.cloneRange();r.selectNodeContents(e), r.setEnd(t.startContainer, t.startOffset);let i = r.toString().length;return { start: i, end: i + t.toString().length };}static restoreSelection(e, t) {let r,i = 0,l = [e],o = false,n = false,s = document.createRange();for (s.setStart(e, 0), s.collapse(true); !n && (r = l.pop());) if (3 === r.nodeType) {let e = i + r.length;!o && t.start >= i && t.start <= e && (s.setStart(r, t.start - i), o = true), o && t.end >= i && t.end <= e && (s.setEnd(r, t.end - i), n = true), i = e;} else {let e = r.childNodes.length;for (; e--;) l.push(r.childNodes[e]);}let a = window.getSelection();a.removeAllRanges(), a.addRange(s);}}function pi(e, t) {let r = t.column,i = null == t.keyword ? "" : t.keyword.toString();if (!i || !r) return true;let l = e[r];return null != l && (l = l.toString(), t.caseSensitive || (l = l.toLowerCase(), i = i.toLowerCase()), -1 !== l.indexOf(i));}const vi = Array.prototype.indexOf;let gi = document.createElement.bind(document);const bi = Object.prototype.hasOwnProperty,Ci = Symbol("safe"),wi = Symbol("hover_in"),yi = Symbol("hover_out"),_i = Symbol("row_click"),Si = Symbol("preview_cell"),Wi = Symbol("cell");function Ri(e) {["relative", "absolute", "fixed"].includes(getComputedStyle(e).position) || (e.style.position = "relative");}const Ni = (e) => /^(?:INPUT|TEXTAREA|BUTTON|SELECT)$/.test(e.target.tagName);class Ti {constructor(e) {this._init(e), this.VERSION = Ti.VERSION;}_init(e) {e = e || {};let t = this._o = {},r = this._p = { eventsSink: new DomEventsSink(), mitt: { all: i = i || new Map(), on: function (e, t) {var r = i.get(e);r ? r.push(t) : i.set(e, [t]);}, off: function (e, t) {var r = i.get(e);r && (t ? r.splice(r.indexOf(t) >>> 0, 1) : i.set(e, []));}, emit: function (e, t) {var r = i.get(e);r && r.slice().map(function (e) {e(t);}), (r = i.get("*")) && r.slice().map(function (r) {r(e, t);});} }, tableSkeletonNeedsRendering: true };var i;this.el = e.el && e.el instanceof Element ? e.el : document.createElement("div"), this.el !== e.el && this.el.classList.add(e.className || "dgtable-wrapper"), r.eventsSink.add(this.el, "dragend.colresize", this._onEndDragColumnHeader.bind(this)), t.virtualTable = void 0 === e.virtualTable || !!e.virtualTable, t.estimatedRowHeight = e.estimatedRowHeight || void 0, t.rowsBufferSize = e.rowsBufferSize || 3, t.minColumnWidth = Math.max(e.minColumnWidth || 35, 0), t.resizeAreaWidth = e.resizeAreaWidth || 8, t.resizableColumns = void 0 === e.resizableColumns || !!e.resizableColumns, t.movableColumns = void 0 === e.movableColumns || !!e.movableColumns, t.sortableColumns = void 0 === e.sortableColumns ? 1 : parseInt(e.sortableColumns, 10) || 1, t.adjustColumnWidthForSortArrow = void 0 === e.adjustColumnWidthForSortArrow || !!e.adjustColumnWidthForSortArrow, t.convertColumnWidthsToRelative = void 0 !== e.convertColumnWidthsToRelative && !!e.convertColumnWidthsToRelative, t.autoFillTableWidth = void 0 !== e.autoFillTableWidth && !!e.autoFillTableWidth, t.allowCancelSort = void 0 === e.allowCancelSort || !!e.allowCancelSort, t.cellClasses = void 0 === e.cellClasses ? "" : e.cellClasses, t.resizerClassName = void 0 === e.resizerClassName ? "dgtable-resize" : e.resizerClassName, t.tableClassName = void 0 === e.tableClassName ? "dgtable" : e.tableClassName, t.allowCellPreview = void 0 === e.allowCellPreview || e.allowCellPreview, t.allowHeaderCellPreview = void 0 === e.allowHeaderCellPreview || e.allowHeaderCellPreview, t.cellPreviewClassName = void 0 === e.cellPreviewClassName ? "dgtable-cell-preview" : e.cellPreviewClassName, t.cellPreviewAutoBackground = void 0 === e.cellPreviewAutoBackground || e.cellPreviewAutoBackground, t.onComparatorRequired = void 0 === e.onComparatorRequired ? null : e.onComparatorRequired, t.onComparatorRequired || "function" != typeof e.comparatorCallback || (t.onComparatorRequired = e.comparatorCallback), t.customSortingProvider = void 0 === e.customSortingProvider ? null : e.customSortingProvider, t.width = void 0 === e.width ? Ti.Width.NONE : e.width, t.relativeWidthGrowsToFillWidth = void 0 === e.relativeWidthGrowsToFillWidth || !!e.relativeWidthGrowsToFillWidth, t.relativeWidthShrinksToFillWidth = void 0 !== e.relativeWidthShrinksToFillWidth && !!e.relativeWidthShrinksToFillWidth, this.setCellFormatter(e.cellFormatter), this.setHeaderCellFormatter(e.headerCellFormatter), this.setFilter(e.filter), t.height = e.height, this.setColumns(e.columns || [], false);let l = [];if (e.sortColumn) {let t = e.sortColumn;if (t && !Array.isArray(t) && (t = [t]), t) for (let e = 0, i = t.length; e < i; e++) {let i = t[e];"string" == typeof i && (i = { column: i, descending: false });let o = r.columns.get(i.column);o && l.push({ column: i.column, comparePath: o.comparePath || o.dataPath, descending: i.descending });}}r.rows = new ui({ sortColumn: l }), r.rows.onComparatorRequired = (e, r, i) => {if (t.onComparatorRequired) return t.onComparatorRequired(e, r, i);}, r.rows.customSortingProvider = (e, r) => t.customSortingProvider ? t.customSortingProvider(e, r) : r(e), r.filteredRows = null, r.scrollbarWidth = 0, r.lastVirtualScrollHeight = 0, this._setupHovers();}_setupHovers() {const e = this._p;let t = (e) => {let t = e.currentTarget,r = e.relatedTarget;r === t || t.contains(r) || t[Si] && (r === t[Si] || t[Si].contains(r)) || this._cellMouseOverEvent(t);},r = (e) => {let t = e.currentTarget[Wi] || e.currentTarget,r = e.relatedTarget;r === this || t.contains(r) || t[Si] && (r === t[Si] || t[Si].contains(r)) || this._cellMouseOutEvent(t);};e._bindCellHoverIn = (e) => {e[wi] || e.addEventListener("mouseover", e[wi] = t);}, e._unbindCellHoverIn = (e) => {e[wi] && (e.removeEventListener("mouseover", e[wi]), e[wi] = null);}, e._bindCellHoverOut = (e) => {e[yi] || e.addEventListener("mouseout", e[yi] = r);}, e._unbindCellHoverOut = (e) => {e[yi] && (e.removeEventListener("mouseout", e[yi]), e[yi] = null);};}_setupVirtualTable() {var e;const t = this._p,r = this._o,i = r.tableClassName,l = i + "-row",o = i + "-row-alt",n = i + "-cell";let s = t.visibleColumns,a = s.length;t.notifyRendererOfColumnsConfig = () => {s = t.visibleColumns, a = s.length;for (let e, t = 0; t < a; t++) e = s[t], e._finalWidth = e.actualWidthConsideringScrollbarWidth || e.actualWidth;}, t.virtualListHelper = new VirtualListHelper({ list: t.table, itemsParent: t.tbody, autoVirtualWrapperWidth: false, virtual: r.virtualTable, buffer: r.rowsBufferSize, estimatedItemHeight: r.estimatedRowHeight ? r.estimatedRowHeight : t.virtualRowHeight || 40, itemElementCreatorFn: () => gi("div"), onItemRender: (e, i) => {const d = t.filteredRows || t.rows,u = !!t.filteredRows,h = r.allowCellPreview;e.className = l, i % 2 == 1 && (e.className += " " + o);let c = d[i],m = u ? c.__i : i;e.vIndex = i, e.index = m;for (let r = 0; r < a; r++) {let i = s[r],l = gi("div");l.columnName = i.name, l.setAttribute("data-column", i.name), l.className = n, l.style.width = i._finalWidth + "px", i.cellClasses && (l.className += " " + i.cellClasses), h && t._bindCellHoverIn(l), l.appendChild(gi("div")).innerHTML = this._getHtmlForCell(c, i), e.appendChild(l);}e.addEventListener("click", e[_i] = (t) => {this.emit("rowclick", { event: t, filteredRowIndex: i, rowIndex: m, rowEl: e, rowData: c });}), this.emit("rowcreate", { filteredRowIndex: i, rowIndex: m, rowEl: e, rowData: c });}, onItemUnrender: (e) => {e[_i] && e.removeEventListener("click", e[_i]), this._unbindCellEventsForRow(e), this.emit("rowdestroy", e);}, onScrollHeightChange: (e) => {e > t._lastVirtualScrollHeight && !t.scrollbarWidth && this._updateLastCellWidthFromScrollbar(), t._lastVirtualScrollHeight = e;} }), t.virtualListHelper.setCount((null !== (e = t.filteredRows) && void 0 !== e ? e : t.rows).length), t.notifyRendererOfColumnsConfig();}trigger(e) {const t = this._p;if (!t) return;let r = t.events;if (bi.call(r, e)) {let t = r[e];for (let e = 0; e < t.length; e++) {let r = t[e];r.once && t.splice(e--, 1), r.cb.apply(this, Array.prototype.slice.call(arguments, 1));}}return this;}on(e, t) {return this._p.mitt.on(e, t), this;}once(e, t) {let r = (i) => {this._p.mitt.off(e, r), t(i);};return this._p.mitt.on(e, r), this;}off(e, t) {return e || e ? this._p.mitt.off(e, t) : this._p.mitt.all.clear(), this;}emit(e, t) {return this._p.mitt.emit(e, t), this;}_parseColumnWidth(e, t) {let r = Math.max(0, parseFloat(e)),i = Li.AUTO;return r > 0 && (e === r + "%" ? (i = Li.RELATIVE, r /= 100) : r > 0 && r < 1 ? i = Li.RELATIVE : (r < t && (r = t), i = Li.ABSOLUTE)), { width: r, mode: i };}_initColumnFromData(e) {let t = this._parseColumnWidth(e.width, e.ignoreMin ? 0 : this._o.minColumnWidth),r = { name: e.name, label: void 0 === e.label ? e.name : e.label, width: t.width, widthMode: t.mode, resizable: void 0 === e.resizable || e.resizable, sortable: void 0 === e.sortable || e.sortable, movable: void 0 === e.movable || e.movable, visible: void 0 === e.visible || e.visible, cellClasses: void 0 === e.cellClasses ? this._o.cellClasses : e.cellClasses, ignoreMin: void 0 !== e.ignoreMin && !!e.ignoreMin };return r.dataPath = void 0 === e.dataPath ? r.name : e.dataPath, r.comparePath = void 0 === e.comparePath ? r.dataPath : e.comparePath, "string" == typeof r.dataPath && (r.dataPath = r.dataPath.split(".")), "string" == typeof r.comparePath && (r.comparePath = r.comparePath.split(".")), r;}destroy() {var e, t, r;let i = this._p || {},l = this.el;if (this.__removed) return this;if (i.resizer && (i.resizer.remove(), i.resizer = null), null === (e = i.virtualListHelper) || void 0 === e || e.destroy(), i.virtualListHelper = null, this._destroyHeaderCells(), null === (t = i.table) || void 0 === t || t.remove(), null === (r = i.tbody) || void 0 === r || r.remove(), i.workerListeners) {for (let e = 0; e < i.workerListeners.length; e++) {let t = i.workerListeners[e];t.worker.removeEventListener("message", t.listener, false);}i.workerListeners.length = 0;}i.rows.length = i.columns.length = 0, i._deferredRender && clearTimeout(i._deferredRender);for (let e in this) bi.call(this, e) && (this[e] = null);return this.__removed = true, l && l.remove(), this;}close() {this.destroy();}remove() {this.destroy();}_unbindCellEventsForTable() {const e = this._p;if (e.headerRow) for (let t = 0, r = e.headerRow.childNodes, i = r.length; t < i; t++) for (let i = 0, l = r[t].childNodes, o = l.length; i < o; i++) e._unbindCellHoverIn(l[i]);return this;}_unbindCellEventsForRow(e) {const t = this._p;for (let r = 0, i = e.childNodes, l = i.length; r < l; r++) t._unbindCellHoverIn(i[r]);return this;}render() {const r = this._o,i = this._p;if (!this.el.offsetParent) return i._deferredRender || (i._deferredRender = setTimeout(() => {i._deferredRender = null, !this.__removed && this.el.offsetParent && this.render();})), this;if (true === i.tableSkeletonNeedsRendering) {var l;i.tableSkeletonNeedsRendering = false, r.width === Ti.Width.AUTO && this._clearSortArrows();let o = i.table && i.table.parentNode ? i.table.scrollTop : NaN,n = i.table && i.table.parentNode ? getScrollHorz(i.table) : NaN;this._renderSkeletonBase()._renderSkeletonBody().tableWidthChanged(true, false)._renderSkeletonHeaderCells(), i.virtualListHelper.setCount((null !== (l = i.filteredRows) && void 0 !== l ? l : i.rows).length), this._updateVirtualHeight(), this._updateLastCellWidthFromScrollbar(true), this._updateTableWidth(true);for (let e = 0; e < i.rows.sortColumn.length; e++) this._showSortArrow(i.rows.sortColumn[e].column, i.rows.sortColumn[e].descending);r.adjustColumnWidthForSortArrow && i.rows.sortColumn.length ? this.tableWidthChanged(true) : r.virtualTable || this.tableWidthChanged(), isNaN(o) || (i.table.scrollTop = o), isNaN(n) || (setScrollHorz(i.table, n), setScrollHorz(i.header, n)), this.emit("renderskeleton");}return i.virtualListHelper.render(), this.emit("render"), this;}clearAndRender(e) {var t;let r = this._p;return r.tableSkeletonNeedsRendering = true, null === (t = r.notifyRendererOfColumnsConfig) || void 0 === t || t.call(r), (void 0 === e || e) && this.render(), this;}_calculateTbodyWidth() {const e = this._p;let t = this._o.tableClassName,l = t + "-row",o = t + "-cell",n = e.visibleColumns,s = n.length;const a = gi("div");a.className = l, a.style.float = "left";let d = 0;for (let e = 0; e < s; e++) {const t = n[e],r = gi("div");r.className = o, r.style.width = t.actualWidth + "px", t.cellClasses && (r.className += " " + t.cellClasses), r.appendChild(gi("div")), a.appendChild(r), d += t.actualWidth;}const u = gi("div");u.className = this.el.className, setCssProps(u, { "z-index": -1, position: "absolute", left: "0", top: "-9999px", float: "left", width: "1px", overflow: "hidden" });const h = gi("div");h.className = t, u.appendChild(h);const c = gi("div");c.className = t + "-body", c.style.width = d + 1e4 + "px", h.appendChild(c), c.appendChild(a), document.body.appendChild(u);const m = gi("div");setCssProps(m, { border: "1.5px solid #000", width: "0", height: "0", position: "absolute", left: "0", top: "-9999px" }), document.body.appendChild(m);let f = parseFloat(getComputedStyle(m).borderWidth),p = Math.round(f) !== f;m.remove();let v = getElementWidth(a, true, true, true);return v -= e.scrollbarWidth || 0, p && v++, u.remove(), v;}setColumns(e, t) {const r = this._p;e = e || [];let i = new mi();for (let t = 0, r = 0; t < e.length; t++) {let l = e[t],o = this._initColumnFromData(l);void 0 !== l.order ? (l.order > r && (r = l.order + 1), o.order = l.order) : o.order = r++, i.push(o);}return i.normalizeOrder(), r.columns = i, r.visibleColumns = i.getVisibleColumns(), this._ensureVisibleColumns().clearAndRender(t), this;}addColumn(e, t, r) {const i = this._p;let l = i.columns;if (e && !l.get(e.name)) {let o = null;void 0 !== t && (o = l.get(t) || l.getByOrder(t));let n = this._initColumnFromData(e);n.order = o ? o.order : l.getMaxOrder() + 1;for (let e = l.getMaxOrder(), t = n.order; e >= t; e--) {let t = l.getByOrder(e);t && t.order++;}l.push(n), l.normalizeOrder(), i.visibleColumns = l.getVisibleColumns(), this._ensureVisibleColumns().clearAndRender(r), this.emit("addcolumn", n.name);}return this;}removeColumn(e, t) {const r = this._p;let i = r.columns,l = i.indexOf(e);return l > -1 && (i.splice(l, 1), i.normalizeOrder(), r.visibleColumns = i.getVisibleColumns(), this._ensureVisibleColumns().clearAndRender(t), this.emit("removecolumn", e)), this;}setCellFormatter(e) {return e || ((e = (e) => "string" == typeof e ? di(e) : e)[Ci] = true), this._o.cellFormatter = e, this;}setHeaderCellFormatter(e) {return this._o.headerCellFormatter = e || function (e) {return "string" == typeof e ? di(e) : e;}, this;}setFilter(e) {return this._o.filter = e, this;}filter(e) {const t = this._p;let r = this._o.filter || pi;"string" == typeof arguments[0] && "string" == typeof arguments[1] && (e = { column: arguments[0], keyword: arguments[1], caseSensitive: arguments[2] });let i = !!t.filteredRows;return t.filteredRows && (t.filteredRows = null), t.filterArgs = null == e ? null : "object" != typeof e || Array.isArray(e) ? e : Object.assign({}, e), null !== t.filterArgs ? (t.filteredRows = t.rows.filteredCollection(r, t.filterArgs), (i || t.filteredRows) && (this.clearAndRender(), this.emit("filter", e))) : (t.filterArgs = null, t.filteredRows = null, this.clearAndRender(), this.emit("filterclear", {})), this;}clearFilter() {const e = this._p;return e.filteredRows && (e.filterArgs = null, e.filteredRows = null, this.clearAndRender(), this.emit("filterclear", {})), this;}_refilter() {const e = this._p;if (e.filteredRows && e.filterArgs) {let t = this._o.filter || pi;e.filteredRows = e.rows.filteredCollection(t, e.filterArgs);}return this;}setColumnLabel(e, t) {let r = this._p.columns.get(e);if (r && (r.label = void 0 === t ? r.name : t, r.element)) for (let e = 0; e < r.element.firstChild.childNodes.length; e++) {let t = r.element.firstChild.childNodes[e];if (3 === t.nodeType) {t.textContent = r.label;break;}}return this;}moveColumn(e, t, r = true) {const i = this._o,l = this._p;let o,n,a = l.columns,d = r ? l.visibleColumns : a.getColumns();if ("string" == typeof e ? o = a.get(e) : "number" == typeof e && (o = d[e]), "string" == typeof t ? n = a.get(t) : "number" == typeof t && (n = d[t]), o && n && e !== t) {let e = o.order,t = n.order,r = a.moveColumn(o, n).getVisibleColumns();if (l.visibleColumns.length !== r.length || l.visibleColumns.some((e, t) => e !== r[t])) if (l.visibleColumns = r, this._ensureVisibleColumns(), i.virtualTable) this.clearAndRender();else {const r = scopedSelectorAll(l.headerRow, `>div.${i.tableClassName}-header-cell`);let o = e < t ? t + 1 : t,n = e;r[0].parentNode.insertBefore(r[n], r[o]);let a = l.visibleColumns[e];a = (a.actualWidthConsideringScrollbarWidth || a.actualWidth) + "px";let d = l.visibleColumns[t];d = (d.actualWidthConsideringScrollbarWidth || d.actualWidth) + "px";let u = l.tbody.childNodes;for (let r = 0, i = u.length; r < i; r++) {let i = u[r];1 === i.nodeType && (i.insertBefore(i.childNodes[n], i.childNodes[o]), i.childNodes[t].firstChild.style.width = d, i.childNodes[e].firstChild.style.width = a);}}this.emit("movecolumn", { name: o.name, src: e, dest: t });}return this;}sort(e, t, r) {const i = this._o,l = this._p;let o,n = l.columns.get(e),s = l.rows.sortColumn;if (n) {if (r) {for (let e = 0; e < s.length; e++) if (s[e].column === n.name) {e < s.length - 1 ? s.length = 0 : (t = s[s.length - 1].descending, s.splice(s.length - 1, 1));break;}(i.sortableColumns > 0 && s.length >= i.sortableColumns || s.length >= l.visibleColumns.length) && (s.length = 0);} else s.length = 0;t = void 0 !== t && t, s.push({ column: n.name, comparePath: n.comparePath || n.dataPath, descending: !!t });} else s.length = 0;this._clearSortArrows();for (let e = 0; e < s.length; e++) this._showSortArrow(s[e].column, s[e].descending);i.adjustColumnWidthForSortArrow && !l.tableSkeletonNeedsRendering && this.tableWidthChanged(true), l.rows.sortColumn = s, s.length && (o = l.rows.sort(!!l.filteredRows), l.filteredRows && l.filteredRows.sort(!!l.filteredRows)), l.virtualListHelper && l.virtualListHelper.invalidate().render();let a = [];for (let e = 0; e < s.length; e++) a.push({ column: s[e].column, descending: s[e].descending });return this.emit("sort", { sorts: a, comparator: o }), this;}resort() {const e = this._p;let t = e.columns,r = e.rows.sortColumn;if (r.length) {for (let e = 0; e < r.length; e++) t.get(r[e].column) || r.splice(e--, 1);let i;e.rows.sortColumn = r, r.length && (i = e.rows.sort(!!e.filteredRows), e.filteredRows && e.filteredRows.sort(!!e.filteredRows));let l = [];for (let e = 0; e < r.length; e++) l.push({ column: r[e].column, descending: r[e].descending });this.emit("sort", { sorts: l, resort: true, comparator: i });}return this;}_ensureVisibleColumns() {const e = this._p;return 0 === e.visibleColumns.length && e.columns.length && (e.columns[0].visible = true, e.visibleColumns.push(e.columns[0]), this.emit("showcolumn", e.columns[0].name)), this;}setColumnVisible(e, t) {const r = this._p;let i = r.columns.get(e);return t = !!t, i && !!i.visible !== t && (i.visible = t, r.visibleColumns = r.columns.getVisibleColumns(), this.emit(t ? "showcolumn" : "hidecolumn", e), this._ensureVisibleColumns(), this.clearAndRender()), this;}isColumnVisible(e) {let t = this._p.columns.get(e);return !!t && t.visible;}setMinColumnWidth(e) {let t = this._o;return e = Math.max(e, 0), t.minColumnWidth !== e && (t.minColumnWidth = e, this.tableWidthChanged(true)), this;}getMinColumnWidth() {return this._o.minColumnWidth;}setSortableColumns(e) {const t = this._p,r = this._o;if (r.sortableColumns !== e && (r.sortableColumns = e, t.table)) {const e = scopedSelectorAll(t.headerRow, `>div.${r.tableClassName}-header-cell`);for (let i = 0, l = e.length; i < l; i++) e[i].classList[r.sortableColumns > 0 && t.visibleColumns[i].sortable ? "add" : "remove"]("sortable");}return this;}getSortableColumns() {return this._o.sortableColumns;}setMovableColumns(e) {let t = this._o;return e = void 0 === e || !!e, t.movableColumns !== e && (t.movableColumns = e), this;}getMovableColumns() {return this._o.movableColumns;}setResizableColumns(e) {let t = this._o;return e = void 0 === e || !!e, t.resizableColumns !== e && (t.resizableColumns = e), this;}getResizableColumns() {return this._o.resizableColumns;}setOnComparatorRequired(e) {let t = this._o;return t.onComparatorRequired !== e && (t.onComparatorRequired = e), this;}setComparatorCallback(e) {return this.setOnComparatorRequired(e);}setCustomSortingProvider(e) {let t = this._o;return t.customSortingProvider !== e && (t.customSortingProvider = e), this;}setColumnWidth(e, t) {let r = this._p.columns.get(e),i = this._parseColumnWidth(t, r.ignoreMin ? 0 : this._o.minColumnWidth);if (r) {let e = this._serializeColumnWidth(r);r.width = i.width, r.widthMode = i.mode;let t = this._serializeColumnWidth(r);e !== t && this.tableWidthChanged(true), this.emit("columnwidth", { name: r.name, width: t, oldWidth: e });}return this;}getColumnWidth(e) {let t = this._p.columns.get(e);return t ? this._serializeColumnWidth(t) : null;}getColumnConfig(e) {let t = this._p.columns.get(e);return t ? { order: t.order, width: this._serializeColumnWidth(t), visible: t.visible, label: t.label } : null;}getColumnsConfig() {const e = this._p;let t = {};for (let r = 0; r < e.columns.length; r++) t[e.columns[r].name] = this.getColumnConfig(e.columns[r].name);return t;}getSortedColumns() {const e = this._p;let t = [];for (let r = 0; r < e.rows.sortColumn.length; r++) {let i = e.rows.sortColumn[r];t.push({ column: i.column, descending: i.descending });}return t;}getHtmlForRowCell(e, t) {const r = this._p;if (e < 0 || e > r.rows.length - 1) return null;let i = r.columns.get(t);if (!i) return null;let l = r.rows[e];return this._getHtmlForCell(l, i);}getHtmlForRowDataCell(e, t) {let r = this._p.columns.get(t);return r ? this._getHtmlForCell(e, r) : null;}_getHtmlForCell(e, t) {let r = t.dataPath,i = e[r[0]];for (let e = 1; e < r.length && null != i; e++) i = i && i[r[e]];const l = this._o.cellFormatter;let o;if (l[Ci]) o = l(i, t.name, e);else try {o = l(i, t.name, e);} catch (e) {o = "[ERROR]", console.error("Failed to generate content for cell " + t.name, e);}return null == o && (o = ""), o;}getRowYPos(e) {return this._p.virtualListHelper.getItemPosition(e) || null;}getDataForRow(e) {const t = this._p;return e < 0 || e > t.rows.length - 1 ? null : t.rows[e];}getRowCount() {const e = this._p;return e.rows ? e.rows.length : 0;}getIndexForRow(e) {return this._p.rows.indexOf(e);}getFilteredRowCount() {const e = this._p;return (e.filteredRows || e.rows).length;}getIndexForFilteredRow(e) {const t = this._p;return (t.filteredRows || t.rows).indexOf(e);}getDataForFilteredRow(e) {const t = this._p;return e < 0 || e > (t.filteredRows || t.rows).length - 1 ? null : (t.filteredRows || t.rows)[e];}getHeaderRowElement() {return this._p.headerRow;}_horizontalPadding(e) {const t = getComputedStyle(e);return (parseFloat(t.paddingLeft) || 0) + (parseFloat(t.paddingRight) || 0);}_horizontalBorderWidth(e) {const t = getComputedStyle(e);return (parseFloat(t.borderLeftWidth) || 0) + (parseFloat(t.borderRightWidth) || 0);}_calculateWidthAvailableForColumns() {const e = this._o,t = this._p;let l, o, n;t.table && (o = t.table ? t.table.scrollTop : 0, n = t.table ? t.table.scrollLeft : 0, e.virtualTable && (l = t.table.style.display, t.table.style.display = "none"));let a = getElementWidth(this.el);t.table && (e.virtualTable && (t.table.style.display = l), t.table.scrollTop = o, t.table.scrollLeft = n, t.header.scrollLeft = n);let d = e.tableClassName;const u = gi("div");u.className = this.el.className, setCssProps(u, { "z-index": -1, position: "absolute", left: "0", top: "-9999px" });let h = gi("div");h.className = `${d}-header`, u.appendChild(h);let c = gi("div");c.index = null, c.vIndex = null, c.className = `${d}-header-row`, h.appendChild(c);for (let e = 0; e < t.visibleColumns.length; e++) {const r = t.visibleColumns[e],i = gi("div");i.className = `${d}-header-cell ${r.cellClasses || ""}`, i.columnName = r.name, i.appendChild(gi("div")), c.appendChild(i);}document.body.appendChild(u), a -= this._horizontalBorderWidth(c);let m = scopedSelectorAll(c, `>div.${d}-header-cell`);for (const e of m) {const r = getComputedStyle(e);if ("border-box" !== r.boxSizing) {a -= (parseFloat(r.borderRightWidth) || 0) + (parseFloat(r.borderLeftWidth) || 0) + this._horizontalPadding(e);const i = e.columnName,l = t.columns.get(i);l && (a -= l.arrowProposedWidth || 0);}}return u.remove(), Math.max(0, a);}_getTextWidth(e) {let t = this._o.tableClassName;const l = gi("div");l.className = this.el.className;const o = gi("div");o.className = t + "-header";const n = gi("div");n.className = t + "-header-row";const s = gi("div");s.className = t + "-header-cell";const a = gi("div");a.textContent = e, s.appendChild(a), n.appendChild(s), o.appendChild(n), l.appendChild(o), setCssProps(l, { position: "absolute", top: "-9999px", visibility: "hidden" }), document.body.appendChild(l);let d = getElementWidth(s);return l.remove(), d;}tableWidthChanged(e, t) {let r = this._o,i = this._p,l = this._calculateWidthAvailableForColumns(),o = l,n = 0;if (!i.table) return this;t = void 0 === t || t;let s = 0;if (i.tbody || (t = false), t && (s = parseFloat(i.tbody.style.minWidth) || 0), o !== i.lastDetectedWidth || e) {var a;i.lastDetectedWidth = l;let e = 0,d = [],u = 0;for (let e = 0; e < i.columns.length; e++) i.columns[e].actualWidthConsideringScrollbarWidth = null;for (let t = 0; t < i.visibleColumns.length; t++) {let l = i.visibleColumns[t];if (l.widthMode === Li.ABSOLUTE) {let i = l.width;i += l.arrowProposedWidth || 0, !l.ignoreMin && i < r.minColumnWidth && (i = r.minColumnWidth), o -= i, e += i, i !== l.actualWidth && (l.actualWidth = i, d.push(t));} else if (l.widthMode === Li.AUTO) {let i = this._getTextWidth(l.label) + 20;i += l.arrowProposedWidth || 0, !l.ignoreMin && i < r.minColumnWidth && (i = r.minColumnWidth), o -= i, e += i, i !== l.actualWidth && (l.actualWidth = i, r.convertColumnWidthsToRelative || d.push(t));} else l.widthMode === Li.RELATIVE && (u += l.width, n++);}if (r.convertColumnWidthsToRelative) for (let t = 0; t < i.visibleColumns.length; t++) {let r = i.visibleColumns[t];r.widthMode === Li.AUTO && (r.widthMode = Li.RELATIVE, o += r.actualWidth, r.width = r.actualWidth / e, u += r.width, n++);}if (n && (u < 1 && r.relativeWidthGrowsToFillWidth || u > 1 && r.relativeWidthShrinksToFillWidth)) for (let e = 0; e < i.visibleColumns.length; e++) {let t = i.visibleColumns[e];t.widthMode === Li.RELATIVE && (t.width /= u);}let h = Math.max(0, o);0 === h && (h = i.table.clientWidth);let c = r.minColumnWidth / h;if (isNaN(c) && (c = 0), c > 0) {let e,t = 0;for (let e = 0; e < i.visibleColumns.length; e++) {let r = i.visibleColumns[e];r.widthMode === Li.RELATIVE && !r.ignoreMin && r.width < c && (t += c - r.width, r.width = c);}for (let r = 0; r < i.visibleColumns.length; r++) {let l = i.visibleColumns[r];l.widthMode === Li.RELATIVE && !l.ignoreMin && l.width > c && t > 0 && (e = Math.min(t, l.width - c), l.width -= e, t -= e);}}if (r.autoFillTableWidth && o > 0) {let e = 0,t = o;for (let r = 0; r < i.visibleColumns.length; r++) {let l = i.visibleColumns[r];l.resizable || l.widthMode !== Li.ABSOLUTE || (e += l.width), l.widthMode === Li.RELATIVE && (t -= Math.round(h * l.width));}let r = (l - e) / (l - t - e) || NaN;for (let e = 0; e < i.visibleColumns.length && t > 0; e++) {let t = i.visibleColumns[e];if (t.resizable || t.widthMode !== Li.ABSOLUTE) if (t.widthMode === Li.RELATIVE) t.width *= r;else {let i = t.actualWidth * r;t.actualWidth !== i && (t.actualWidth = i, -1 === d.indexOf(e) && d.push(e));}}}for (let e = 0; e < i.visibleColumns.length; e++) {let t = i.visibleColumns[e];if (t.widthMode === Li.RELATIVE) {let r = Math.round(h * t.width);o -= r, n--, 0 === n && 1 === o && (r++, o--), -1 === o && (r--, o++), r !== t.actualWidth && (t.actualWidth = r, d.push(e));}}if (i.visibleColumns.length && (i.visibleColumns[i.visibleColumns.length - 1].actualWidthConsideringScrollbarWidth = i.visibleColumns[i.visibleColumns.length - 1].actualWidth - (i.scrollbarWidth || 0)), null === (a = i.notifyRendererOfColumnsConfig) || void 0 === a || a.call(i), t) {let e = this._calculateTbodyWidth();s < e && this._updateTableWidth(false);for (let e = 0; e < d.length; e++) this._resizeColumnElements(d[e]);s > e && this._updateTableWidth(false);}}return this;}tableHeightChanged() {let e = this._o,t = this._p;if (!t.table) return this;const r = getComputedStyle(t.table);let i = getElementHeight(this.el, true) - (parseFloat(r.borderTopWidth) || 0) - (parseFloat(r.borderBottomWidth) || 0);return i !== e.height && (e.height = i, t.tbody && (t.tbody.style.height = Math.max(e.height - getElementHeight(t.header, true, true, true), 1) + "px"), e.virtualTable && this.clearAndRender()), this;}addRows(e, t, r, i) {let l = this._p;return "boolean" == typeof t && (i = r, r = t, t = -1), "number" != typeof t && (t = -1), (t < 0 || t > l.rows.length) && (t = l.rows.length), i = void 0 === i || !!i, e && (l.rows.add(e, t), l.filteredRows || r && l.rows.sortColumn.length ? (r && l.rows.sortColumn.length ? this.resort() : this._refilter(), l.tableSkeletonNeedsRendering = true, i && this.render()) : i && (l.virtualListHelper.addItemsAt(e.length, t), this._o.virtualTable ? this._updateVirtualHeight()._updateLastCellWidthFromScrollbar().render()._updateTableWidth(false) : l.tbody && this.render()._updateLastCellWidthFromScrollbar()._updateTableWidth(true)), this.emit("addrows", { count: e.length, clear: false })), this;}removeRows(e, t, r) {let i = this._p;return "number" != typeof t || t <= 0 || e < 0 || e > i.rows.length - 1 || (i.rows.splice(e, t), r = void 0 === r || !!r, i.filteredRows ? (this._refilter(), i.tableSkeletonNeedsRendering = true, r && this.render()) : r && (i.virtualListHelper.removeItemsAt(t, e), this._o.virtualTable ? this._updateVirtualHeight()._updateLastCellWidthFromScrollbar().render()._updateTableWidth(false) : this.render()._updateLastCellWidthFromScrollbar()._updateTableWidth(true))), this;}removeRow(e, t) {return this.removeRows(e, 1, t);}refreshRow(e, t = true) {let r = this._p;if (e < 0 || e > r.rows.length - 1) return this;let i = -1;return r.filteredRows && -1 === (i = r.filteredRows.indexOf(r.rows[e])) || (-1 === i && (i = e), r.virtualListHelper.refreshItemAt(i), t && r.virtualListHelper.render()), this;}getRowElement(e) {let t = this._p;if (e < 0 || e > t.rows.length - 1) return null;let r = -1;return t.filteredRows && -1 === (r = t.filteredRows.indexOf(t.rows[e])) ? null : (-1 === r && (r = e), t.virtualListHelper.getItemElementAt(r) || null);}refreshAllVirtualRows() {return this._p.virtualListHelper.invalidate().render(), this;}setRows(e, t) {let r = this._p;return r.rows.reset(e), t && r.rows.sortColumn.length ? this.resort() : this._refilter(), this.clearAndRender().trigger("addrows", { count: e.length, clear: true }), this;}getUrlForElementContent(e) {let t,r = document.getElementById(e);if (r) {let e = r.textContent;if ("function" == typeof Blob) t = new Blob([e]);else {let r = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;if (!r) return null;let i = new r();i.append(e), t = i.getBlob();}return (window.URL || window.webkitURL).createObjectURL(t);}return null;}isWorkerSupported() {return window.Worker instanceof Function;}createWebWorker(e, t, r) {if (this.isWorkerSupported()) {let i = this._p,l = new Worker(e),o = (e) => {e.data.append ? this.addRows(e.data.rows, r) : this.setRows(e.data.rows, r);};return l.addEventListener("message", o, false), i.workerListeners || (i.workerListeners = []), i.workerListeners.push({ worker: l, listener: o }), (t || void 0 === t) && l.postMessage(null), l;}return null;}unbindWebWorker(e) {let t = this._p;if (t.workerListeners) for (let r = 0; r < t.workerListeners.length; r++) t.workerListeners[r].worker === e && (e.removeEventListener("message", t.workerListeners[r].listener, false), t.workerListeners.splice(r, 1), r--);return this;}abortCellPreview() {return this.hideCellPreview(), this;}cancelColumnResize() {const e = this._p;return e.resizer && (e.resizer.remove(), e.resizer = null, e.eventsSink.remove(document, ".colresize")), this;}_onTableScrolledHorizontally() {const e = this._p;e.header.scrollLeft = e.table.scrollLeft;}_getColumnByResizePosition(e) {let t = this._o,r = this._isTableRtl(),l = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`);l[Wi] && (l = l[Wi]);let n = l.previousSibling;for (; n && 1 !== n.nodeType;) n = n.previousSibling;let s = !n,a = (e.pageX || e.clientX) - getElementOffset(l).left;if (r) {if (!s && getElementWidth(l, true, true, true) - a <= t.resizeAreaWidth / 2) return n.columnName;if (a <= t.resizeAreaWidth / 2) return l.columnName;} else {if (!s && a <= t.resizeAreaWidth / 2) return n.columnName;if (getElementWidth(l, true, true, true) - a <= t.resizeAreaWidth / 2) return l.columnName;}return null;}_onTouchStartColumnHeader(e) {const t = this._p;if (t.currentTouchId) return;let r = e.changedTouches[0];t.currentTouchId = r.identifier;let i,l = e.currentTarget,o = { x: r.pageX, y: r.pageY },n = o,s = function () {t.currentTouchId = null, t.eventsSink.remove(l, ".colheader"), clearTimeout(i);},a = (t, ...r) => {for (const t of e) e[t];for (const e of r) for (const t of ["target", "clientX", "clientY", "offsetX", "offsetY", "screenX", "screenY", "pageX", "pageY", "which"]) null != e[t] && e[t];return new MouseEvent(t, e);};l.dispatchEvent(a("mousedown", e.changedTouches[0], { button: 0, target: e.target })), i = setTimeout(() => {s(), t.eventsSink.add(l, "touchend.colheader", (e) => {Ni(e) || e.preventDefault(), t.eventsSink.remove(l, ".colheader");}, { once: true }).add(l, "touchcancel.colheader", (e) => {t.eventsSink.remove(l, ".colheader");}, { once: true }), Math.sqrt(Math.pow(Math.abs(n.x - o.x), 2) + Math.pow(Math.abs(n.y - o.y), 2)) < 9 && (this.cancelColumnResize(), l.dispatchEvent(a("mouseup", e.changedTouches[0], { button: 2, target: e.target })));}, 500), t.eventsSink.add(l, "touchend.colheader", (e) => {let r = ai(e.changedTouches, (e) => e.identifier === t.currentTouchId);r && (s(), Ni(e) || e.preventDefault(), n = { x: r.pageX, y: r.pageY }, (Math.sqrt(Math.pow(Math.abs(n.x - o.x), 2) + Math.pow(Math.abs(n.y - o.y), 2)) < 9 || t.resizer) && (l.dispatchEvent(a("mouseup", r, { 0: 2, target: e.target })), l.dispatchEvent(a("click", r, { button: 0, target: e.target }))));}).add(l, "touchcancel.colheader", s).add(l, "touchmove.colheader", (e) => {let r = ai(e.changedTouches, (e) => e.identifier === t.currentTouchId);r && (n = { x: r.pageX, y: r.pageY }, t.resizer && (e.preventDefault(), l.dispatchEvent(a("mousemove", r, { target: e.target }))));});}_onMouseDownColumnHeader(e) {if (0 !== e.button) return this;let t = this._o,n = this._p,s = this._getColumnByResizePosition(e);if (s) {let a = n.columns.get(s);if (!t.resizableColumns || !a || !a.resizable) return false;let d = this._isTableRtl();n.resizer && n.resizer.remove(), n.resizer = gi("div"), n.resizer.className = t.resizerClassName, setCssProps(n.resizer, { position: "absolute", display: "block", zIndex: -1, visibility: "hidden", width: "2px", background: "#000", opacity: .7 }), this.el.appendChild(n.resizer);let u = a.element,h = n.resizer.parentNode;const c = getComputedStyle(h),m = getComputedStyle(u);let f = getElementOffset(u),p = getElementOffset(h);p.left += parseFloat(c.borderLeftWidth) || 0, p.top += parseFloat(c.borderTopWidth) || 0, f.left -= p.left, f.top -= p.top, f.top -= parseFloat(m.borderTopWidth) || 0;let v = getElementWidth(n.resizer, true, true, true);d ? (f.left -= Math.ceil((parseFloat(m.borderLeftWidth) || 0) / 2), f.left -= Math.ceil(v / 2)) : (f.left += getElementWidth(u, true, true, true), f.left += Math.ceil((parseFloat(m.borderRightWidth) || 0) / 2), f.left -= Math.ceil(v / 2)), setCssProps(n.resizer, { "z-index": "10", visibility: "visible", left: f.left + "px", top: f.top + "px", height: getElementHeight(this.el, false, false, false) + "px" }), n.resizer.columnName = u.columnName;try {n.resizer.style.zIndex = "";} catch (e) {}n.eventsSink.add(document, "mousemove.colresize", this._onMouseMoveResizeArea.bind(this)).add(document, "mouseup.colresize", this._onEndDragColumnHeader.bind(this)), e.preventDefault();}}_onMouseMoveColumnHeader(e) {let t = this._o,r = this._p;if (t.resizableColumns) {let i = this._getColumnByResizePosition(e),l = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`);i && r.columns.get(i).resizable ? l.style.cursor = "e-resize" : l.style.cursor = "";}}_onMouseUpColumnHeader(e) {if (2 === e.button) {let t = this._o,r = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`),n = getElementOffset(r);n.width = getElementWidth(r, true, true, true), n.height = getElementHeight(r, true, true, true), this.emit("headercontextmenu", { name: r.columnName, pageX: e.pageX, pageY: e.pageY, bounds: n });}return this;}_onMouseLeaveColumnHeader(e) {let t = this._o;e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`).style.cursor = "";}_onClickColumnHeader(e) {if (!Ni(e) && !this._getColumnByResizePosition(e)) {let t = this._o,r = this._p,i = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`);if (t.sortableColumns) {let e = r.columns.get(i.columnName),l = r.rows.sortColumn;if (e && e.sortable) {let r = true,i = l.length ? l[l.length - 1] : null;i && i.column === e.name && (i.descending && t.allowCancelSort ? (r = false, l.splice(l.length - 1, 1)) : i.descending = !i.descending), r ? this.sort(e.name, void 0, true).render() : this.sort();}}}}_onStartDragColumnHeader(e) {let t = this._o,r = this._p;if (t.movableColumns) {let i = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`),l = r.columns.get(i.columnName);l && l.movable ? (i.style.opacity = .35, r.dragId = 161061273 * Math.random(), e.dataTransfer.setData("text", JSON.stringify({ dragId: r.dragId, column: l.name }))) : e.preventDefault();} else e.preventDefault();}_onMouseMoveResizeArea(e) {let t = this._p,r = t.columns.get(t.resizer.columnName),l = this._isTableRtl(),n = r.element,s = t.resizer.parentNode;const a = getComputedStyle(s),d = getComputedStyle(n);let u = getElementOffset(n),h = getElementOffset(s);h.left += parseFloat(a.borderLeftWidth) || 0, u.left -= h.left;let c = getElementWidth(t.resizer, true, true, true),m = "border-box" === d.boxSizing,f = e.pageX - h.left,p = u.left;p -= Math.ceil(c / 2), l ? (p += getElementWidth(n, true, true, true), p -= r.ignoreMin ? 0 : this._o.minColumnWidth, m || (p -= Math.ceil((parseFloat(d.borderLeftWidth) || 0) / 2), p -= this._horizontalPadding(n)), f > p && (f = p)) : (p += r.ignoreMin ? 0 : this._o.minColumnWidth, m || (p += Math.ceil((parseFloat(d.borderRightWidth) || 0) / 2), p += this._horizontalPadding(n)), f < p && (f = p)), t.resizer.style.left = f + "px";}_onEndDragColumnHeader(e) {let t = this._o,r = this._p;if (r.resizer) {r.eventsSink.remove(document, ".colresize");let l = r.columns.get(r.resizer.columnName),n = this._isTableRtl(),s = l.element,a = s.firstChild,d = r.resizer.parentNode;const u = getComputedStyle(d),h = getComputedStyle(s);let c = getElementOffset(s),m = getElementOffset(d);m.left += parseFloat(u.borderLeftWidth) || 0, c.left -= m.left;let f = getElementWidth(r.resizer, true, true, true),p = "border-box" === h.boxSizing,v = e.pageX - m.left,g = c.left,b = c.left,C = 0;if (g -= Math.ceil(f / 2), n) {if (!p) {v += this._horizontalPadding(s);const e = getComputedStyle(a || s);v += parseFloat(e.borderLeftWidth) || 0, v += parseFloat(e.borderRightWidth) || 0, v += l.arrowProposedWidth || 0;}g += getElementWidth(s, true, true, true), b = g - (l.ignoreMin ? 0 : this._o.minColumnWidth), v > b && (v = b), C = g - v;} else {if (!p) {v -= this._horizontalPadding(s);const e = getComputedStyle(a || s);v -= parseFloat(e.borderLeftWidth) || 0, v -= parseFloat(e.borderRightWidth) || 0, v -= l.arrowProposedWidth || 0;}b = g + (l.ignoreMin ? 0 : this._o.minColumnWidth), v < b && (v = b), C = v - g;}r.resizer.remove(), r.resizer = null;let w = C;if (l.widthMode === Li.RELATIVE) {let e = this._calculateWidthAvailableForColumns(),i = 0,o = 0;for (let t = 0; t < r.visibleColumns.length; t++) {let n = r.visibleColumns[t];n.name !== l.name && (n.widthMode === Li.RELATIVE ? (i += n.width, o++) : e -= n.actualWidth);}if (e = Math.max(1, e), 1 === e && (e = r.table.clientWidth), w = C / e, o > 0) {let e = w / ((1 - w) / i);i += w, (i < 1 && t.relativeWidthGrowsToFillWidth || i > 1 && t.relativeWidthShrinksToFillWidth) && (w = e);}w *= 100, w += "%";}this.setColumnWidth(l.name, w);} else e.target.style.opacity = null;}_onDragEnterColumnHeader(e) {let t = this._o,r = this._p;if (t.movableColumns) {let i = e.dataTransfer.getData("text");i = i ? JSON.parse(i) : null;let l = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`);if (!i || r.dragId === i.dragId && l.columnName !== i.column) {let e = r.columns.get(l.columnName);e && (e.movable || e !== r.visibleColumns[0]) && l.classList.add("drag-over");}}}_onDragOverColumnHeader(e) {e.preventDefault();}_onDragLeaveColumnHeader(e) {let t = this._o,r = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`);e.relatedTarget.contains(r.firstChild) || r.classList.remove("drag-over");}_onDropColumnHeader(e) {e.preventDefault();let t = this._o,r = this._p,i = JSON.parse(e.dataTransfer.getData("text")),l = e.target.closest(`div.${t.tableClassName}-header-cell,div.${t.cellPreviewClassName}`);if (t.movableColumns && i.dragId === r.dragId) {let e = i.column,t = l.columnName,o = r.columns.get(e),n = r.columns.get(t);o && n && o.movable && (n.movable || n !== r.visibleColumns[0]) && this.moveColumn(e, t);}l.classList.remove("drag-over");}_clearSortArrows() {let e = this._p;if (e.table) {let t = this._o.tableClassName,r = scopedSelectorAll(e.headerRow, `>div.${t}-header-cell.sorted`),i = Array.prototype.slice.call(r, 0).map((e) => scopedSelector(e, ">div>.sort-arrow")).filter((e) => !!e);for (const t of i) {let r = e.columns.get(t.parentNode.parentNode.columnName);r && (r.arrowProposedWidth = 0), t.remove();}for (const e of r) e.classList.remove("sorted", "desc");}return this;}_showSortArrow(e, t) {let r = this._p.columns.get(e);if (!r) return false;let i = gi("span");return i.className = "sort-arrow", r.element && (r.element.className += t ? " sorted desc" : " sorted", r.element.firstChild.insertBefore(i, r.element.firstChild.firstChild)), r.widthMode !== Li.RELATIVE && this._o.adjustColumnWidthForSortArrow && (r.arrowProposedWidth = i.scrollWidth + (parseFloat(getComputedStyle(i).marginRight) || 0) + (parseFloat(getComputedStyle(i).marginLeft) || 0)), true;}_resizeColumnElements(e) {let t = this._p;const r = t.headerRow.querySelectorAll(`div.${this._o.tableClassName}-header-cell`)[e];let i = t.columns.get(r.columnName);if (i) {r.style.width = (i.actualWidthConsideringScrollbarWidth || i.actualWidth) + "px";let l = (i.actualWidthConsideringScrollbarWidth || i.actualWidth) + "px",o = t.tbody.childNodes;for (let t = 0, r = o.length; t < r; t++) {let r = o[t];1 === r.nodeType && (r.childNodes[e].style.width = l);}}return this;}_destroyHeaderCells() {let e = this._p;return e.headerRow && (e.headerRow = null), this;}_renderSkeletonBase() {var e;let t = this._p,r = this._o;null === (e = t.virtualListHelper) || void 0 === e || e.destroy(), t.virtualListHelper = null, t.table && r.virtualTable && (t.table.remove(), t.table = t.tbody = null), this._destroyHeaderCells(), t.currentTouchId = null, t.header && t.header.remove();let i = r.tableClassName,o = gi("div"),n = gi("div");return o.className = `${i}-header`, n.className = `${i}-header-row`, t.header = o, t.headerRow = n, o.appendChild(n), this.el.prepend(o), Ri(this.el), r.width === Ti.Width.SCROLL ? this.el.style.overflow = "hidden" : this.el.style.overflow = "", !r.height && r.virtualTable && (r.height = getElementHeight(this.el, true)), this;}_bindHeaderColumnEvents(e) {const t = e.firstChild;e.addEventListener("mousedown", this._onMouseDownColumnHeader.bind(this)), e.addEventListener("mousemove", this._onMouseMoveColumnHeader.bind(this)), e.addEventListener("mouseup", this._onMouseUpColumnHeader.bind(this)), e.addEventListener("mouseleave", this._onMouseLeaveColumnHeader.bind(this)), e.addEventListener("touchstart", this._onTouchStartColumnHeader.bind(this)), e.addEventListener("dragstart", this._onStartDragColumnHeader.bind(this)), e.addEventListener("click", this._onClickColumnHeader.bind(this)), e.addEventListener("contextmenu", (e) => {e.preventDefault();}), t.addEventListener("dragenter", this._onDragEnterColumnHeader.bind(this)), t.addEventListener("dragover", this._onDragOverColumnHeader.bind(this)), t.addEventListener("dragleave", this._onDragLeaveColumnHeader.bind(this)), t.addEventListener("drop", this._onDropColumnHeader.bind(this));}_renderSkeletonHeaderCells() {let e = this._p,t = this._o,r = t.allowCellPreview,i = t.allowHeaderCellPreview,l = t.tableClassName + "-header-cell",o = e.headerRow;for (let n = 0; n < e.visibleColumns.length; n++) {let s = e.visibleColumns[n];if (s.visible) {let a = gi("div");a.draggable = true, a.className = l, a.style.width = s.actualWidth + "px", t.sortableColumns && s.sortable && (a.className += " sortable"), a.columnName = s.name, a.setAttribute("data-column", s.name);let d = gi("div");d.innerHTML = t.headerCellFormatter(s.label, s.name), a.appendChild(d), r && i && e._bindCellHoverIn(a), o.appendChild(a), e.visibleColumns[n].element = a, this._bindHeaderColumnEvents(a), this._disableCssSelect(a);}}return this.emit("headerrowcreate", o), this;}_renderSkeletonBody() {let e = this._p,t = this._o,i = t.tableClassName;if (t.virtualTable && !e.virtualRowHeight) {let t = () => {let e = gi("div"),t = e.appendChild(gi("div")),r = t.appendChild(gi("div"));return e.className = `${i}-row`, t.className = `${i}-cell`, r.innerHTML = "0", e.style.visibility = "hidden", e.style.position = "absolute", e;};const o = gi("div");o.className = this.el.className, setCssProps(o, { "z-index": -1, position: "absolute", left: "0", top: "-9999px", width: "1px", overflow: "hidden" });const n = gi("div");n.className = i, o.appendChild(n);const s = gi("div");s.className = `${i}-body`, s.style.width = "99999px", n.appendChild(s), document.body.appendChild(o);let a = t(),d = t(),u = t();s.appendChild(a), s.appendChild(d), s.appendChild(u), e.virtualRowHeightFirst = getElementHeight(a, true, true, true), e.virtualRowHeight = getElementHeight(d, true, true, true), e.virtualRowHeightLast = getElementHeight(u, true, true, true), o.remove();}if (!e.table) {let o = document.createDocumentFragment(),n = gi("div");n.className = i, t.virtualTable && (n.className += " virtual");const s = getComputedStyle(n);let a = t.height - getElementHeight(e.header, true, true, true);"border-box" !== s.boxSizing && (a -= parseFloat(s.borderTopWidth) || 0, a -= parseFloat(s.borderBottomWidth) || 0, a -= parseFloat(s.paddingTop) || 0, a -= parseFloat(s.paddingBottom) || 0), e.visibleHeight = a, setCssProps(n, { height: t.height ? a + "px" : "auto", display: "block", overflowY: "auto", overflowX: t.width === Ti.Width.SCROLL ? "auto" : "hidden" }), o.appendChild(n);let d = gi("div");d.className = t.tableClassName + "-body", d.style.minHeight = "1px", e.table = n, e.tbody = d, Ri(d), Ri(n), n.appendChild(d), this.el.appendChild(o), this._setupVirtualTable();}return this;}_renderSkeleton() {return this;}_updateVirtualHeight() {const e = this._o,t = this._p;if (!t.tbody) return this;if (e.virtualTable) {const e = t.virtualListHelper.estimateFullHeight();t.lastVirtualScrollHeight = e, t.tbody.style.height = e + "px";} else t.tbody.style.height = "";return this;}_updateLastCellWidthFromScrollbar(e) {const t = this._p;let r = t.table.offsetWidth - t.table.clientWidth;if (r !== t.scrollbarWidth || e) {var i;t.scrollbarWidth = r;for (let e = 0; e < t.columns.length; e++) t.columns[e].actualWidthConsideringScrollbarWidth = null;if (t.scrollbarWidth > 0 && t.visibleColumns.length > 0) {let e = t.visibleColumns.length - 1;t.visibleColumns[e].actualWidthConsideringScrollbarWidth = t.visibleColumns[e].actualWidth - t.scrollbarWidth;let r = t.visibleColumns[e].actualWidthConsideringScrollbarWidth + "px",i = t.tbody.childNodes;for (let t = 0, l = i.length; t < l; t++) {let l = i[t];1 === l.nodeType && (l.childNodes[e].style.width = r);}t.headerRow.childNodes[e].style.width = r;}null === (i = t.notifyRendererOfColumnsConfig) || void 0 === i || i.call(t);}return this;}_updateTableWidth(e) {const t = this._o,r = this._p;let l = this._calculateTbodyWidth();if (r.tbody.style.minWidth = l + "px", r.headerRow.style.minWidth = l + (r.scrollbarWidth || 0) + "px", r.eventsSink.remove(r.table, "scroll"), t.width === Ti.Width.AUTO) setElementWidth(r.table, getElementWidth(r.tbody, true, true, true)), setElementWidth(this.el, getElementWidth(r.table, true, true, true));else if (t.width === Ti.Width.SCROLL) {if (e) {let e = r.table ? r.table.scrollTop : 0,t = r.table ? r.table.scrollLeft : 0;!function (e) {let t = e.style.display;e.style.display = "none", e.offsetHeight, e.style.display = t;}(this.el), r.table.crollTop = e, r.table.scrollLeft = t, r.header.scrollLeft = t;}r.eventsSink.add(r.table, "scroll", this._onTableScrolledHorizontally.bind(this));}return this;}_isTableRtl() {return "rtl" === getComputedStyle(this._p.table).direction;}_serializeColumnWidth(e) {return e.widthMode === Li.AUTO ? "auto" : e.widthMode === Li.RELATIVE ? 100 * e.width + "%" : e.width;}_disableCssSelect(e) {const t = e.style;t["-webkit-touch-callout"] = "none", t["-webkit-user-select"] = "none", t["-moz-user-select"] = "none", t["-ms-user-select"] = "none", t["-o-user-select"] = "none", t["user-select"] = "none";}_cellMouseOverEvent(e) {const t = this._o,n = this._p;let s = e.firstElementChild;if (!(s.scrollWidth - s.clientWidth > 1 || s.scrollHeight - s.clientHeight > 1)) return;this.hideCellPreview(), n.abortCellPreview = false;const a = e.parentElement,d = gi("div");d.innerHTML = e.innerHTML, d.className = t.cellPreviewClassName;let u = e.classList.contains(`${t.tableClassName}-header-cell`);u && (d.classList.add("header"), e.classList.contains("sortable") && d.classList.add("sortable"), d.draggable = true, this._bindHeaderColumnEvents(d));const h = getComputedStyle(e),c = getComputedStyle(s);let m = parseFloat(h.paddingLeft) || 0,f = parseFloat(h.paddingRight) || 0,p = parseFloat(h.paddingTop) || 0,v = parseFloat(h.paddingBottom) || 0,g = s.scrollWidth + (e.clientWidth - s.offsetWidth),b = "border-box" === h.boxSizing;if (b ? d.style.boxSizing = "border-box" : (g -= m + f, d.style.marginTop = (parseFloat(h.borderTopWidth) || 0) + "px"), !n.transparentBgColor1) {let e = document.createElement("div");document.body.appendChild(e), e.style.backgroundColor = "transparent", n.transparentBgColor1 = getComputedStyle(e).backgroundColor, e.style.backgroundColor = "rgba(0,0,0,0)", n.transparentBgColor2 = getComputedStyle(e).backgroundColor, e.remove();}let C = { "box-sizing": b ? "border-box" : "content-box", width: g, "min-height": Math.max(getElementHeight(e), parseFloat(h.minHeight) || 0) + "px", "padding-left": m, "padding-right": f, "padding-top": p, "padding-bottom": v, overflow: "hidden", position: "absolute", "z-index": "-1", left: "0", top: "0", cursor: h.cursor },w = h.backgroundColor;w !== n.transparentBgColor1 && w !== n.transparentBgColor2 || (w = getComputedStyle(a).backgroundColor), w !== n.transparentBgColor1 && w !== n.transparentBgColor2 || (w = "#fff"), C["background-color"] = w, setCssProps(d, C), setCssProps(d.firstChild, { direction: c.direction, "white-space": c.whiteSpace, "min-height": c.minHeight, "line-height": c.lineHeight, font: c.font }), this.el.appendChild(d), u && this._disableCssSelect(d), d.rowVIndex = a.vIndex;let y = d.rowIndex = a.index;d.columnName = n.visibleColumns[vi.call(a.childNodes, e)].name;try {let t = fi.saveSelection(e);t && fi.restoreSelection(d, t);} catch (e) {}if (this.emit("cellpreview", { el: d.firstElementChild, name: d.columnName, rowIndex: null != y ? y : null, rowData: null == y ? null : n.rows[y], cell: e, cellEl: s }), n.abortCellPreview) return void d.remove();null != y && d.addEventListener("click", (e) => {this.emit("rowclick", { event: e, filteredRowIndex: a.vIndex, rowIndex: y, rowEl: a, rowData: n.rows[y] });});let _ = this.el,S = _ === window ? document : _;const W = getComputedStyle(_);let R = getElementOffset(e),N = getElementOffset(_),T = "right" === h.float,L = T ? "right" : "left";if (T) {let t = window.innerWidth;R.right = t - (R.left + getElementWidth(e, true, true, true)), N.right = t - (N.left + getElementWidth(_, true, true, true));}R.left -= parseFloat(W.borderLeftWidth) || 0, "right" === L && (R.right -= parseFloat(W.borderRightWidth) || 0), R.top -= parseFloat(W.borderTopWidth) || 0, R[L] += parseFloat(h[`border-${L}-width`]) || 0, R.top += parseFloat(h.borderTopWidth) || parseFloat(h.borderBottomWidth) || 0, R.left -= N.left, "right" === L && (R.right -= N.right), R.top -= N.top;let E = getElementWidth(_, false, false, false) - getElementWidth(d, true, true, true);R[L] = R[L] < 0 ? 0 : R[L] > E ? E : R[L];let x = getElementHeight(e, true, true, true),z = S.scrollTop + getElementHeight(_, true) - x;R.top > z && (R.top = Math.max(0, z));let P = { top: R.top + "px", "z-index": 9999 };P[L] = R[L] + "px", setCssProps(d, P), d[Wi] = e, n.cellPreviewCell = d, e[Si] = d, n._bindCellHoverOut(e), n._bindCellHoverOut(d), d.addEventListener("wheel", () => {this.hideCellPreview();});}_cellMouseOutEvent(e) {this.hideCellPreview();}hideCellPreview() {const e = this._p;if (e.cellPreviewCell) {var t;let r,i = e.cellPreviewCell,l = i[Wi];try {r = fi.saveSelection(i);} catch (e) {}e.cellPreviewCell.remove(), e._unbindCellHoverOut(l), e._unbindCellHoverOut(i);try {r && fi.restoreSelection(l, r);} catch (e) {}this.emit("cellpreviewdestroy", { el: i.firstChild, name: i.columnName, rowIndex: null !== (t = i.rowIndex) && void 0 !== t ? t : null, rowData: null == i.rowIndex ? null : e.rows[i.rowIndex], cell: l, cellEl: l.firstChild }), delete l[Si], delete i[Wi], e.cellPreviewCell = null, e.abortCellPreview = false;} else e.abortCellPreview = true;return this;}}Ti.VERSION = "@@VERSION";const Li = { AUTO: 0, ABSOLUTE: 1, RELATIVE: 2 };Ti.Width = { NONE: "none", AUTO: "auto", SCROLL: "scroll" };
+
+class DGTableJQuery extends Ti {
+  constructor(options) {
+    super(options);
+
+    this.$el = jQuery(this.el).
+    data('dgtable', this).
+    on('remove', () => this.destroy());
+
+    this.on('headerrowdestroy', () => {var _this$_p;
+      const headerRow = (_this$_p = this._p) === null || _this$_p === void 0 ? void 0 : _this$_p.headerRow;
+      if (!headerRow) return;
+
+      jQuery(headerRow).find(`div.${this._o.tableClassName}-header-cell`).remove();
+    });
+  }
+
+  destroy() {var _this$_p2, _this$_p3;
+    if ((_this$_p2 = this._p) !== null && _this$_p2 !== void 0 && _this$_p2.table)
+    jQuery(this._p.table).empty();
+    if ((_this$_p3 = this._p) !== null && _this$_p3 !== void 0 && _this$_p3.tbody)
+    jQuery(this._p.tbody).empty();
+    return super.destroy();
+  }
+}
+
+module.exports = DGTableJQuery;
+
+//# sourceMappingURL=lib.cjs.js.map