jquery.dgtable 0.6.18 → 2.0.0

package/dist/lib.umd.js

@@ -0,0 +1,1984 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery')) :
+    typeof define === 'function' && define.amd ? define(['jquery'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.DGTableJQuery = factory(global.jQuery));
+})(this, (function (jQuery) { 'use strict';
+
+    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 function () {
+        let /**Element|ElementCSSInlineStyle*/el = arguments.length <= 0 ? undefined : arguments[0],
+          /**string*/pseudoSelector,
+          /**boolean*/paddings,
+          /**boolean*/borders,
+          /**boolean*/margins;
+
+        if (pseudo) {
+          pseudoSelector = arguments.length <= 1 ? undefined : arguments[1];
+          paddings = !!(arguments.length <= 2 ? undefined : arguments[2]);
+          borders = !!(arguments.length <= 3 ? undefined : arguments[3]);
+          margins = !!(arguments.length <= 4 ? undefined : arguments[4]);
+        } else {
+          paddings = !!(arguments.length <= 1 ? undefined : arguments[1]);
+          borders = !!(arguments.length <= 2 ? undefined : arguments[2]);
+          margins = !!(arguments.length <= 3 ? undefined : arguments[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 function (/**Element|ElementCSSInlineStyle*/el,
+      /**number*/value)
+      {let paddings = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;let borders = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;let margins = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 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) {
+        /** @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.autoVirtualWrapperWidth ?? 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) {
+            p.virtualWrapper.style.height = scrollHeightPx;
+            p.onScrollHeightChange?.(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) {let atIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -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() {
+        const p = this._p;
+        p.currentItemsParent = p.virtualWrapper ?? p.userItemsParent ?? 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 = function (positions, pos) {let start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;let end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -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 = function (total, fn, pos) {let start = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;let end = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -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;
+      }
+    }
+
+    /*!
+     * @danielgindi/dgtable.js 2.0.0
+     * git://github.com/danielgindi/dgtable.js.git
+     */
+    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) {let r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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.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) {let t = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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 = function (t) {for (const t of e) e[t];for (var _len = arguments.length, r = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {r[_key - 1] = arguments[_key];}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: y, 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) {let t,r = e.cellPreviewCell,i = r[Wi];try {t = fi.saveSelection(r);} catch (e) {}e.cellPreviewCell.remove(), e._unbindCellHoverOut(i), e._unbindCellHoverOut(r);try {t && fi.restoreSelection(i, t);} catch (e) {}this.emit("cellpreviewdestroy", { el: r.firstChild, name: r.columnName, rowIndex: r.rowIndex, rowData: null == r.rowIndex ? null : e.rows[r.rowIndex], cell: i, cellEl: i.firstChild }), delete i[Si], delete r[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', () => {
+          const headerRow = this._p?.headerRow;
+          if (!headerRow) return;
+
+          jQuery(headerRow).find(`div.${this._o.tableClassName}-header-cell`).remove();
+        });
+      }
+
+      destroy() {
+        if (this._p?.table)
+        jQuery(this._p.table).empty();
+        if (this._p?.tbody)
+        jQuery(this._p.tbody).empty();
+        return super.destroy();
+      }
+    }
+
+    return DGTableJQuery;
+
+}));
+
+//# sourceMappingURL=lib.umd.js.map