handsontable 14.0.0-next-07c0a60-20231107 → 14.0.0-next-7ee54cb-20231108

package/plugins/nestedHeaders/nestedHeaders.js

@@ -1,7 +1,7 @@
 "use strict";
 
-require("core-js/modules/es.error.cause.js");
 exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
 require("core-js/modules/es.array.push.js");
 var _element = require("../../helpers/dom/element");
 var _number = require("../../helpers/number");
@@ -13,6 +13,7 @@ var _base = require("../base");
 var _stateManager2 = _interopRequireDefault(require("./stateManager"));
 var _ghostTable = _interopRequireDefault(require("./utils/ghostTable"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
@@ -23,6 +24,7 @@ function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
 function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 const PLUGIN_KEY = exports.PLUGIN_KEY = 'nestedHeaders';
 const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 280;
 
@@ -75,9 +77,166 @@ var _stateManager = /*#__PURE__*/new WeakMap();
 var _hidingIndexMapObserver = /*#__PURE__*/new WeakMap();
 var _focusInitialCoords = /*#__PURE__*/new WeakMap();
 var _isColumnsSelectionInProgress = /*#__PURE__*/new WeakMap();
+var _updateFocusHighlightPosition = /*#__PURE__*/new WeakSet();
+var _onBeforeViewportScrollHorizontally = /*#__PURE__*/new WeakSet();
+var _onBeforeHighlightingColumnHeader = /*#__PURE__*/new WeakSet();
+var _onBeforeCopy = /*#__PURE__*/new WeakSet();
+var _onBeforeOnCellMouseDown = /*#__PURE__*/new WeakSet();
+var _onAfterOnCellMouseDown = /*#__PURE__*/new WeakSet();
+var _onBeforeOnCellMouseOver = /*#__PURE__*/new WeakSet();
+var _onBeforeOnCellMouseUp = /*#__PURE__*/new WeakSet();
+var _onBeforeSelectionHighlightSet = /*#__PURE__*/new WeakSet();
+var _onModifyTransformStart = /*#__PURE__*/new WeakSet();
+var _onBeforeSelectColumns = /*#__PURE__*/new WeakSet();
+var _onAfterGetColumnHeaderRenderers = /*#__PURE__*/new WeakSet();
+var _onAfterViewportColumnCalculatorOverride = /*#__PURE__*/new WeakSet();
+var _onModifyColWidth = /*#__PURE__*/new WeakSet();
+var _onModifyColumnHeaderValue = /*#__PURE__*/new WeakSet();
+var _onModifyFocusedElement = /*#__PURE__*/new WeakSet();
+var _onInit = /*#__PURE__*/new WeakSet();
+var _onAfterLoadData = /*#__PURE__*/new WeakSet();
 class NestedHeaders extends _base.BasePlugin {
   constructor() {
     super(...arguments);
+    /**
+     * Updates the plugin state after new dataset load.
+     *
+     * @param {Array[]} sourceData Array of arrays or array of objects containing data.
+     * @param {boolean} initialLoad Flag that determines whether the data has been loaded
+     *                              during the initialization.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterLoadData);
+    /**
+     * Updates the plugin state after HoT initialization.
+     */
+    _classPrivateMethodInitSpec(this, _onInit);
+    /**
+     * `modifyFocusedElement` hook callback.
+     *
+     * @param {number} row Row index.
+     * @param {number} column Column index.
+     * @returns {HTMLTableCellElement} The `TH` element to be focused.
+     */
+    _classPrivateMethodInitSpec(this, _onModifyFocusedElement);
+    /**
+     * Listens the `modifyColumnHeaderValue` hook that overwrites the column headers values based on
+     * the internal state and settings of the plugin.
+     *
+     * @param {string} value The column header value.
+     * @param {number} visualColumnIndex The visual column index.
+     * @param {number} headerLevel The index of header level. The header level accepts positive (0 to N)
+     *                             and negative (-1 to -N) values. For positive values, 0 points to the
+     *                             top most header, and for negative direction, -1 points to the most bottom
+     *                             header (the header closest to the cells).
+     * @returns {string} Returns the column header value to update.
+     */
+    _classPrivateMethodInitSpec(this, _onModifyColumnHeaderValue);
+    /**
+     * `modifyColWidth` hook callback - returns width from cache, when is greater than incoming from hook.
+     *
+     * @param {number} width Width from hook.
+     * @param {number} column Visual index of an column.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onModifyColWidth);
+    /**
+     * Make the renderer render the first nested column in its entirety.
+     *
+     * @param {object} calc Viewport column calculator.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterViewportColumnCalculatorOverride);
+    /**
+     * `afterGetColumnHeader` hook callback - prepares the header structure.
+     *
+     * @param {Array} renderersArray Array of renderers.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterGetColumnHeaderRenderers);
+    /**
+     * The hook observes the column selection from the Selection API and modifies the column range to
+     * ensure that the whole nested column will be covered.
+     *
+     * @param {CellCoords} from The coords object where the selection starts.
+     * @param {CellCoords} to The coords object where the selection ends.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeSelectColumns);
+    /**
+     * `modifyTransformStart` hook is called every time the keyboard navigation is used.
+     *
+     * @param {object} delta The transformation delta.
+     */
+    _classPrivateMethodInitSpec(this, _onModifyTransformStart);
+    /**
+     * The hook checks and ensures that the focus position that depends on the selected columns
+     * range is always positioned within the range.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeSelectionHighlightSet);
+    /**
+     * Switches internal flag about selection progress to `false`.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeOnCellMouseUp);
+    /**
+     * Makes the header-selection properly select the nested headers.
+     *
+     * @param {MouseEvent} event Mouse event.
+     * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
+     * @param {HTMLElement} TD The cell element.
+     * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
+     *                            a boolean value that allows or disallows changing the selection for that particular area.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeOnCellMouseOver);
+    /**
+     * Allows to control how the column selection based on the coordinates and the nested headers is made.
+     *
+     * @param {MouseEvent} event Mouse event.
+     * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
+     */
+    _classPrivateMethodInitSpec(this, _onAfterOnCellMouseDown);
+    /**
+     * Allows blocking the column selection that is controlled by the core Selection module.
+     *
+     * @param {MouseEvent} event Mouse event.
+     * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
+     * @param {CellCoords} TD The table cell or header element.
+     * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
+     *                            a boolean value that allows or disallows changing the selection for that particular area.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeOnCellMouseDown);
+    /**
+     * Listens the `beforeCopy` hook that allows processing the copied column headers so that the
+     * merged column headers do not propagate the value for each column but only once at the beginning
+     * of the column.
+     *
+     * @private
+     * @param {Array[]} data An array of arrays which contains data to copied.
+     * @param {object[]} copyableRanges An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`)
+     *                                  which will copied.
+     * @param {{ columnHeadersCount: number }} copiedHeadersCount An object with keys that holds information with
+     *                                                            the number of copied headers.
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeCopy);
+    /**
+     * Allows to control which header DOM element will be used to highlight.
+     *
+     * @param {number} visualColumn A visual column index of the highlighted row header.
+     * @param {number} headerLevel A row header level that is currently highlighted.
+     * @param {object} highlightMeta An object with meta data that describes the highlight state.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeHighlightingColumnHeader);
+    /**
+     * Allows to control to which column index the viewport will be scrolled. To ensure that the viewport
+     * is scrolled to the correct column for the nested header the most left and the most right visual column
+     * indexes are used.
+     *
+     * @param {number} visualColumn A visual column index to which the viewport will be scrolled.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onBeforeViewportScrollHorizontally);
+    /**
+     * Updates the selection focus highlight position to point to the nested header root element (TH)
+     * even when the logical coordinates point in-between the header.
+     */
+    _classPrivateMethodInitSpec(this, _updateFocusHighlightPosition);
     /**
      * The state manager for the nested headers.
      *
@@ -161,56 +320,101 @@ class NestedHeaders extends _base.BasePlugin {
       (0, _console.warn)((0, _templateLiteralTag.toSingleLine)`Your Nested Headers plugin configuration is invalid. The settings has to be\x20
                         passed as an array of arrays e.q. [['A1', { label: 'A2', colspan: 2 }]]`);
     }
-    this.addHook('init', () => this.onInit());
+    this.addHook('init', () => _classPrivateMethodGet(this, _onInit, _onInit2).call(this));
     this.addHook('afterLoadData', function () {
-      return _this.onAfterLoadData(...arguments);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return _classPrivateMethodGet(_this, _onAfterLoadData, _onAfterLoadData2).call(_this, ...args);
     });
     this.addHook('beforeOnCellMouseDown', function () {
-      return _this.onBeforeOnCellMouseDown(...arguments);
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeOnCellMouseDown, _onBeforeOnCellMouseDown2).call(_this, ...args);
     });
     this.addHook('afterOnCellMouseDown', function () {
-      return _this.onAfterOnCellMouseDown(...arguments);
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      return _classPrivateMethodGet(_this, _onAfterOnCellMouseDown, _onAfterOnCellMouseDown2).call(_this, ...args);
     });
     this.addHook('beforeOnCellMouseOver', function () {
-      return _this.onBeforeOnCellMouseOver(...arguments);
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeOnCellMouseOver, _onBeforeOnCellMouseOver2).call(_this, ...args);
     });
     this.addHook('beforeOnCellMouseUp', function () {
-      return _this.onBeforeOnCellMouseUp(...arguments);
+      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        args[_key5] = arguments[_key5];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeOnCellMouseUp, _onBeforeOnCellMouseUp2).call(_this, ...args);
     });
     this.addHook('beforeSelectionHighlightSet', function () {
-      return _this.onBeforeSelectionHighlightSet(...arguments);
+      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeSelectionHighlightSet, _onBeforeSelectionHighlightSet2).call(_this, ...args);
     });
     this.addHook('modifyTransformStart', function () {
-      return _this.onModifyTransformStart(...arguments);
+      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+        args[_key7] = arguments[_key7];
+      }
+      return _classPrivateMethodGet(_this, _onModifyTransformStart, _onModifyTransformStart2).call(_this, ...args);
     });
-    this.addHook('afterSelection', () => this.updateFocusHighlightPosition());
+    this.addHook('afterSelection', () => _classPrivateMethodGet(this, _updateFocusHighlightPosition, _updateFocusHighlightPosition2).call(this));
     this.addHook('beforeViewportScrollHorizontally', function () {
-      return _this.onBeforeViewportScrollHorizontally(...arguments);
+      for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+        args[_key8] = arguments[_key8];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeViewportScrollHorizontally, _onBeforeViewportScrollHorizontally2).call(_this, ...args);
     });
-    this.addHook('afterGetColumnHeaderRenderers', array => this.onAfterGetColumnHeaderRenderers(array));
+    this.addHook('afterGetColumnHeaderRenderers', array => _classPrivateMethodGet(this, _onAfterGetColumnHeaderRenderers, _onAfterGetColumnHeaderRenderers2).call(this, array));
     this.addHook('modifyColWidth', function () {
-      return _this.onModifyColWidth(...arguments);
+      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+        args[_key9] = arguments[_key9];
+      }
+      return _classPrivateMethodGet(_this, _onModifyColWidth, _onModifyColWidth2).call(_this, ...args);
     });
     this.addHook('modifyColumnHeaderValue', function () {
-      return _this.onModifyColumnHeaderValue(...arguments);
+      for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+        args[_key10] = arguments[_key10];
+      }
+      return _classPrivateMethodGet(_this, _onModifyColumnHeaderValue, _onModifyColumnHeaderValue2).call(_this, ...args);
     });
     this.addHook('beforeHighlightingColumnHeader', function () {
-      return _this.onBeforeHighlightingColumnHeader(...arguments);
+      for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+        args[_key11] = arguments[_key11];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeHighlightingColumnHeader, _onBeforeHighlightingColumnHeader2).call(_this, ...args);
     });
     this.addHook('beforeCopy', function () {
-      return _this.onBeforeCopy(...arguments);
+      for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+        args[_key12] = arguments[_key12];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeCopy, _onBeforeCopy2).call(_this, ...args);
     });
     this.addHook('beforeSelectColumns', function () {
-      return _this.onBeforeSelectColumns(...arguments);
+      for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+        args[_key13] = arguments[_key13];
+      }
+      return _classPrivateMethodGet(_this, _onBeforeSelectColumns, _onBeforeSelectColumns2).call(_this, ...args);
     });
     this.addHook('afterViewportColumnCalculatorOverride', function () {
-      return _this.onAfterViewportColumnCalculatorOverride(...arguments);
+      for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+        args[_key14] = arguments[_key14];
+      }
+      return _classPrivateMethodGet(_this, _onAfterViewportColumnCalculatorOverride, _onAfterViewportColumnCalculatorOverride2).call(_this, ...args);
     });
     this.addHook('modifyFocusedElement', function () {
-      return _this.onModifyFocusedElement(...arguments);
+      for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
+        args[_key15] = arguments[_key15];
+      }
+      return _classPrivateMethodGet(_this, _onModifyFocusedElement, _onModifyFocusedElement2).call(_this, ...args);
     });
-    this.hot.columnIndexMapper.addLocalHook('cacheUpdated', () => this.updateFocusHighlightPosition());
-    this.hot.rowIndexMapper.addLocalHook('cacheUpdated', () => this.updateFocusHighlightPosition());
+    this.hot.columnIndexMapper.addLocalHook('cacheUpdated', () => _classPrivateMethodGet(this, _updateFocusHighlightPosition, _updateFocusHighlightPosition2).call(this));
+    this.hot.rowIndexMapper.addLocalHook('cacheUpdated', () => _classPrivateMethodGet(this, _updateFocusHighlightPosition, _updateFocusHighlightPosition2).call(this));
     super.enablePlugin();
     this.updatePlugin(); // @TODO: Workaround for broken plugin initialization abstraction.
   }
@@ -425,522 +629,361 @@ class NestedHeaders extends _base.BasePlugin {
     }
     return this.hot.getColHeader(visualColumnIndex, headerLevel);
   }
-
   /**
-   * Updates the selection focus highlight position to point to the nested header root element (TH)
-   * even when the logical coordinates point in-between the header.
-   *
-   * @private
+   * Destroys the plugin instance.
    */
-  updateFocusHighlightPosition() {
-    var _this$hot;
-    const selection = (_this$hot = this.hot) === null || _this$hot === void 0 ? void 0 : _this$hot.getSelectedRangeLast();
-    if (!selection) {
-      return;
-    }
-    const {
-      highlight
-    } = selection;
-    const isNestedHeadersRange = highlight.isHeader() && highlight.col >= 0;
-    if (isNestedHeadersRange) {
-      const columnIndex = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(highlight.row, highlight.col);
-      const focusHighlight = this.hot.selection.highlight.getFocus();
-
-      // Correct the highlight/focus selection to highlight the correct TH element
-      focusHighlight.visualCellRange.highlight.col = columnIndex;
-      focusHighlight.visualCellRange.from.col = columnIndex;
-      focusHighlight.visualCellRange.to.col = columnIndex;
-      focusHighlight.commit();
+  destroy() {
+    _classPrivateFieldSet(this, _stateManager, null);
+    if (_classPrivateFieldGet(this, _hidingIndexMapObserver) !== null) {
+      _classPrivateFieldGet(this, _hidingIndexMapObserver).unsubscribe();
+      _classPrivateFieldSet(this, _hidingIndexMapObserver, null);
     }
+    super.destroy();
   }
 
   /**
-   * Allows to control to which column index the viewport will be scrolled. To ensure that the viewport
-   * is scrolled to the correct column for the nested header the most left and the most right visual column
-   * indexes are used.
+   * Gets the tree data that belongs to the column headers pointed by the passed coordinates.
    *
    * @private
-   * @param {number} visualColumn A visual column index to which the viewport will be scrolled.
-   * @returns {number}
+   * @param {CellCoords} coords The CellCoords instance.
+   * @returns {object|undefined}
    */
-  onBeforeViewportScrollHorizontally(visualColumn) {
-    const selection = this.hot.getSelectedRangeLast();
-    if (!selection) {
-      return visualColumn;
-    }
-    const {
-      highlight
-    } = selection;
-    const isNestedHeadersRange = highlight.isHeader() && highlight.col >= 0;
-    if (!isNestedHeadersRange) {
-      return visualColumn;
-    }
-    const firstColumn = this.hot.view.getFirstFullyVisibleColumn();
-    const lastColumn = this.hot.view.getLastFullyVisibleColumn();
-    const mostLeftColumnIndex = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(highlight.row, highlight.col);
-    const mostRightColumnIndex = _classPrivateFieldGet(this, _stateManager).findRightMostColumnIndex(highlight.row, highlight.col);
-
-    // do not scroll the viewport when the header is wider than the viewport
-    if (mostLeftColumnIndex < firstColumn && mostRightColumnIndex > lastColumn) {
-      return visualColumn;
+  _getHeaderTreeNodeDataByCoords(coords) {
+    if (coords.row >= 0 || coords.col < 0) {
+      return;
     }
-    return mostLeftColumnIndex < firstColumn ? mostLeftColumnIndex : mostRightColumnIndex;
+    return _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(coords.row, coords.col);
   }
-
-  /**
-   * Allows to control which header DOM element will be used to highlight.
-   *
-   * @private
-   * @param {number} visualColumn A visual column index of the highlighted row header.
-   * @param {number} headerLevel A row header level that is currently highlighted.
-   * @param {object} highlightMeta An object with meta data that describes the highlight state.
-   * @returns {number}
-   */
-  onBeforeHighlightingColumnHeader(visualColumn, headerLevel, highlightMeta) {
-    const headerNodeData = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(headerLevel, visualColumn);
-    if (!headerNodeData) {
-      return visualColumn;
-    }
-    const {
-      columnCursor,
-      selectionType,
-      selectionWidth
-    } = highlightMeta;
-    const {
-      isRoot,
-      colspan
-    } = _classPrivateFieldGet(this, _stateManager).getHeaderSettings(headerLevel, visualColumn);
-    if (selectionType === _selection.HEADER_TYPE) {
-      if (!isRoot) {
-        return headerNodeData.columnIndex;
-      }
-    } else if (selectionType === _selection.ACTIVE_HEADER_TYPE) {
-      if (colspan > selectionWidth - columnCursor || !isRoot) {
-        // Prevents adding any CSS class names to the TH element
-        return null;
-      }
-    }
+}
+exports.NestedHeaders = NestedHeaders;
+function _updateFocusHighlightPosition2() {
+  var _this$hot;
+  const selection = (_this$hot = this.hot) === null || _this$hot === void 0 ? void 0 : _this$hot.getSelectedRangeLast();
+  if (!selection) {
+    return;
+  }
+  const {
+    highlight
+  } = selection;
+  const isNestedHeadersRange = highlight.isHeader() && highlight.col >= 0;
+  if (isNestedHeadersRange) {
+    const columnIndex = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(highlight.row, highlight.col);
+    const focusHighlight = this.hot.selection.highlight.getFocus();
+
+    // Correct the highlight/focus selection to highlight the correct TH element
+    focusHighlight.visualCellRange.highlight.col = columnIndex;
+    focusHighlight.visualCellRange.from.col = columnIndex;
+    focusHighlight.visualCellRange.to.col = columnIndex;
+    focusHighlight.commit();
+  }
+}
+function _onBeforeViewportScrollHorizontally2(visualColumn) {
+  const selection = this.hot.getSelectedRangeLast();
+  if (!selection) {
     return visualColumn;
   }
-
-  /**
-   * Listens the `beforeCopy` hook that allows processing the copied column headers so that the
-   * merged column headers do not propagate the value for each column but only once at the beginning
-   * of the column.
-   *
-   * @private
-   * @param {Array[]} data An array of arrays which contains data to copied.
-   * @param {object[]} copyableRanges An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`)
-   *                                  which will copied.
-   * @param {{ columnHeadersCount: number }} copiedHeadersCount An object with keys that holds information with
-   *                                                            the number of copied headers.
-   */
-  onBeforeCopy(data, copyableRanges, _ref2) {
-    let {
-      columnHeadersCount
-    } = _ref2;
-    if (columnHeadersCount === 0) {
-      return;
-    }
-    for (let rangeIndex = 0; rangeIndex < copyableRanges.length; rangeIndex++) {
-      const {
-        startRow,
-        startCol,
-        endRow,
-        endCol
-      } = copyableRanges[rangeIndex];
-      const rowsCount = endRow - startRow + 1;
-      const columnsCount = startCol - endCol + 1;
-
-      // do not process dataset ranges and column headers where only one column is copied
-      if (startRow >= 0 || columnsCount === 1) {
-        break;
-      }
-      for (let column = startCol; column <= endCol; column++) {
-        for (let row = startRow; row <= endRow; row++) {
-          var _classPrivateFieldGet4;
-          const zeroBasedColumnHeaderLevel = rowsCount + row;
-          const zeroBasedColumnIndex = column - startCol;
-          if (zeroBasedColumnIndex === 0) {
-            continue; // eslint-disable-line no-continue
-          }
-
-          const isRoot = (_classPrivateFieldGet4 = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(row, column)) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.isRoot;
-          if (isRoot === false) {
-            data[zeroBasedColumnHeaderLevel][zeroBasedColumnIndex] = '';
-          }
-        }
-      }
-    }
+  const {
+    highlight
+  } = selection;
+  const isNestedHeadersRange = highlight.isHeader() && highlight.col >= 0;
+  if (!isNestedHeadersRange) {
+    return visualColumn;
   }
+  const firstColumn = this.hot.view.getFirstFullyVisibleColumn();
+  const lastColumn = this.hot.view.getLastFullyVisibleColumn();
+  const mostLeftColumnIndex = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(highlight.row, highlight.col);
+  const mostRightColumnIndex = _classPrivateFieldGet(this, _stateManager).findRightMostColumnIndex(highlight.row, highlight.col);
 
-  /**
-   * Allows blocking the column selection that is controlled by the core Selection module.
-   *
-   * @private
-   * @param {MouseEvent} event Mouse event.
-   * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
-   * @param {CellCoords} TD The table cell or header element.
-   * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
-   *                            a boolean value that allows or disallows changing the selection for that particular area.
-   */
-  onBeforeOnCellMouseDown(event, coords, TD, controller) {
-    const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
-    if (headerNodeData) {
-      // Block the Selection module in controlling how the columns are selected. Pass the
-      // responsibility of the column selection to this plugin (see "onAfterOnCellMouseDown" hook).
-      controller.column = true;
-    }
+  // do not scroll the viewport when the header is wider than the viewport
+  if (mostLeftColumnIndex < firstColumn && mostRightColumnIndex > lastColumn) {
+    return visualColumn;
   }
-
-  /**
-   * Allows to control how the column selection based on the coordinates and the nested headers is made.
-   *
-   * @private
-   * @param {MouseEvent} event Mouse event.
-   * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
-   */
-  onAfterOnCellMouseDown(event, coords) {
-    const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
-    if (!headerNodeData) {
-      return;
-    }
-    _classPrivateFieldSet(this, _focusInitialCoords, coords.clone());
-    _classPrivateFieldSet(this, _isColumnsSelectionInProgress, true);
-    const {
-      selection
-    } = this.hot;
-    const currentSelection = selection.isSelected() ? selection.getSelectedRange().current() : null;
-    const columnsToSelect = [];
+  return mostLeftColumnIndex < firstColumn ? mostLeftColumnIndex : mostRightColumnIndex;
+}
+function _onBeforeHighlightingColumnHeader2(visualColumn, headerLevel, highlightMeta) {
+  const headerNodeData = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(headerLevel, visualColumn);
+  if (!headerNodeData) {
+    return visualColumn;
+  }
+  const {
+    columnCursor,
+    selectionType,
+    selectionWidth
+  } = highlightMeta;
+  const {
+    isRoot,
+    colspan
+  } = _classPrivateFieldGet(this, _stateManager).getHeaderSettings(headerLevel, visualColumn);
+  if (selectionType === _selection.HEADER_TYPE) {
+    if (!isRoot) {
+      return headerNodeData.columnIndex;
+    }
+  } else if (selectionType === _selection.ACTIVE_HEADER_TYPE) {
+    if (colspan > selectionWidth - columnCursor || !isRoot) {
+      // Prevents adding any CSS class names to the TH element
+      return null;
+    }
+  }
+  return visualColumn;
+}
+function _onBeforeCopy2(data, copyableRanges, _ref2) {
+  let {
+    columnHeadersCount
+  } = _ref2;
+  if (columnHeadersCount === 0) {
+    return;
+  }
+  for (let rangeIndex = 0; rangeIndex < copyableRanges.length; rangeIndex++) {
     const {
-      columnIndex,
-      origColspan
-    } = headerNodeData;
+      startRow,
+      startCol,
+      endRow,
+      endCol
+    } = copyableRanges[rangeIndex];
+    const rowsCount = endRow - startRow + 1;
+    const columnsCount = startCol - endCol + 1;
+
+    // do not process dataset ranges and column headers where only one column is copied
+    if (startRow >= 0 || columnsCount === 1) {
+      break;
+    }
+    for (let column = startCol; column <= endCol; column++) {
+      for (let row = startRow; row <= endRow; row++) {
+        var _classPrivateFieldGet4;
+        const zeroBasedColumnHeaderLevel = rowsCount + row;
+        const zeroBasedColumnIndex = column - startCol;
+        if (zeroBasedColumnIndex === 0) {
+          continue; // eslint-disable-line no-continue
+        }
 
-    // The Selection module doesn't allow it to extend its behavior easily. That's why here we need
-    // to re-implement the "click" and "shift" behavior. As a workaround, the logic for the nested
-    // headers must implement a similar logic as in the original Selection handler
-    // (see src/selection/mouseEventHandler.js).
-    const allowRightClickSelection = !selection.inInSelection(coords);
-    if (event.shiftKey && currentSelection) {
-      if (coords.col < currentSelection.from.col) {
-        columnsToSelect.push(currentSelection.getTopEndCorner().col, columnIndex, coords.row);
-      } else if (coords.col > currentSelection.from.col) {
-        columnsToSelect.push(currentSelection.getTopStartCorner().col, columnIndex + origColspan - 1, coords.row);
-      } else {
-        columnsToSelect.push(columnIndex, columnIndex + origColspan - 1, coords.row);
+        const isRoot = (_classPrivateFieldGet4 = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(row, column)) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.isRoot;
+        if (isRoot === false) {
+          data[zeroBasedColumnHeaderLevel][zeroBasedColumnIndex] = '';
+        }
       }
-    } else if ((0, _event.isLeftClick)(event) || (0, _event.isRightClick)(event) && allowRightClickSelection) {
-      columnsToSelect.push(columnIndex, columnIndex + origColspan - 1, coords.row);
     }
-
-    // The plugin takes control of how the columns are selected.
-    selection.selectColumns(...columnsToSelect);
   }
-
-  /**
-   * Makes the header-selection properly select the nested headers.
-   *
-   * @private
-   * @param {MouseEvent} event Mouse event.
-   * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell.
-   * @param {HTMLElement} TD The cell element.
-   * @param {object} controller An object with properties `row`, `column` and `cell`. Each property contains
-   *                            a boolean value that allows or disallows changing the selection for that particular area.
-   */
-  onBeforeOnCellMouseOver(event, coords, TD, controller) {
-    if (!this.hot.view.isMouseDown()) {
-      return;
-    }
-    const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
-    if (!headerNodeData) {
-      return;
-    }
-    const {
-      columnIndex,
-      origColspan
-    } = headerNodeData;
-    const selectedRange = this.hot.getSelectedRangeLast();
-    const topStartCoords = selectedRange.getTopStartCorner();
-    const bottomEndCoords = selectedRange.getBottomEndCorner();
-    const {
-      from
-    } = selectedRange;
-
-    // Block the Selection module in controlling how the columns and cells are selected.
-    // From now on, the plugin is responsible for the selection.
+}
+function _onBeforeOnCellMouseDown2(event, coords, TD, controller) {
+  const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
+  if (headerNodeData) {
+    // Block the Selection module in controlling how the columns are selected. Pass the
+    // responsibility of the column selection to this plugin (see "onAfterOnCellMouseDown" hook).
     controller.column = true;
-    controller.cell = true;
-    const columnsToSelect = [];
-    const headerLevel = (0, _number.clamp)(coords.row, -Infinity, -1);
-    if (coords.col < from.col) {
-      columnsToSelect.push(bottomEndCoords.col, columnIndex, headerLevel);
-    } else if (coords.col > from.col) {
-      columnsToSelect.push(topStartCoords.col, columnIndex + origColspan - 1, headerLevel);
+  }
+}
+function _onAfterOnCellMouseDown2(event, coords) {
+  const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
+  if (!headerNodeData) {
+    return;
+  }
+  _classPrivateFieldSet(this, _focusInitialCoords, coords.clone());
+  _classPrivateFieldSet(this, _isColumnsSelectionInProgress, true);
+  const {
+    selection
+  } = this.hot;
+  const currentSelection = selection.isSelected() ? selection.getSelectedRange().current() : null;
+  const columnsToSelect = [];
+  const {
+    columnIndex,
+    origColspan
+  } = headerNodeData;
+
+  // The Selection module doesn't allow it to extend its behavior easily. That's why here we need
+  // to re-implement the "click" and "shift" behavior. As a workaround, the logic for the nested
+  // headers must implement a similar logic as in the original Selection handler
+  // (see src/selection/mouseEventHandler.js).
+  const allowRightClickSelection = !selection.inInSelection(coords);
+  if (event.shiftKey && currentSelection) {
+    if (coords.col < currentSelection.from.col) {
+      columnsToSelect.push(currentSelection.getTopEndCorner().col, columnIndex, coords.row);
+    } else if (coords.col > currentSelection.from.col) {
+      columnsToSelect.push(currentSelection.getTopStartCorner().col, columnIndex + origColspan - 1, coords.row);
     } else {
-      columnsToSelect.push(columnIndex, columnIndex + origColspan - 1, headerLevel);
+      columnsToSelect.push(columnIndex, columnIndex + origColspan - 1, coords.row);
     }
-    this.hot.selection.selectColumns(...columnsToSelect);
+  } else if ((0, _event.isLeftClick)(event) || (0, _event.isRightClick)(event) && allowRightClickSelection) {
+    columnsToSelect.push(columnIndex, columnIndex + origColspan - 1, coords.row);
   }
 
-  /**
-   * Switches internal flag about selection progress to `false`.
-   *
-   * @private
-   */
-  onBeforeOnCellMouseUp() {
-    _classPrivateFieldSet(this, _isColumnsSelectionInProgress, false);
+  // The plugin takes control of how the columns are selected.
+  selection.selectColumns(...columnsToSelect);
+}
+function _onBeforeOnCellMouseOver2(event, coords, TD, controller) {
+  if (!this.hot.view.isMouseDown()) {
+    return;
+  }
+  const headerNodeData = this._getHeaderTreeNodeDataByCoords(coords);
+  if (!headerNodeData) {
+    return;
+  }
+  const {
+    columnIndex,
+    origColspan
+  } = headerNodeData;
+  const selectedRange = this.hot.getSelectedRangeLast();
+  const topStartCoords = selectedRange.getTopStartCorner();
+  const bottomEndCoords = selectedRange.getBottomEndCorner();
+  const {
+    from
+  } = selectedRange;
+
+  // Block the Selection module in controlling how the columns and cells are selected.
+  // From now on, the plugin is responsible for the selection.
+  controller.column = true;
+  controller.cell = true;
+  const columnsToSelect = [];
+  const headerLevel = (0, _number.clamp)(coords.row, -Infinity, -1);
+  if (coords.col < from.col) {
+    columnsToSelect.push(bottomEndCoords.col, columnIndex, headerLevel);
+  } else if (coords.col > from.col) {
+    columnsToSelect.push(topStartCoords.col, columnIndex + origColspan - 1, headerLevel);
+  } else {
+    columnsToSelect.push(columnIndex, columnIndex + origColspan - 1, headerLevel);
+  }
+  this.hot.selection.selectColumns(...columnsToSelect);
+}
+function _onBeforeOnCellMouseUp2() {
+  _classPrivateFieldSet(this, _isColumnsSelectionInProgress, false);
+}
+function _onBeforeSelectionHighlightSet2() {
+  const {
+    navigableHeaders
+  } = this.hot.getSettings();
+  if (!this.hot.view.isMouseDown() || !_classPrivateFieldGet(this, _isColumnsSelectionInProgress) || !navigableHeaders) {
+    return;
+  }
+  const selectedRange = this.hot.getSelectedRangeLast();
+  const columnStart = selectedRange.getTopStartCorner().col;
+  const columnEnd = selectedRange.getBottomEndCorner().col;
+  const {
+    columnIndex,
+    origColspan
+  } = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(_classPrivateFieldGet(this, _focusInitialCoords).row, _classPrivateFieldGet(this, _focusInitialCoords).col);
+  selectedRange.setHighlight(_classPrivateFieldGet(this, _focusInitialCoords));
+  if (origColspan > selectedRange.getWidth() || columnIndex < columnStart || columnIndex + origColspan - 1 > columnEnd) {
+    const headerLevel = _classPrivateFieldGet(this, _stateManager).findTopMostEntireHeaderLevel((0, _number.clamp)(columnStart, columnIndex, columnIndex + origColspan - 1), (0, _number.clamp)(columnEnd, columnIndex, columnIndex + origColspan - 1));
+    selectedRange.highlight.row = headerLevel;
+    selectedRange.highlight.col = selectedRange.from.col;
   }
-
-  /**
-   * The hook checks and ensures that the focus position that depends on the selected columns
-   * range is always positioned within the range.
-   *
-   * @private
-   */
-  onBeforeSelectionHighlightSet() {
-    const {
-      navigableHeaders
-    } = this.hot.getSettings();
-    if (!this.hot.view.isMouseDown() || !_classPrivateFieldGet(this, _isColumnsSelectionInProgress) || !navigableHeaders) {
-      return;
-    }
-    const selectedRange = this.hot.getSelectedRangeLast();
-    const columnStart = selectedRange.getTopStartCorner().col;
-    const columnEnd = selectedRange.getBottomEndCorner().col;
-    const {
-      columnIndex,
-      origColspan
-    } = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(_classPrivateFieldGet(this, _focusInitialCoords).row, _classPrivateFieldGet(this, _focusInitialCoords).col);
-    selectedRange.setHighlight(_classPrivateFieldGet(this, _focusInitialCoords));
-    if (origColspan > selectedRange.getWidth() || columnIndex < columnStart || columnIndex + origColspan - 1 > columnEnd) {
-      const headerLevel = _classPrivateFieldGet(this, _stateManager).findTopMostEntireHeaderLevel((0, _number.clamp)(columnStart, columnIndex, columnIndex + origColspan - 1), (0, _number.clamp)(columnEnd, columnIndex, columnIndex + origColspan - 1));
-      selectedRange.highlight.row = headerLevel;
-      selectedRange.highlight.col = selectedRange.from.col;
+}
+function _onModifyTransformStart2(delta) {
+  const {
+    highlight
+  } = this.hot.getSelectedRangeLast();
+  const nextCoords = this.hot._createCellCoords(highlight.row + delta.row, highlight.col + delta.col);
+  const isNestedHeadersRange = nextCoords.isHeader() && nextCoords.col >= 0;
+  if (!isNestedHeadersRange) {
+    return;
+  }
+  const visualColumnIndexStart = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(nextCoords.row, nextCoords.col);
+  const visualColumnIndexEnd = _classPrivateFieldGet(this, _stateManager).findRightMostColumnIndex(nextCoords.row, nextCoords.col);
+  if (delta.col < 0) {
+    const nextColumn = highlight.col >= visualColumnIndexStart && highlight.col <= visualColumnIndexEnd ? visualColumnIndexStart - 1 : visualColumnIndexEnd;
+    const notHiddenColumnIndex = this.hot.columnIndexMapper.getNearestNotHiddenIndex(nextColumn, -1);
+    if (notHiddenColumnIndex === null) {
+      // There are no visible columns anymore, so move the selection out of the table edge. This will
+      // be processed by the selection Transformer class as a move selection to the previous row (if autoWrapRow is enabled).
+      delta.col = -this.hot.view.countRenderableColumnsInRange(0, highlight.col);
+    } else {
+      delta.col = -Math.max(this.hot.view.countRenderableColumnsInRange(notHiddenColumnIndex, highlight.col) - 1, 1);
+    }
+  } else if (delta.col > 0) {
+    const nextColumn = highlight.col >= visualColumnIndexStart && highlight.col <= visualColumnIndexEnd ? visualColumnIndexEnd + 1 : visualColumnIndexStart;
+    const notHiddenColumnIndex = this.hot.columnIndexMapper.getNearestNotHiddenIndex(nextColumn, 1);
+    if (notHiddenColumnIndex === null) {
+      // There are no visible columns anymore, so move the selection out of the table edge. This will
+      // be processed by the selection Transformer class as a move selection to the next row (if autoWrapRow is enabled).
+      delta.col = this.hot.view.countRenderableColumnsInRange(highlight.col, this.hot.countCols());
+    } else {
+      delta.col = Math.max(this.hot.view.countRenderableColumnsInRange(highlight.col, notHiddenColumnIndex) - 1, 1);
     }
   }
-
-  /**
-   * `modifyTransformStart` hook is called every time the keyboard navigation is used.
-   *
-   * @private
-   * @param {object} delta The transformation delta.
-   */
-  onModifyTransformStart(delta) {
-    const {
-      highlight
-    } = this.hot.getSelectedRangeLast();
-    const nextCoords = this.hot._createCellCoords(highlight.row + delta.row, highlight.col + delta.col);
-    const isNestedHeadersRange = nextCoords.isHeader() && nextCoords.col >= 0;
-    if (!isNestedHeadersRange) {
-      return;
-    }
-    const visualColumnIndexStart = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(nextCoords.row, nextCoords.col);
-    const visualColumnIndexEnd = _classPrivateFieldGet(this, _stateManager).findRightMostColumnIndex(nextCoords.row, nextCoords.col);
-    if (delta.col < 0) {
-      const nextColumn = highlight.col >= visualColumnIndexStart && highlight.col <= visualColumnIndexEnd ? visualColumnIndexStart - 1 : visualColumnIndexEnd;
-      const notHiddenColumnIndex = this.hot.columnIndexMapper.getNearestNotHiddenIndex(nextColumn, -1);
-      if (notHiddenColumnIndex === null) {
-        // There are no visible columns anymore, so move the selection out of the table edge. This will
-        // be processed by the selection Transformer class as a move selection to the previous row (if autoWrapRow is enabled).
-        delta.col = -this.hot.view.countRenderableColumnsInRange(0, highlight.col);
-      } else {
-        delta.col = -Math.max(this.hot.view.countRenderableColumnsInRange(notHiddenColumnIndex, highlight.col) - 1, 1);
-      }
-    } else if (delta.col > 0) {
-      const nextColumn = highlight.col >= visualColumnIndexStart && highlight.col <= visualColumnIndexEnd ? visualColumnIndexEnd + 1 : visualColumnIndexStart;
-      const notHiddenColumnIndex = this.hot.columnIndexMapper.getNearestNotHiddenIndex(nextColumn, 1);
-      if (notHiddenColumnIndex === null) {
-        // There are no visible columns anymore, so move the selection out of the table edge. This will
-        // be processed by the selection Transformer class as a move selection to the next row (if autoWrapRow is enabled).
-        delta.col = this.hot.view.countRenderableColumnsInRange(highlight.col, this.hot.countCols());
-      } else {
-        delta.col = Math.max(this.hot.view.countRenderableColumnsInRange(highlight.col, notHiddenColumnIndex) - 1, 1);
-      }
+}
+function _onBeforeSelectColumns2(from, to) {
+  const headerLevel = from.row;
+  const startNodeData = this._getHeaderTreeNodeDataByCoords({
+    row: headerLevel,
+    col: from.col
+  });
+  const endNodeData = this._getHeaderTreeNodeDataByCoords({
+    row: headerLevel,
+    col: to.col
+  });
+  if (to.col < from.col) {
+    // Column selection from right to left
+    if (startNodeData) {
+      from.col = startNodeData.columnIndex + startNodeData.origColspan - 1;
+    }
+    if (endNodeData) {
+      to.col = endNodeData.columnIndex;
+    }
+  } else if (to.col >= from.col) {
+    // Column selection from left to right or a single column selection
+    if (startNodeData) {
+      from.col = startNodeData.columnIndex;
+    }
+    if (endNodeData) {
+      to.col = endNodeData.columnIndex + endNodeData.origColspan - 1;
     }
   }
-
-  /**
-   * The hook observes the column selection from the Selection API and modifies the column range to
-   * ensure that the whole nested column will be covered.
-   *
-   * @private
-   * @param {CellCoords} from The coords object where the selection starts.
-   * @param {CellCoords} to The coords object where the selection ends.
-   */
-  onBeforeSelectColumns(from, to) {
-    const headerLevel = from.row;
-    const startNodeData = this._getHeaderTreeNodeDataByCoords({
-      row: headerLevel,
-      col: from.col
-    });
-    const endNodeData = this._getHeaderTreeNodeDataByCoords({
-      row: headerLevel,
-      col: to.col
-    });
-    if (to.col < from.col) {
-      // Column selection from right to left
-      if (startNodeData) {
-        from.col = startNodeData.columnIndex + startNodeData.origColspan - 1;
-      }
-      if (endNodeData) {
-        to.col = endNodeData.columnIndex;
-      }
-    } else if (to.col >= from.col) {
-      // Column selection from left to right or a single column selection
-      if (startNodeData) {
-        from.col = startNodeData.columnIndex;
-      }
-      if (endNodeData) {
-        to.col = endNodeData.columnIndex + endNodeData.origColspan - 1;
-      }
-    }
+}
+function _onAfterGetColumnHeaderRenderers2(renderersArray) {
+  renderersArray.length = 0;
+  for (let headerLayer = 0; headerLayer < _classPrivateFieldGet(this, _stateManager).getLayersCount(); headerLayer++) {
+    renderersArray.push(this.headerRendererFactory(headerLayer));
   }
+}
+function _onAfterViewportColumnCalculatorOverride2(calc) {
+  const headerLayersCount = _classPrivateFieldGet(this, _stateManager).getLayersCount();
+  let newStartColumn = calc.startColumn;
+  let nonRenderable = !!headerLayersCount;
+  for (let headerLayer = 0; headerLayer < headerLayersCount; headerLayer++) {
+    const startColumn = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(headerLayer, calc.startColumn);
+    const renderedStartColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(startColumn);
 
-  /**
-   * `afterGetColumnHeader` hook callback - prepares the header structure.
-   *
-   * @private
-   * @param {Array} renderersArray Array of renderers.
-   */
-  onAfterGetColumnHeaderRenderers(renderersArray) {
-    renderersArray.length = 0;
-    for (let headerLayer = 0; headerLayer < _classPrivateFieldGet(this, _stateManager).getLayersCount(); headerLayer++) {
-      renderersArray.push(this.headerRendererFactory(headerLayer));
+    // If any of the headers for that column index is rendered, all of them should be rendered properly, see
+    // comment below.
+    if (startColumn >= 0) {
+      nonRenderable = false;
     }
-  }
 
-  /**
-   * Make the renderer render the first nested column in its entirety.
-   *
-   * @private
-   * @param {object} calc Viewport column calculator.
-   */
-  onAfterViewportColumnCalculatorOverride(calc) {
-    const headerLayersCount = _classPrivateFieldGet(this, _stateManager).getLayersCount();
-    let newStartColumn = calc.startColumn;
-    let nonRenderable = !!headerLayersCount;
-    for (let headerLayer = 0; headerLayer < headerLayersCount; headerLayer++) {
-      const startColumn = _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(headerLayer, calc.startColumn);
-      const renderedStartColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(startColumn);
-
-      // If any of the headers for that column index is rendered, all of them should be rendered properly, see
-      // comment below.
-      if (startColumn >= 0) {
-        nonRenderable = false;
-      }
-
-      // `renderedStartColumn` can be `null` if the leftmost columns are hidden. In that case -> ignore that header
-      // level, as it should be handled by the "parent" header
-      if ((0, _number.isNumeric)(renderedStartColumn) && renderedStartColumn < calc.startColumn) {
-        newStartColumn = renderedStartColumn;
-        break;
-      }
+    // `renderedStartColumn` can be `null` if the leftmost columns are hidden. In that case -> ignore that header
+    // level, as it should be handled by the "parent" header
+    if ((0, _number.isNumeric)(renderedStartColumn) && renderedStartColumn < calc.startColumn) {
+      newStartColumn = renderedStartColumn;
+      break;
     }
-
-    // If no headers for the provided column index are renderable, start rendering from the beginning of the upmost
-    // header for that position.
-    calc.startColumn = nonRenderable ? _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(0, newStartColumn).columnIndex : newStartColumn;
   }
 
-  /**
-   * `modifyColWidth` hook callback - returns width from cache, when is greater than incoming from hook.
-   *
-   * @private
-   * @param {number} width Width from hook.
-   * @param {number} column Visual index of an column.
-   * @returns {number}
-   */
-  onModifyColWidth(width, column) {
-    const cachedWidth = this.ghostTable.getWidth(column);
-    return width > cachedWidth ? width : cachedWidth;
-  }
-
-  /**
-   * Listens the `modifyColumnHeaderValue` hook that overwrites the column headers values based on
-   * the internal state and settings of the plugin.
-   *
-   * @private
-   * @param {string} value The column header value.
-   * @param {number} visualColumnIndex The visual column index.
-   * @param {number} headerLevel The index of header level. The header level accepts positive (0 to N)
-   *                             and negative (-1 to -N) values. For positive values, 0 points to the
-   *                             top most header, and for negative direction, -1 points to the most bottom
-   *                             header (the header closest to the cells).
-   * @returns {string} Returns the column header value to update.
-   */
-  onModifyColumnHeaderValue(value, visualColumnIndex, headerLevel) {
-    var _classPrivateFieldGet5;
-    const {
-      label
-    } = (_classPrivateFieldGet5 = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet5 !== void 0 ? _classPrivateFieldGet5 : {
-      label: ''
-    };
-    return label;
-  }
-
-  /**
-   * `modifyFocusedElement` hook callback.
-   *
-   * @private
-   * @param {number} row Row index.
-   * @param {number} column Column index.
-   * @returns {HTMLTableCellElement} The `TH` element to be focused.
-   */
-  onModifyFocusedElement(row, column) {
-    if (row < 0) {
-      return this.hot.getCell(row, _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(row, column), true);
-    }
+  // If no headers for the provided column index are renderable, start rendering from the beginning of the upmost
+  // header for that position.
+  calc.startColumn = nonRenderable ? _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(0, newStartColumn).columnIndex : newStartColumn;
+}
+function _onModifyColWidth2(width, column) {
+  const cachedWidth = this.ghostTable.getWidth(column);
+  return width > cachedWidth ? width : cachedWidth;
+}
+function _onModifyColumnHeaderValue2(value, visualColumnIndex, headerLevel) {
+  var _classPrivateFieldGet5;
+  const {
+    label
+  } = (_classPrivateFieldGet5 = _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(headerLevel, visualColumnIndex)) !== null && _classPrivateFieldGet5 !== void 0 ? _classPrivateFieldGet5 : {
+    label: ''
+  };
+  return label;
+}
+function _onModifyFocusedElement2(row, column) {
+  if (row < 0) {
+    return this.hot.getCell(row, _classPrivateFieldGet(this, _stateManager).findLeftMostColumnIndex(row, column), true);
   }
-
-  /**
-   * Updates the plugin state after HoT initialization.
-   *
-   * @private
-   */
-  onInit() {
-    // @TODO: Workaround for broken plugin initialization abstraction.
+}
+function _onInit2() {
+  // @TODO: Workaround for broken plugin initialization abstraction.
+  this.updatePlugin();
+}
+function _onAfterLoadData2(sourceData, initialLoad) {
+  if (!initialLoad) {
     this.updatePlugin();
   }
-
-  /**
-   * Updates the plugin state after new dataset load.
-   *
-   * @private
-   * @param {Array[]} sourceData Array of arrays or array of objects containing data.
-   * @param {boolean} initialLoad Flag that determines whether the data has been loaded
-   *                              during the initialization.
-   */
-  onAfterLoadData(sourceData, initialLoad) {
-    if (!initialLoad) {
-      this.updatePlugin();
-    }
-  }
-
-  /**
-   * Destroys the plugin instance.
-   */
-  destroy() {
-    _classPrivateFieldSet(this, _stateManager, null);
-    if (_classPrivateFieldGet(this, _hidingIndexMapObserver) !== null) {
-      _classPrivateFieldGet(this, _hidingIndexMapObserver).unsubscribe();
-      _classPrivateFieldSet(this, _hidingIndexMapObserver, null);
-    }
-    super.destroy();
-  }
-
-  /**
-   * Gets the tree data that belongs to the column headers pointed by the passed coordinates.
-   *
-   * @private
-   * @param {CellCoords} coords The CellCoords instance.
-   * @returns {object|undefined}
-   */
-  _getHeaderTreeNodeDataByCoords(coords) {
-    if (coords.row >= 0 || coords.col < 0) {
-      return;
-    }
-    return _classPrivateFieldGet(this, _stateManager).getHeaderTreeNodeData(coords.row, coords.col);
-  }
-}
-exports.NestedHeaders = NestedHeaders;
+}