handsontable 17.1.0 → 18.0.0-rc2

package/plugins/mergeCells/mergeCells.mjs

@@ -56,7 +56,6 @@ import AutofillCalculations from './calculations/autofill.mjs';
 import SelectionCalculations from './calculations/selection.mjs';
 import toggleMergeItem from './contextMenuItem/toggleMerge.mjs';
 import { arrayEach } from '../../helpers/array.mjs';
-import { isObject } from '../../helpers/object.mjs';
 import { warn } from '../../helpers/console.mjs';
 import { rangeEach, clamp } from '../../helpers/number.mjs';
 import { getStyle } from '../../helpers/dom/element.mjs';
@@ -90,121 +89,177 @@ var /**
    *
    * @type {{before: Function, after: Function}}
    */ _cellRenderer = /*#__PURE__*/ new WeakMap(), /**
+   * Snapshot of physical column indexes per merge, captured before a column move/freeze.
+   *
+   * @type {Map<MergedCellCoords, number[]> | null}
+   */ _columnMoveSnapshot = /*#__PURE__*/ new WeakMap(), /**
+   * Snapshot of physical row indexes per merge, captured before a row move.
+   *
+   * @type {Map<MergedCellCoords, number[]> | null}
+   */ _rowMoveSnapshot = /*#__PURE__*/ new WeakMap(), /**
+   * `true` once the plugin has finished its initial settings ingestion. Used to skip
+   * snapshot/translate during the bootstrap-time column reorders fired by
+   * `manualColumnMove: [...]` initial config, where the merge collection is empty
+   * anyway but we want to be defensive against future hook-order changes.
+   *
+   * @type {boolean}
+   */ _initialized = /*#__PURE__*/ new WeakMap(), /**
    * `afterInit` hook callback.
-   */ _onAfterInit = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterInit = /*#__PURE__*/ new WeakMap(), /**
    * Modifies the information on whether the current selection contains multiple cells. The `afterIsMultipleSelection`
    * hook callback.
    *
    * @param {boolean} isMultiple Determines whether the current selection contains multiple cells.
    * @returns {boolean}
-   */ _onAfterIsMultipleSelection = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterIsMultipleSelection = /*#__PURE__*/ new WeakMap(), /**
    * `modifyTransformFocus` hook callback.
    *
    * @param {object} delta The transformation delta.
-   */ _onModifyTransformFocus = /*#__PURE__*/ new WeakSet(), /**
+   */ _onModifyTransformFocus = /*#__PURE__*/ new WeakMap(), /**
    * `modifyTransformStart` hook callback.
    *
    * @param {object} delta The transformation delta.
-   */ _onModifyTransformStart = /*#__PURE__*/ new WeakSet(), /**
+   */ _onModifyTransformStart = /*#__PURE__*/ new WeakMap(), /**
    * The hook allows to modify the delta transformation object necessary for correct selection end transformations.
-   * The logic here handles "jumping over" merged merged cells, while selecting.
    *
    * @param {{ row: number, col: number }} delta The transformation delta.
-   */ _onModifyTransformEnd = /*#__PURE__*/ new WeakSet(), /**
+   */ _onModifyTransformEnd = /*#__PURE__*/ new WeakMap(), /**
    * The hook corrects the range (before drawing it) after the selection was made on the merged cells.
-   * It expands the range to cover the entire area of the selected merged cells.
-   */ _onBeforeSelectionHighlightSet = /*#__PURE__*/ new WeakSet(), /**
-   * The `modifyGetCellCoords` hook callback allows forwarding all `getCell` calls that point in-between the merged cells
-   * to the root element of the cell.
+   */ _onBeforeSelectionHighlightSet = /*#__PURE__*/ new WeakMap(), /**
+   * The `modifyGetCellCoords` hook callback.
    *
    * @param {number} row Row index.
    * @param {number} column Visual column index.
-   * @param {boolean} topmost Indicates if the requested element belongs to the topmost layer (any overlay) or not.
+   * @param {boolean} topmost Indicates if the requested element belongs to the topmost layer.
    * @param {string} [source] String that identifies how this coords change will be processed.
    * @returns {Array|undefined} Visual coordinates of the merge.
-   */ _onModifyGetCellCoords = /*#__PURE__*/ new WeakSet(), /**
+   */ _onModifyGetCellCoords = /*#__PURE__*/ new WeakMap(), /**
    * `afterContextMenuDefaultOptions` hook callback.
    *
    * @param {object} defaultOptions The default context menu options.
    */ _addMergeActionsToContextMenu = /*#__PURE__*/ new WeakSet(), /**
    * Clears the last selected coordinates before setting a new selection range.
-   */ _onBeforeSetRangeStart = /*#__PURE__*/ new WeakSet(), /**
-   * Detects if the last selected cell was a header cell if so update the order list active node for further
-   * computations.
-   */ _onBeforeSelectionFocusSet = /*#__PURE__*/ new WeakSet(), /**
+   */ _onBeforeSetRangeStart = /*#__PURE__*/ new WeakMap(), /**
+   * Detects if the last selected cell was a header cell.
+   */ _onBeforeSelectionFocusSet = /*#__PURE__*/ new WeakMap(), /**
    * Changes the focus selection to the next or previous cell or merged cell position.
    *
    * @param {number} row The visual row index.
    * @param {number} column The visual column index.
-   */ _onAfterSelectionFocusSet = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterSelectionFocusSet = /*#__PURE__*/ new WeakMap(), /**
    * Creates the horizontal and vertical cells order matrix (linked lists) for focused cell.
-   */ _onAfterSelectionEnd = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterSelectionEnd = /*#__PURE__*/ new WeakMap(), /**
    * The `afterGetCellMeta` hook callback.
    *
    * @param {number} row Row index.
    * @param {number} col Column index.
    * @param {object} cellProperties The cell properties object.
-   */ _onAfterGetCellMeta = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterGetCellMeta = /*#__PURE__*/ new WeakMap(), /**
    * `afterViewportRowCalculatorOverride` hook callback.
    *
    * @param {object} calc The row calculator object.
-   */ _onAfterViewportRowCalculatorOverride = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterViewportRowCalculatorOverride = /*#__PURE__*/ new WeakMap(), /**
    * `afterViewportColumnCalculatorOverride` hook callback.
    *
    * @param {object} calc The column calculator object.
-   */ _onAfterViewportColumnCalculatorOverride = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterViewportColumnCalculatorOverride = /*#__PURE__*/ new WeakMap(), /**
    * The `modifyAutofillRange` hook callback.
    *
    * @param {number[]} fullArea The drag + base area coordinates (`[startRow, startColumn, endRow, endColumn]`).
    * @param {number[]} baseArea The selection area coordinates (`[startRow, startColumn, endRow, endColumn]`).
    * @returns {number[]} The new drag area (`[startRow, startColumn, endRow, endColumn]`).
-   */ _onModifyAutofillRange = /*#__PURE__*/ new WeakSet(), /**
+   */ _onModifyAutofillRange = /*#__PURE__*/ new WeakMap(), /**
    * `afterCreateCol` hook callback.
    *
    * @param {number} column Column index.
    * @param {number} count Number of created columns.
-   */ _onAfterCreateCol = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterCreateCol = /*#__PURE__*/ new WeakMap(), /**
    * `afterRemoveCol` hook callback.
    *
    * @param {number} column Column index.
    * @param {number} count Number of removed columns.
-   */ _onAfterRemoveCol = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterRemoveCol = /*#__PURE__*/ new WeakMap(), /**
    * `afterCreateRow` hook callback.
    *
    * @param {number} row Row index.
    * @param {number} count Number of created rows.
    * @param {string} source Source of change.
-   */ _onAfterCreateRow = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterCreateRow = /*#__PURE__*/ new WeakMap(), /**
    * `afterRemoveRow` hook callback.
    *
    * @param {number} row Row index.
    * @param {number} count Number of removed rows.
-   */ _onAfterRemoveRow = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterRemoveRow = /*#__PURE__*/ new WeakMap(), /**
+   * `beforeColumnMove` hook callback. Captures physical column positions of every merge
+   * so they can be translated onto the new visual order in `afterColumnMove`.
+   *
+   * @param {number[]} columns Visual column indexes being moved.
+   * @param {number} finalIndex Drop target visual index.
+   * @param {number} dropIndex Drop index from drag.
+   * @param {boolean} movePossible Whether the move is allowed.
+   */ _onBeforeColumnMove = /*#__PURE__*/ new WeakMap(), /**
+   * `afterColumnMove` hook callback. Translates merges using the pre-move snapshot
+   * and the now-updated column index mapping. Auto-splits merges whose physical
+   * columns are no longer contiguous.
+   *
+   * @param {number[]} columns Visual column indexes that were moved.
+   * @param {number} finalIndex Drop target visual index.
+   * @param {number} dropIndex Drop index from drag.
+   * @param {boolean} movePossible Whether the move was allowed.
+   * @param {boolean} orderChanged Whether the move actually changed the order.
+   */ _onAfterColumnMove = /*#__PURE__*/ new WeakMap(), /**
+   * `beforeRowMove` hook callback. Captures physical row positions of every merge
+   * so they can be translated onto the new visual order in `afterRowMove`.
+   *
+   * @param {number[]} rows Visual row indexes being moved.
+   * @param {number} finalIndex Drop target visual index.
+   * @param {number} dropIndex Drop index from drag.
+   * @param {boolean} movePossible Whether the move is allowed.
+   */ _onBeforeRowMove = /*#__PURE__*/ new WeakMap(), /**
+   * `afterRowMove` hook callback. Translates merges using the pre-move snapshot
+   * and the now-updated row index mapping. Auto-splits merges whose physical
+   * rows are no longer contiguous.
+   *
+   * @param {number[]} rows Visual row indexes that were moved.
+   * @param {number} finalIndex Drop target visual index.
+   * @param {number} dropIndex Drop index from drag.
+   * @param {boolean} movePossible Whether the move was allowed.
+   * @param {boolean} orderChanged Whether the move actually changed the order.
+   */ _onAfterRowMove = /*#__PURE__*/ new WeakMap(), /**
+   * `beforeColumnFreeze` / `beforeColumnUnfreeze` hook callback. `manualColumnFreeze`
+   * reorders the visual sequence directly through the column index mapper, so we
+   * need to translate merges through it the same way as for `manualColumnMove`.
+   *
+   * @param {number} column Visual column index being frozen/unfrozen.
+   * @param {boolean} performed Whether the (un)freeze will actually run.
+   */ _onBeforeColumnFreeze = /*#__PURE__*/ new WeakMap(), /**
+   * `afterColumnFreeze` / `afterColumnUnfreeze` hook callback.
+   *
+   * @param {number} column Visual column index that was frozen/unfrozen.
+   * @param {boolean} performed Whether the (un)freeze actually ran.
+   */ _onAfterColumnFreeze = /*#__PURE__*/ new WeakMap(), /**
    * `afterChange` hook callback. Used to propagate merged cells after using Autofill.
    *
    * @param {Array} changes The changes array.
    * @param {string} source Determines the source of the change.
-   */ _onAfterChange = /*#__PURE__*/ new WeakSet(), /**
+   */ _onAfterChange = /*#__PURE__*/ new WeakMap(), /**
    * `beforeDrawAreaBorders` hook callback.
    *
    * @param {Array} corners Visual coordinates of the area corners.
    * @param {string} className Class name for the area.
-   */ _onBeforeDrawAreaBorders = /*#__PURE__*/ new WeakSet(), /**
-   * `afterDrawSelection` hook callback. Used to add the additional class name for the entirely-selected merged cells.
+   */ _onBeforeDrawAreaBorders = /*#__PURE__*/ new WeakMap(), /**
+   * `afterDrawSelection` hook callback.
    *
    * @param {number} currentRow Visual row index of the currently processed cell.
    * @param {number} currentColumn Visual column index of the currently cell.
-   * @param {Array} cornersOfSelection Array of the current selection in a form of `[startRow, startColumn, endRow,
-   *   endColumn]`.
+   * @param {Array} cornersOfSelection Array of the current selection.
    * @param {number|undefined} layerLevel Number indicating which layer of selection is currently processed.
-   * @returns {string|undefined} A `String`, which will act as an additional `className` to be added to the currently
-   *   processed cell.
-   */ _onAfterDrawSelection = /*#__PURE__*/ new WeakSet(), /**
-   * `beforeRemoveCellClassNames` hook callback. Used to remove additional class name from all cells in the table.
+   * @returns {string|undefined}
+   */ _onAfterDrawSelection = /*#__PURE__*/ new WeakMap(), /**
+   * `beforeRemoveCellClassNames` hook callback.
    *
-   * @returns {string[]} An `Array` of `String`s. Each of these strings will act like class names to be removed from
-   *   all the cells in the table.
-   */ _onBeforeRemoveCellClassNames = /*#__PURE__*/ new WeakSet(), /**
+   * @returns {string[]}
+   */ _onBeforeRemoveCellClassNames = /*#__PURE__*/ new WeakMap(), /**
    * Allows to prevent opening the editor while more than one merged cell is selected.
    *
    * @param {number} row Visual row index of the edited cell.
@@ -212,15 +267,15 @@ var /**
    * @param {string | null} initialValue The initial editor value.
    * @param {MouseEvent | KeyboardEvent} event The event which was responsible for opening the editor.
    * @returns {boolean | undefined}
-   */ _onBeforeBeginEditing = /*#__PURE__*/ new WeakSet(), /**
+   */ _onBeforeBeginEditing = /*#__PURE__*/ new WeakMap(), /**
    * Hook used to modify the row height depends on the merged cells in the row.
    *
    * @param {number} height The row height value provided by the Core.
    * @param {number} row The visual row index.
    * @param {string} overlayType The overlay type that is currently rendered.
    * @returns {number}
-   */ _onModifyRowHeightByOverlayName = /*#__PURE__*/ new WeakSet();
-/* eslint-disable jsdoc/require-description-complete-sentence */ /**
+   */ _onModifyRowHeightByOverlayName = /*#__PURE__*/ new WeakMap();
+/**
  * @plugin MergeCells
  * @class MergeCells
  *
@@ -273,17 +328,24 @@ var /**
  * ```
  * :::
  */ export class MergeCells extends BasePlugin {
-    static get PLUGIN_KEY() {
+    /**
+   * Returns the plugin key used to identify this plugin in Handsontable settings.
+   */ static get PLUGIN_KEY() {
         return PLUGIN_KEY;
     }
-    static get PLUGIN_PRIORITY() {
+    /**
+   * Returns the priority order used to determine the order in which plugins are initialized.
+   */ static get PLUGIN_PRIORITY() {
         return PLUGIN_PRIORITY;
     }
-    static get DEFAULT_SETTINGS() {
+    /**
+   * Returns the default settings applied when the plugin is enabled without explicit configuration.
+   */ static get DEFAULT_SETTINGS() {
+        const cells = [];
         return {
             [defaultMainSettingSymbol]: 'cells',
             virtualized: false,
-            cells: []
+            cells
         };
     }
     /**
@@ -303,35 +365,43 @@ var /**
         this.mergedCellsCollection = new MergedCellsCollection(this);
         this.autofillCalculations = new AutofillCalculations(this);
         this.selectionCalculations = new SelectionCalculations(this);
-        this.addHook('afterInit', (...args)=>_class_private_method_get(this, _onAfterInit, onAfterInit).call(this, ...args));
-        this.addHook('modifyTransformFocus', (...args)=>_class_private_method_get(this, _onModifyTransformFocus, onModifyTransformFocus).call(this, ...args));
-        this.addHook('modifyTransformStart', (...args)=>_class_private_method_get(this, _onModifyTransformStart, onModifyTransformStart).call(this, ...args));
-        this.addHook('modifyTransformEnd', (...args)=>_class_private_method_get(this, _onModifyTransformEnd, onModifyTransformEnd).call(this, ...args));
-        this.addHook('beforeSelectionHighlightSet', (...args)=>_class_private_method_get(this, _onBeforeSelectionHighlightSet, onBeforeSelectionHighlightSet).call(this, ...args));
-        this.addHook('beforeSetRangeStart', (...args)=>_class_private_method_get(this, _onBeforeSetRangeStart, onBeforeSetRangeStart).call(this, ...args));
-        this.addHook('beforeSetRangeStartOnly', (...args)=>_class_private_method_get(this, _onBeforeSetRangeStart, onBeforeSetRangeStart).call(this, ...args));
-        this.addHook('beforeSelectionFocusSet', (...args)=>_class_private_method_get(this, _onBeforeSelectionFocusSet, onBeforeSelectionFocusSet).call(this, ...args));
-        this.addHook('afterSelectionFocusSet', (...args)=>_class_private_method_get(this, _onAfterSelectionFocusSet, onAfterSelectionFocusSet).call(this, ...args));
-        this.addHook('afterSelectionEnd', (...args)=>_class_private_method_get(this, _onAfterSelectionEnd, onAfterSelectionEnd).call(this, ...args));
-        this.addHook('modifyGetCellCoords', (...args)=>_class_private_method_get(this, _onModifyGetCellCoords, onModifyGetCellCoords).call(this, ...args));
-        this.addHook('modifyGetCoordsElement', (...args)=>_class_private_method_get(this, _onModifyGetCellCoords, onModifyGetCellCoords).call(this, ...args));
-        this.addHook('afterIsMultipleSelection', (...args)=>_class_private_method_get(this, _onAfterIsMultipleSelection, onAfterIsMultipleSelection).call(this, ...args));
-        this.addHook('afterRenderer', (...args)=>_class_private_field_get(this, _cellRenderer).after(...args));
-        this.addHook('afterContextMenuDefaultOptions', (...args)=>_class_private_method_get(this, _addMergeActionsToContextMenu, addMergeActionsToContextMenu).call(this, ...args));
-        this.addHook('afterGetCellMeta', (...args)=>_class_private_method_get(this, _onAfterGetCellMeta, onAfterGetCellMeta).call(this, ...args));
-        this.addHook('afterViewportRowCalculatorOverride', (...args)=>_class_private_method_get(this, _onAfterViewportRowCalculatorOverride, onAfterViewportRowCalculatorOverride).call(this, ...args));
-        this.addHook('afterViewportColumnCalculatorOverride', (...args)=>_class_private_method_get(this, _onAfterViewportColumnCalculatorOverride, onAfterViewportColumnCalculatorOverride).call(this, ...args));
-        this.addHook('modifyAutofillRange', (...args)=>_class_private_method_get(this, _onModifyAutofillRange, onModifyAutofillRange).call(this, ...args));
-        this.addHook('afterCreateCol', (...args)=>_class_private_method_get(this, _onAfterCreateCol, onAfterCreateCol).call(this, ...args));
-        this.addHook('afterRemoveCol', (...args)=>_class_private_method_get(this, _onAfterRemoveCol, onAfterRemoveCol).call(this, ...args));
-        this.addHook('afterCreateRow', (...args)=>_class_private_method_get(this, _onAfterCreateRow, onAfterCreateRow).call(this, ...args));
-        this.addHook('afterRemoveRow', (...args)=>_class_private_method_get(this, _onAfterRemoveRow, onAfterRemoveRow).call(this, ...args));
-        this.addHook('afterChange', (...args)=>_class_private_method_get(this, _onAfterChange, onAfterChange).call(this, ...args));
-        this.addHook('beforeDrawBorders', (...args)=>_class_private_method_get(this, _onBeforeDrawAreaBorders, onBeforeDrawAreaBorders).call(this, ...args));
-        this.addHook('afterDrawSelection', (...args)=>_class_private_method_get(this, _onAfterDrawSelection, onAfterDrawSelection).call(this, ...args));
-        this.addHook('beforeRemoveCellClassNames', (...args)=>_class_private_method_get(this, _onBeforeRemoveCellClassNames, onBeforeRemoveCellClassNames).call(this, ...args));
-        this.addHook('beforeBeginEditing', (...args)=>_class_private_method_get(this, _onBeforeBeginEditing, onBeforeBeginEditing).call(this, ...args));
-        this.addHook('modifyRowHeightByOverlayName', (...args)=>_class_private_method_get(this, _onModifyRowHeightByOverlayName, onModifyRowHeightByOverlayName).call(this, ...args));
+        this.addHook('afterInit', _class_private_field_get(this, _onAfterInit));
+        this.addHook('modifyTransformFocus', _class_private_field_get(this, _onModifyTransformFocus));
+        this.addHook('modifyTransformStart', _class_private_field_get(this, _onModifyTransformStart));
+        this.addHook('modifyTransformEnd', _class_private_field_get(this, _onModifyTransformEnd));
+        this.addHook('beforeSelectionHighlightSet', _class_private_field_get(this, _onBeforeSelectionHighlightSet));
+        this.addHook('beforeSetRangeStart', _class_private_field_get(this, _onBeforeSetRangeStart));
+        this.addHook('beforeSetRangeStartOnly', _class_private_field_get(this, _onBeforeSetRangeStart));
+        this.addHook('beforeSelectionFocusSet', _class_private_field_get(this, _onBeforeSelectionFocusSet));
+        this.addHook('afterSelectionFocusSet', _class_private_field_get(this, _onAfterSelectionFocusSet));
+        this.addHook('afterSelectionEnd', _class_private_field_get(this, _onAfterSelectionEnd));
+        this.addHook('modifyGetCellCoords', _class_private_field_get(this, _onModifyGetCellCoords));
+        this.addHook('modifyGetCoordsElement', _class_private_field_get(this, _onModifyGetCellCoords));
+        this.addHook('afterIsMultipleSelection', _class_private_field_get(this, _onAfterIsMultipleSelection));
+        this.addHook('afterRenderer', (TD, row, col)=>_class_private_field_get(this, _cellRenderer).after(TD, row, col));
+        this.addHook('afterContextMenuDefaultOptions', (defaultOptions)=>_class_private_method_get(this, _addMergeActionsToContextMenu, addMergeActionsToContextMenu).call(this, defaultOptions));
+        this.addHook('afterGetCellMeta', _class_private_field_get(this, _onAfterGetCellMeta));
+        this.addHook('afterViewportRowCalculatorOverride', _class_private_field_get(this, _onAfterViewportRowCalculatorOverride));
+        this.addHook('afterViewportColumnCalculatorOverride', _class_private_field_get(this, _onAfterViewportColumnCalculatorOverride));
+        this.addHook('modifyAutofillRange', _class_private_field_get(this, _onModifyAutofillRange));
+        this.addHook('afterCreateCol', _class_private_field_get(this, _onAfterCreateCol));
+        this.addHook('afterRemoveCol', _class_private_field_get(this, _onAfterRemoveCol));
+        this.addHook('afterCreateRow', _class_private_field_get(this, _onAfterCreateRow));
+        this.addHook('afterRemoveRow', _class_private_field_get(this, _onAfterRemoveRow));
+        this.addHook('beforeColumnMove', _class_private_field_get(this, _onBeforeColumnMove));
+        this.addHook('afterColumnMove', _class_private_field_get(this, _onAfterColumnMove));
+        this.addHook('beforeRowMove', _class_private_field_get(this, _onBeforeRowMove));
+        this.addHook('afterRowMove', _class_private_field_get(this, _onAfterRowMove));
+        this.addHook('beforeColumnFreeze', _class_private_field_get(this, _onBeforeColumnFreeze));
+        this.addHook('afterColumnFreeze', _class_private_field_get(this, _onAfterColumnFreeze));
+        this.addHook('beforeColumnUnfreeze', _class_private_field_get(this, _onBeforeColumnFreeze));
+        this.addHook('afterColumnUnfreeze', _class_private_field_get(this, _onAfterColumnFreeze));
+        this.addHook('afterChange', _class_private_field_get(this, _onAfterChange));
+        this.addHook('beforeDrawBorders', _class_private_field_get(this, _onBeforeDrawAreaBorders));
+        this.addHook('afterDrawSelection', _class_private_field_get(this, _onAfterDrawSelection));
+        this.addHook('beforeRemoveCellClassNames', _class_private_field_get(this, _onBeforeRemoveCellClassNames));
+        this.addHook('beforeBeginEditing', _class_private_field_get(this, _onBeforeBeginEditing));
+        this.addHook('modifyRowHeightByOverlayName', _class_private_field_get(this, _onModifyRowHeightByOverlayName));
         this.addHook('beforeUndoStackChange', (action, source)=>{
             if (source === 'MergeCells') {
                 return false;
@@ -346,6 +416,7 @@ var /**
         this.clearCollections();
         this.unregisterShortcuts();
         this.hot.render();
+        _class_private_field_set(this, _initialized, false);
         super.disablePlugin();
     }
     /**
@@ -358,6 +429,7 @@ var /**
         this.disablePlugin();
         this.enablePlugin();
         this.generateFromSettings();
+        _class_private_field_set(this, _initialized, true);
         super.updatePlugin();
     }
     /**
@@ -384,13 +456,16 @@ var /**
         ];
         rowIndexesToRefresh.forEach((rowIndex)=>{
             const renderableRowIndex = this.hot.rowIndexMapper.getRenderableFromVisualIndex(rowIndex);
-            this.hot.view._wt.wtOverlays.getOverlays(true).map((overlay)=>overlay?.name === 'master' ? overlay : overlay.clone.wtTable).forEach((wtTableRef)=>{
+            if (renderableRowIndex === null) {
+                return;
+            }
+            this.hot.view._wt.wtOverlays.getOverlays(true).map((overlay)=>overlay.name === 'master' ? overlay : overlay.clone.wtTable).forEach((wtTableRef)=>{
                 const rowToRefresh = wtTableRef.getRow(renderableRowIndex);
                 if (rowToRefresh) {
                     // Modify the TR's `background` property to later modify it asynchronously.
                     // The background color is getting modified only with the alpha, so the change should not be visible (and is
                     // covered by the TDs' background color).
-                    rowToRefresh.style.background = getStyle(rowToRefresh, 'backgroundColor').replace(')', ', 0.99)');
+                    rowToRefresh.style.background = getStyle(rowToRefresh, 'backgroundColor')?.replace(')', ', 0.99)') ?? '';
                     rowsToRefresh.push(rowToRefresh);
                 }
             });
@@ -398,7 +473,7 @@ var /**
         // Asynchronously revert the TRs' `background` property to force a fresh repaint.
         this.hot._registerTimeout(()=>{
             rowsToRefresh.forEach((rowElement)=>{
-                rowElement.style.background = getStyle(rowElement, 'backgroundColor')?.replace(', 0.99)', ')');
+                rowElement.style.background = getStyle(rowElement, 'backgroundColor')?.replace(', 0.99)', '') ?? '';
             });
         }, 1);
     }
@@ -463,7 +538,7 @@ var /**
             return;
         }
         // TODO: Change the `source` argument to a more meaningful value, e.g. `${this.pluginName}.clearCells`.
-        this.hot.setDataAtCell(populatedNulls, undefined, undefined, this.pluginName);
+        this.hot.setDataAtCell(populatedNulls, undefined, undefined, this.pluginName ?? undefined);
     }
     /**
    * Clears the merged cells from the merged cell container.
@@ -492,7 +567,9 @@ var /**
         const { from, to } = cellRange;
         this.unmergeRange(cellRange, true);
         this.mergeRange(cellRange);
-        this.hot.selectCell(from.row, from.col, to.row, to.col, false);
+        if (from.row !== null && from.col !== null && to.row !== null && to.col !== null) {
+            this.hot.selectCell(from.row, from.col, to.row, to.col, false);
+        }
     }
     /**
    * Unmerges the selection provided as a cell range.
@@ -504,7 +581,9 @@ var /**
         }
         const { from, to } = cellRange;
         this.unmergeRange(cellRange, true);
-        this.hot.selectCell(from.row, from.col, to.row, to.col, false);
+        if (from.row !== null && from.col !== null && to.row !== null && to.col !== null) {
+            this.hot.selectCell(from.row, from.col, to.row, to.col, false);
+        }
     }
     /**
    * Merges cells in the provided cell range.
@@ -521,6 +600,9 @@ var /**
    */ mergeRange(cellRange, auto = false, preventPopulation = false) {
         const topStart = cellRange.getTopStartCorner();
         const bottomEnd = cellRange.getBottomEndCorner();
+        if (topStart.row === null || topStart.col === null || bottomEnd.row === null || bottomEnd.col === null) {
+            return false;
+        }
         const mergeParent = {
             row: topStart.row,
             col: topStart.col,
@@ -558,7 +640,7 @@ var /**
                 ];
             } else {
                 // TODO: Change the `source` argument to a more meaningful value, e.g. `${this.pluginName}.clearCells`.
-                this.hot.populateFromArray(mergeParent.row, mergeParent.col, clearedData, undefined, undefined, this.pluginName);
+                this.hot.populateFromArray(mergeParent.row, mergeParent.col, clearedData, undefined, undefined, this.pluginName ?? undefined);
             }
             if (!auto) {
                 this.ifChromeForceRepaint();
@@ -603,8 +685,11 @@ var /**
    * @param {CellRange} cellRange The cell range to merge or unmerged.
    */ toggleMerge(cellRange) {
         const { from, to } = cellRange.clone().normalize();
+        if (from.row === null || from.col === null || to.row === null || to.col === null) {
+            return;
+        }
         const mergedCell = this.mergedCellsCollection.get(from.row, from.col);
-        const mergedCellCoversWholeRange = mergedCell.row === from.row && mergedCell.col === from.col && mergedCell.row + mergedCell.rowspan - 1 === to.row && mergedCell.col + mergedCell.colspan - 1 === to.col;
+        const mergedCellCoversWholeRange = mergedCell !== false && mergedCell.row === from.row && mergedCell.col === from.col && mergedCell.row + mergedCell.rowspan - 1 === to.row && mergedCell.col + mergedCell.colspan - 1 === to.col;
         if (mergedCellCoversWholeRange) {
             this.unmergeRange(cellRange);
         } else {
@@ -646,6 +731,9 @@ var /**
    */ registerShortcuts() {
         const shortcutManager = this.hot.getShortcutManager();
         const gridContext = shortcutManager.getContext('grid');
+        if (!gridContext) {
+            return;
+        }
         gridContext.addShortcut({
             keys: [
                 [
@@ -660,7 +748,7 @@ var /**
                     this.hot.render();
                 }
             },
-            runOnlyIf: (event)=>!event.altKey,
+            runOnlyIf: (event)=>!event?.altKey,
             group: SHORTCUTS_GROUP
         });
     }
@@ -671,102 +759,100 @@ var /**
    */ unregisterShortcuts() {
         const shortcutManager = this.hot.getShortcutManager();
         const gridContext = shortcutManager.getContext('grid');
-        gridContext.removeShortcutsByGroup(SHORTCUTS_GROUP);
+        gridContext?.removeShortcutsByGroup(SHORTCUTS_GROUP);
     }
     /**
-   * Modify viewport start when needed. We extend viewport when merged cells aren't fully visible.
+   * Modify viewport start when needed.
    *
    * @private
    * @param {object} calc The row calculator object.
    * @param {number} nrOfColumns Number of visual columns.
    */ modifyViewportRowStart(calc, nrOfColumns) {
         const rowMapper = this.hot.rowIndexMapper;
-        const visualStartRow = rowMapper.getVisualFromRenderableIndex(calc.startRow);
+        const visualStartRow = rowMapper.getVisualFromRenderableIndex(calc.startRow) ?? 0;
         for(let visualColumnIndex = 0; visualColumnIndex < nrOfColumns; visualColumnIndex += 1){
             const mergeParentForViewportStart = this.mergedCellsCollection.get(visualStartRow, visualColumnIndex);
-            if (isObject(mergeParentForViewportStart)) {
-                const renderableIndexAtMergeStart = rowMapper.getRenderableFromVisualIndex(rowMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.row, 1));
-                // Merge start is out of the viewport (i.e. when we scrolled to the bottom and we can see just part of a merge).
-                if (renderableIndexAtMergeStart < calc.startRow) {
-                    // We extend viewport when some rows have been merged.
+            if (mergeParentForViewportStart !== false) {
+                const nearestNotHiddenRow = rowMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.row, 1);
+                const renderableIndexAtMergeStart = nearestNotHiddenRow !== null ? rowMapper.getRenderableFromVisualIndex(nearestNotHiddenRow) : null;
+                if (renderableIndexAtMergeStart !== null && renderableIndexAtMergeStart < calc.startRow) {
                     calc.startRow = renderableIndexAtMergeStart;
-                    // We are looking for next merges inside already extended viewport (starting again from row equal to 0).
-                    this.modifyViewportRowStart(calc, nrOfColumns); // recursively search upwards
-                    return; // Finish the current loop. Everything will be checked from the beginning by above recursion.
+                    this.modifyViewportRowStart(calc, nrOfColumns);
+                    return;
                 }
             }
         }
     }
     /**
-   *  Modify viewport end when needed. We extend viewport when merged cells aren't fully visible.
+   * Modify viewport end when needed.
    *
    * @private
    * @param {object} calc The row calculator object.
    * @param {number} nrOfColumns Number of visual columns.
    */ modifyViewportRowEnd(calc, nrOfColumns) {
         const rowMapper = this.hot.rowIndexMapper;
-        const visualEndRow = rowMapper.getVisualFromRenderableIndex(calc.endRow);
+        const visualEndRow = rowMapper.getVisualFromRenderableIndex(calc.endRow) ?? 0;
         for(let visualColumnIndex = 0; visualColumnIndex < nrOfColumns; visualColumnIndex += 1){
             const mergeParentForViewportEnd = this.mergedCellsCollection.get(visualEndRow, visualColumnIndex);
-            if (isObject(mergeParentForViewportEnd)) {
+            if (mergeParentForViewportEnd !== false) {
                 const mergeEnd = mergeParentForViewportEnd.row + mergeParentForViewportEnd.rowspan - 1;
-                const renderableIndexAtMergeEnd = rowMapper.getRenderableFromVisualIndex(rowMapper.getNearestNotHiddenIndex(mergeEnd, -1));
-                // Merge end is out of the viewport.
-                if (renderableIndexAtMergeEnd > calc.endRow) {
-                    // We extend the viewport when some rows have been merged.
-                    calc.endRow = renderableIndexAtMergeEnd;
-                    // We are looking for next merges inside already extended viewport (starting again from row equal to 0).
-                    this.modifyViewportRowEnd(calc, nrOfColumns); // recursively search upwards
-                    return; // Finish the current loop. Everything will be checked from the beginning by above recursion.
+                const nearestRow = rowMapper.getNearestNotHiddenIndex(mergeEnd, -1);
+                if (nearestRow !== null) {
+                    const renderableIndexAtMergeEnd = rowMapper.getRenderableFromVisualIndex(nearestRow);
+                    if (renderableIndexAtMergeEnd !== null && renderableIndexAtMergeEnd > calc.endRow) {
+                        calc.endRow = renderableIndexAtMergeEnd;
+                        this.modifyViewportRowEnd(calc, nrOfColumns);
+                        return;
+                    }
                 }
             }
         }
     }
     /**
-   * Modify viewport start when needed. We extend viewport when merged cells aren't fully visible.
+   * Modify viewport start when needed.
    *
    * @private
    * @param {object} calc The column calculator object.
    * @param {number} nrOfRows Number of visual rows.
    */ modifyViewportColumnStart(calc, nrOfRows) {
         const columnMapper = this.hot.columnIndexMapper;
-        const visualStartCol = columnMapper.getVisualFromRenderableIndex(calc.startColumn);
+        const visualStartCol = columnMapper.getVisualFromRenderableIndex(calc.startColumn) ?? 0;
         for(let visualRowIndex = 0; visualRowIndex < nrOfRows; visualRowIndex += 1){
             const mergeParentForViewportStart = this.mergedCellsCollection.get(visualRowIndex, visualStartCol);
-            if (isObject(mergeParentForViewportStart)) {
-                const renderableIndexAtMergeStart = columnMapper.getRenderableFromVisualIndex(columnMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.col, 1));
-                // Merge start is out of the viewport (i.e. when we scrolled to the right and we can see just part of a merge).
-                if (renderableIndexAtMergeStart < calc.startColumn) {
-                    // We extend viewport when some columns have been merged.
-                    calc.startColumn = renderableIndexAtMergeStart;
-                    // We are looking for next merges inside already extended viewport (starting again from column equal to 0).
-                    this.modifyViewportColumnStart(calc, nrOfRows); // recursively search upwards
-                    return; // Finish the current loop. Everything will be checked from the beginning by above recursion.
+            if (mergeParentForViewportStart !== false) {
+                const nearestCol = columnMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.col, 1);
+                if (nearestCol !== null) {
+                    const renderableIndexAtMergeStart = columnMapper.getRenderableFromVisualIndex(nearestCol);
+                    if (renderableIndexAtMergeStart !== null && renderableIndexAtMergeStart < calc.startColumn) {
+                        calc.startColumn = renderableIndexAtMergeStart;
+                        this.modifyViewportColumnStart(calc, nrOfRows);
+                        return;
+                    }
                 }
             }
         }
     }
     /**
-   *  Modify viewport end when needed. We extend viewport when merged cells aren't fully visible.
+   * Modify viewport end when needed.
    *
    * @private
    * @param {object} calc The column calculator object.
    * @param {number} nrOfRows Number of visual rows.
    */ modifyViewportColumnEnd(calc, nrOfRows) {
         const columnMapper = this.hot.columnIndexMapper;
-        const visualEndCol = columnMapper.getVisualFromRenderableIndex(calc.endColumn);
+        const visualEndCol = columnMapper.getVisualFromRenderableIndex(calc.endColumn) ?? 0;
         for(let visualRowIndex = 0; visualRowIndex < nrOfRows; visualRowIndex += 1){
             const mergeParentForViewportEnd = this.mergedCellsCollection.get(visualRowIndex, visualEndCol);
-            if (isObject(mergeParentForViewportEnd)) {
+            if (mergeParentForViewportEnd !== false) {
                 const mergeEnd = mergeParentForViewportEnd.col + mergeParentForViewportEnd.colspan - 1;
-                const renderableIndexAtMergeEnd = columnMapper.getRenderableFromVisualIndex(columnMapper.getNearestNotHiddenIndex(mergeEnd, -1));
-                // Merge end is out of the viewport.
-                if (renderableIndexAtMergeEnd > calc.endColumn) {
-                    // We extend the viewport when some columns have been merged.
-                    calc.endColumn = renderableIndexAtMergeEnd;
-                    // We are looking for next merges inside already extended viewport (starting again from column equal to 0).
-                    this.modifyViewportColumnEnd(calc, nrOfRows); // recursively search upwards
-                    return; // Finish the current loop. Everything will be checked from the beginning by above recursion.
+                const nearestCol = columnMapper.getNearestNotHiddenIndex(mergeEnd, -1);
+                if (nearestCol !== null) {
+                    const renderableIndexAtMergeEnd = columnMapper.getRenderableFromVisualIndex(nearestCol);
+                    if (renderableIndexAtMergeEnd !== null && renderableIndexAtMergeEnd > calc.endColumn) {
+                        calc.endColumn = renderableIndexAtMergeEnd;
+                        this.modifyViewportColumnEnd(calc, nrOfRows);
+                        return;
+                    }
                 }
             }
         }
@@ -776,16 +862,10 @@ var /**
    *
    * @private
    * @param {number} parentRow Visual row index.
-   * @param {number} rowspan Rowspan which describes shift which will be applied to parent row
-   *                         to calculate renderable index which points to the most bottom
-   *                         index position. Pass rowspan as `0` to calculate the most top
-   *                         index position.
+   * @param {number} rowspan Rowspan.
    * @param {number} parentColumn Visual column index.
-   * @param {number} colspan Colspan which describes shift which will be applied to parent column
-   *                         to calculate renderable index which points to the most right
-   *                         index position. Pass colspan as `0` to calculate the most left
-   *                         index position.
-   * @returns {number[]}
+   * @param {number} colspan Colspan.
+   * @returns {Array<number>} A two-element array of `[renderableRow, renderableColumn]`.
    */ translateMergedCellToRenderable(parentRow, rowspan, parentColumn, colspan) {
         const { rowIndexMapper: rowMapper, columnIndexMapper: columnMapper } = this.hot;
         let firstNonHiddenRow;
@@ -800,15 +880,15 @@ var /**
         } else {
             firstNonHiddenColumn = columnMapper.getNearestNotHiddenIndex(parentColumn + colspan - 1, -1);
         }
-        const renderableRow = parentRow >= 0 ? rowMapper.getRenderableFromVisualIndex(firstNonHiddenRow) : parentRow;
-        const renderableColumn = parentColumn >= 0 ? columnMapper.getRenderableFromVisualIndex(firstNonHiddenColumn) : parentColumn;
+        const renderableRow = parentRow >= 0 && firstNonHiddenRow !== null ? rowMapper.getRenderableFromVisualIndex(firstNonHiddenRow) ?? parentRow : parentRow;
+        const renderableColumn = parentColumn >= 0 && firstNonHiddenColumn !== null ? columnMapper.getRenderableFromVisualIndex(firstNonHiddenColumn) ?? parentColumn : parentColumn;
         return [
             renderableRow,
             renderableColumn
         ];
     }
     constructor(...args){
-        super(...args), _class_private_method_init(this, _onAfterInit), _class_private_method_init(this, _onAfterIsMultipleSelection), _class_private_method_init(this, _onModifyTransformFocus), _class_private_method_init(this, _onModifyTransformStart), _class_private_method_init(this, _onModifyTransformEnd), _class_private_method_init(this, _onBeforeSelectionHighlightSet), _class_private_method_init(this, _onModifyGetCellCoords), _class_private_method_init(this, _addMergeActionsToContextMenu), _class_private_method_init(this, _onBeforeSetRangeStart), _class_private_method_init(this, _onBeforeSelectionFocusSet), _class_private_method_init(this, _onAfterSelectionFocusSet), _class_private_method_init(this, _onAfterSelectionEnd), _class_private_method_init(this, _onAfterGetCellMeta), _class_private_method_init(this, _onAfterViewportRowCalculatorOverride), _class_private_method_init(this, _onAfterViewportColumnCalculatorOverride), _class_private_method_init(this, _onModifyAutofillRange), _class_private_method_init(this, _onAfterCreateCol), _class_private_method_init(this, _onAfterRemoveCol), _class_private_method_init(this, _onAfterCreateRow), _class_private_method_init(this, _onAfterRemoveRow), _class_private_method_init(this, _onAfterChange), _class_private_method_init(this, _onBeforeDrawAreaBorders), _class_private_method_init(this, _onAfterDrawSelection), _class_private_method_init(this, _onBeforeRemoveCellClassNames), _class_private_method_init(this, _onBeforeBeginEditing), _class_private_method_init(this, _onModifyRowHeightByOverlayName), _class_private_field_init(this, _lastSelectedFocus, {
+        super(...args), _class_private_method_init(this, _addMergeActionsToContextMenu), _class_private_field_init(this, _lastSelectedFocus, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _lastFocusDelta, {
@@ -820,441 +900,592 @@ var /**
         }), _class_private_field_init(this, _cellRenderer, {
             writable: true,
             value: void 0
-        }), /**
-   * A container for all the merged cells.
-   *
-   * @private
-   * @type {MergedCellsCollection}
-   */ this.mergedCellsCollection = null, /**
-   * Instance of the class responsible for all the autofill-related calculations.
-   *
-   * @private
-   * @type {AutofillCalculations}
-   */ this.autofillCalculations = null, /**
-   * Instance of the class responsible for the selection-related calculations.
-   *
-   * @private
-   * @type {SelectionCalculations}
-   */ this.selectionCalculations = null, _class_private_field_set(this, _lastSelectedFocus, null), _class_private_field_set(this, _lastFocusDelta, {
+        }), _class_private_field_init(this, _columnMoveSnapshot, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _rowMoveSnapshot, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _initialized, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterInit, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterIsMultipleSelection, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onModifyTransformFocus, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onModifyTransformStart, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onModifyTransformEnd, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeSelectionHighlightSet, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onModifyGetCellCoords, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeSetRangeStart, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeSelectionFocusSet, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterSelectionFocusSet, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterSelectionEnd, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterGetCellMeta, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterViewportRowCalculatorOverride, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterViewportColumnCalculatorOverride, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onModifyAutofillRange, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterCreateCol, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterRemoveCol, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterCreateRow, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterRemoveRow, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeColumnMove, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterColumnMove, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeRowMove, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterRowMove, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeColumnFreeze, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterColumnFreeze, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterChange, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeDrawAreaBorders, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterDrawSelection, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeRemoveCellClassNames, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeBeginEditing, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onModifyRowHeightByOverlayName, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_set(this, _lastSelectedFocus, null), _class_private_field_set(this, _lastFocusDelta, {
             row: 0,
             col: 0
         }), _class_private_field_set(this, _focusOrder, new FocusOrder({
             mergedCellsGetter: (row, column)=>this.mergedCellsCollection.get(row, column),
             rowIndexMapper: this.hot.rowIndexMapper,
             columnIndexMapper: this.hot.columnIndexMapper
-        })), _class_private_field_set(this, _cellRenderer, createMergeCellRenderer(this));
-    }
-}
-function onAfterInit() {
-    this.generateFromSettings();
-    this.hot.render();
-}
-function onAfterIsMultipleSelection(isMultiple) {
-    if (isMultiple) {
-        const mergedCells = this.mergedCellsCollection.mergedCells;
-        const selectionRange = this.hot.getSelectedRangeActive();
-        const topStartCoords = selectionRange.getTopStartCorner();
-        const bottomEndCoords = selectionRange.getBottomEndCorner();
-        for(let group = 0; group < mergedCells.length; group += 1){
-            if (topStartCoords.row === mergedCells[group].row && topStartCoords.col === mergedCells[group].col && bottomEndCoords.row === mergedCells[group].row + mergedCells[group].rowspan - 1 && bottomEndCoords.col === mergedCells[group].col + mergedCells[group].colspan - 1) {
-                return false;
+        })), _class_private_field_set(this, _cellRenderer, createMergeCellRenderer(this)), _class_private_field_set(this, _columnMoveSnapshot, null), _class_private_field_set(this, _rowMoveSnapshot, null), _class_private_field_set(this, _initialized, false), _class_private_field_set(this, _onAfterInit, ()=>{
+            this.generateFromSettings();
+            this.hot.render();
+            _class_private_field_set(this, _initialized, true);
+        }), _class_private_field_set(this, _onAfterIsMultipleSelection, (isMultiple)=>{
+            if (isMultiple) {
+                const mergedCells = this.mergedCellsCollection.mergedCells;
+                const selectionRange = this.hot.getSelectedRangeActive();
+                if (!selectionRange) {
+                    return isMultiple;
+                }
+                const topStartCoords = selectionRange.getTopStartCorner();
+                const bottomEndCoords = selectionRange.getBottomEndCorner();
+                for(let group = 0; group < mergedCells.length; group += 1){
+                    if (topStartCoords.row === mergedCells[group].row && topStartCoords.col === mergedCells[group].col && bottomEndCoords.row === mergedCells[group].row + mergedCells[group].rowspan - 1 && bottomEndCoords.col === mergedCells[group].col + mergedCells[group].colspan - 1) {
+                        return false;
+                    }
+                }
             }
-        }
-    }
-    return isMultiple;
-}
-function onModifyTransformFocus(delta) {
-    _class_private_field_get(this, _lastFocusDelta).row = delta.row;
-    _class_private_field_get(this, _lastFocusDelta).col = delta.col;
-}
-function onModifyTransformStart(delta) {
-    const selectedRange = this.hot.getSelectedRangeActive();
-    const { highlight } = selectedRange;
-    const { columnIndexMapper, rowIndexMapper } = this.hot;
-    if (_class_private_field_get(this, _lastSelectedFocus)) {
-        if (rowIndexMapper.getRenderableFromVisualIndex(_class_private_field_get(this, _lastSelectedFocus).row) !== null) {
-            highlight.row = _class_private_field_get(this, _lastSelectedFocus).row;
-        }
-        if (columnIndexMapper.getRenderableFromVisualIndex(_class_private_field_get(this, _lastSelectedFocus).col) !== null) {
-            highlight.col = _class_private_field_get(this, _lastSelectedFocus).col;
-        }
-        _class_private_field_set(this, _lastSelectedFocus, null);
-    }
-    const mergedParent = this.mergedCellsCollection.get(highlight.row, highlight.col);
-    if (!mergedParent) {
-        return;
-    }
-    const visualColumnIndexStart = mergedParent.col;
-    const visualColumnIndexEnd = mergedParent.col + mergedParent.colspan - 1;
-    if (delta.col < 0) {
-        const nextColumn = highlight.col >= visualColumnIndexStart && highlight.col <= visualColumnIndexEnd ? visualColumnIndexStart - 1 : visualColumnIndexEnd;
-        const notHiddenColumnIndex = 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 = 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);
-        }
-    }
-    const visualRowIndexStart = mergedParent.row;
-    const visualRowIndexEnd = mergedParent.row + mergedParent.rowspan - 1;
-    if (delta.row < 0) {
-        const nextRow = highlight.row >= visualRowIndexStart && highlight.row <= visualRowIndexEnd ? visualRowIndexStart - 1 : visualRowIndexEnd;
-        const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, -1);
-        if (notHiddenRowIndex === null) {
-            // There are no visible rows 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 column (if autoWrapCol is enabled).
-            delta.row = -this.hot.view.countRenderableRowsInRange(0, highlight.row);
-        } else {
-            delta.row = -Math.max(this.hot.view.countRenderableRowsInRange(notHiddenRowIndex, highlight.row) - 1, 1);
-        }
-    } else if (delta.row > 0) {
-        const nextRow = highlight.row >= visualRowIndexStart && highlight.row <= visualRowIndexEnd ? visualRowIndexEnd + 1 : visualRowIndexStart;
-        const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, 1);
-        if (notHiddenRowIndex === null) {
-            // There are no visible rows 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 column (if autoWrapCol is enabled).
-            delta.row = this.hot.view.countRenderableRowsInRange(highlight.row, this.hot.countRows());
-        } else {
-            delta.row = Math.max(this.hot.view.countRenderableRowsInRange(highlight.row, notHiddenRowIndex) - 1, 1);
-        }
-    }
-}
-function onModifyTransformEnd(delta) {
-    const selectedRange = this.hot.getSelectedRangeActive();
-    const cloneRange = selectedRange.clone();
-    const { to } = selectedRange;
-    const { columnIndexMapper, rowIndexMapper } = this.hot;
-    const expandCloneRange = (row, col)=>{
-        cloneRange.expand(this.hot._createCellCoords(row, col));
-        for(let i = 0; i < this.mergedCellsCollection.mergedCells.length; i += 1){
-            cloneRange.expandByRange(this.mergedCellsCollection.mergedCells[i].getRange());
-        }
-    };
-    if (delta.col < 0) {
-        let nextColumn = this.mergedCellsCollection.getStartMostColumnIndex(selectedRange, to.col) + delta.col;
-        expandCloneRange(to.row, nextColumn);
-        if (selectedRange.getHorizontalDirection() === 'E-W' && cloneRange.getHorizontalDirection() === 'E-W') {
-            nextColumn = cloneRange.getTopStartCorner().col;
-        }
-        const notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(nextColumn, 1);
-        if (notHiddenColumnIndex !== null) {
-            delta.col = -Math.max(this.hot.view.countRenderableColumnsInRange(notHiddenColumnIndex, to.col) - 1, 1);
-        }
-    } else if (delta.col > 0) {
-        let nextColumn = this.mergedCellsCollection.getEndMostColumnIndex(selectedRange, to.col) + delta.col;
-        expandCloneRange(to.row, nextColumn);
-        if (selectedRange.getHorizontalDirection() === 'W-E' && cloneRange.getHorizontalDirection() === 'W-E') {
-            nextColumn = cloneRange.getBottomEndCorner().col;
-        }
-        const notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(nextColumn, -1);
-        if (notHiddenColumnIndex !== null) {
-            delta.col = Math.max(this.hot.view.countRenderableColumnsInRange(to.col, notHiddenColumnIndex) - 1, 1);
-        }
-    }
-    if (delta.row < 0) {
-        let nextRow = this.mergedCellsCollection.getTopMostRowIndex(selectedRange, to.row) + delta.row;
-        expandCloneRange(nextRow, to.col);
-        if (selectedRange.getVerticalDirection() === 'S-N' && cloneRange.getVerticalDirection() === 'S-N') {
-            nextRow = cloneRange.getTopStartCorner().row;
-        }
-        const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, 1);
-        if (notHiddenRowIndex !== null) {
-            delta.row = -Math.max(this.hot.view.countRenderableRowsInRange(notHiddenRowIndex, to.row) - 1, 1);
-        }
-    } else if (delta.row > 0) {
-        let nextRow = this.mergedCellsCollection.getBottomMostRowIndex(selectedRange, to.row) + delta.row;
-        expandCloneRange(nextRow, to.col);
-        if (selectedRange.getVerticalDirection() === 'N-S' && cloneRange.getVerticalDirection() === 'N-S') {
-            nextRow = cloneRange.getBottomStartCorner().row;
-        }
-        const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, -1);
-        if (notHiddenRowIndex !== null) {
-            delta.row = Math.max(this.hot.view.countRenderableRowsInRange(to.row, notHiddenRowIndex) - 1, 1);
-        }
-    }
-}
-function onBeforeSelectionHighlightSet() {
-    const selectedRange = this.hot.getSelectedRangeLast();
-    const { highlight } = selectedRange;
-    if (this.hot.selection.isSelectedByColumnHeader() || this.hot.selection.isSelectedByRowHeader()) {
-        _class_private_field_set(this, _lastSelectedFocus, highlight.clone());
-        return;
-    }
-    for(let i = 0; i < this.mergedCellsCollection.mergedCells.length; i += 1){
-        selectedRange.expandByRange(this.mergedCellsCollection.mergedCells[i].getRange(), false);
-    }
-    // TODO: This is a workaround for an issue with the selection not being extended properly.
-    // In some cases when the merge cells are defined in random order the selection is not
-    // extended in that way that it covers all overlapped merge cells.
-    for(let i = 0; i < this.mergedCellsCollection.mergedCells.length; i += 1){
-        selectedRange.expandByRange(this.mergedCellsCollection.mergedCells[i].getRange(), false);
-    }
-    const mergedParent = this.mergedCellsCollection.get(highlight.row, highlight.col);
-    _class_private_field_set(this, _lastSelectedFocus, highlight.clone());
-    if (mergedParent) {
-        highlight.assign(mergedParent);
-    }
-}
-function onModifyGetCellCoords(row, column, topmost, source) {
-    if (row < 0 || column < 0) {
-        return;
-    }
-    const mergeParent = this.mergedCellsCollection.get(row, column);
-    if (!mergeParent) {
-        return;
-    }
-    const { row: mergeRow, col: mergeColumn, colspan, rowspan } = mergeParent;
-    const topStartRow = mergeRow;
-    const topStartColumn = mergeColumn;
-    const bottomEndRow = mergeRow + rowspan - 1;
-    const bottomEndColumn = mergeColumn + colspan - 1;
-    if (source === 'render' && this.getSetting('virtualized')) {
-        const overlayName = this.hot.view.getActiveOverlayName();
-        const firstRenderedRow = [
-            'top',
-            'top_inline_start_corner'
-        ].includes(overlayName) ? 0 : this.hot.getFirstRenderedVisibleRow();
-        const firstRenderedColumn = [
-            'inline_start',
-            'top_inline_start_corner',
-            'bottom_inline_start_corner'
-        ].includes(overlayName) ? 0 : this.hot.getFirstRenderedVisibleColumn();
-        return [
-            clamp(firstRenderedRow, topStartRow, bottomEndRow),
-            clamp(firstRenderedColumn, topStartColumn, bottomEndColumn),
-            clamp(this.hot.getLastRenderedVisibleRow(), topStartRow, bottomEndRow),
-            clamp(this.hot.getLastRenderedVisibleColumn(), topStartColumn, bottomEndColumn)
-        ];
+            return isMultiple;
+        }), _class_private_field_set(this, _onModifyTransformFocus, (delta)=>{
+            _class_private_field_get(this, _lastFocusDelta).row = delta.row;
+            _class_private_field_get(this, _lastFocusDelta).col = delta.col;
+        }), _class_private_field_set(this, _onModifyTransformStart, (delta)=>{
+            const selectedRange = this.hot.getSelectedRangeActive();
+            if (!selectedRange) {
+                return;
+            }
+            const { highlight } = selectedRange;
+            const { columnIndexMapper, rowIndexMapper } = this.hot;
+            if (_class_private_field_get(this, _lastSelectedFocus)) {
+                if (_class_private_field_get(this, _lastSelectedFocus).row !== null && rowIndexMapper.getRenderableFromVisualIndex(_class_private_field_get(this, _lastSelectedFocus).row) !== null) {
+                    highlight.row = _class_private_field_get(this, _lastSelectedFocus).row;
+                }
+                if (_class_private_field_get(this, _lastSelectedFocus).col !== null && columnIndexMapper.getRenderableFromVisualIndex(_class_private_field_get(this, _lastSelectedFocus).col) !== null) {
+                    highlight.col = _class_private_field_get(this, _lastSelectedFocus).col;
+                }
+                _class_private_field_set(this, _lastSelectedFocus, null);
+            }
+            if (highlight.row === null || highlight.col === null) {
+                return;
+            }
+            const mergedParent = this.mergedCellsCollection.get(highlight.row, highlight.col);
+            if (!mergedParent) {
+                return;
+            }
+            const visualColumnIndexStart = mergedParent.col;
+            const visualColumnIndexEnd = mergedParent.col + mergedParent.colspan - 1;
+            if (delta.col < 0) {
+                const nextColumn = highlight.col >= visualColumnIndexStart && highlight.col <= visualColumnIndexEnd ? visualColumnIndexStart - 1 : visualColumnIndexEnd;
+                const notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(nextColumn, -1);
+                if (notHiddenColumnIndex === null) {
+                    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 = columnIndexMapper.getNearestNotHiddenIndex(nextColumn, 1);
+                if (notHiddenColumnIndex === null) {
+                    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);
+                }
+            }
+            const visualRowIndexStart = mergedParent.row;
+            const visualRowIndexEnd = mergedParent.row + mergedParent.rowspan - 1;
+            if (delta.row < 0) {
+                const nextRow = highlight.row >= visualRowIndexStart && highlight.row <= visualRowIndexEnd ? visualRowIndexStart - 1 : visualRowIndexEnd;
+                const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, -1);
+                if (notHiddenRowIndex === null) {
+                    delta.row = -this.hot.view.countRenderableRowsInRange(0, highlight.row);
+                } else {
+                    delta.row = -Math.max(this.hot.view.countRenderableRowsInRange(notHiddenRowIndex, highlight.row) - 1, 1);
+                }
+            } else if (delta.row > 0) {
+                const nextRow = highlight.row >= visualRowIndexStart && highlight.row <= visualRowIndexEnd ? visualRowIndexEnd + 1 : visualRowIndexStart;
+                const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, 1);
+                if (notHiddenRowIndex === null) {
+                    delta.row = this.hot.view.countRenderableRowsInRange(highlight.row, this.hot.countRows());
+                } else {
+                    delta.row = Math.max(this.hot.view.countRenderableRowsInRange(highlight.row, notHiddenRowIndex) - 1, 1);
+                }
+            }
+        }), _class_private_field_set(this, _onModifyTransformEnd, (delta)=>{
+            const selectedRange = this.hot.getSelectedRangeActive();
+            if (!selectedRange) {
+                return;
+            }
+            const cloneRange = selectedRange.clone();
+            const { to } = selectedRange;
+            const toRow = to.row ?? 0;
+            const toCol = to.col ?? 0;
+            const { columnIndexMapper, rowIndexMapper } = this.hot;
+            const expandCloneRange = (row, col)=>{
+                cloneRange.expand(this.hot._createCellCoords(row, col));
+                for(let i = 0; i < this.mergedCellsCollection.mergedCells.length; i += 1){
+                    const range = this.mergedCellsCollection.mergedCells[i].getRange();
+                    if (range) {
+                        cloneRange.expandByRange(range);
+                    }
+                }
+            };
+            if (delta.col < 0) {
+                let nextColumn = this.mergedCellsCollection.getStartMostColumnIndex(selectedRange, toCol) + delta.col;
+                expandCloneRange(toRow, nextColumn);
+                if (selectedRange.getHorizontalDirection() === 'E-W' && cloneRange.getHorizontalDirection() === 'E-W') {
+                    nextColumn = cloneRange.getTopStartCorner().col ?? nextColumn;
+                }
+                const notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(nextColumn, 1);
+                if (notHiddenColumnIndex !== null) {
+                    delta.col = -Math.max(this.hot.view.countRenderableColumnsInRange(notHiddenColumnIndex, toCol) - 1, 1);
+                }
+            } else if (delta.col > 0) {
+                let nextColumn = this.mergedCellsCollection.getEndMostColumnIndex(selectedRange, toCol) + delta.col;
+                expandCloneRange(toRow, nextColumn);
+                if (selectedRange.getHorizontalDirection() === 'W-E' && cloneRange.getHorizontalDirection() === 'W-E') {
+                    nextColumn = cloneRange.getBottomEndCorner().col ?? nextColumn;
+                }
+                const notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(nextColumn, -1);
+                if (notHiddenColumnIndex !== null) {
+                    delta.col = Math.max(this.hot.view.countRenderableColumnsInRange(toCol, notHiddenColumnIndex) - 1, 1);
+                }
+            }
+            if (delta.row < 0) {
+                let nextRow = this.mergedCellsCollection.getTopMostRowIndex(selectedRange, toRow) + delta.row;
+                expandCloneRange(nextRow, toCol);
+                if (selectedRange.getVerticalDirection() === 'S-N' && cloneRange.getVerticalDirection() === 'S-N') {
+                    nextRow = cloneRange.getTopStartCorner().row ?? nextRow;
+                }
+                const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, 1);
+                if (notHiddenRowIndex !== null) {
+                    delta.row = -Math.max(this.hot.view.countRenderableRowsInRange(notHiddenRowIndex, toRow) - 1, 1);
+                }
+            } else if (delta.row > 0) {
+                let nextRow = this.mergedCellsCollection.getBottomMostRowIndex(selectedRange, toRow) + delta.row;
+                expandCloneRange(nextRow, toCol);
+                if (selectedRange.getVerticalDirection() === 'N-S' && cloneRange.getVerticalDirection() === 'N-S') {
+                    nextRow = cloneRange.getBottomStartCorner().row ?? nextRow;
+                }
+                const notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(nextRow, -1);
+                if (notHiddenRowIndex !== null) {
+                    delta.row = Math.max(this.hot.view.countRenderableRowsInRange(toRow, notHiddenRowIndex) - 1, 1);
+                }
+            }
+        }), _class_private_field_set(this, _onBeforeSelectionHighlightSet, ()=>{
+            const selectedRange = this.hot.getSelectedRangeLast();
+            if (!selectedRange) {
+                return;
+            }
+            const { highlight } = selectedRange;
+            if (this.hot.selection.isSelectedByColumnHeader() || this.hot.selection.isSelectedByRowHeader()) {
+                _class_private_field_set(this, _lastSelectedFocus, highlight.clone());
+                return;
+            }
+            for(let i = 0; i < this.mergedCellsCollection.mergedCells.length; i += 1){
+                const range = this.mergedCellsCollection.mergedCells[i].getRange();
+                if (range) {
+                    selectedRange.expandByRange(range, false);
+                }
+            }
+            for(let i = 0; i < this.mergedCellsCollection.mergedCells.length; i += 1){
+                const range = this.mergedCellsCollection.mergedCells[i].getRange();
+                if (range) {
+                    selectedRange.expandByRange(range, false);
+                }
+            }
+            if (highlight.row === null || highlight.col === null) {
+                return;
+            }
+            const mergedParent = this.mergedCellsCollection.get(highlight.row, highlight.col);
+            _class_private_field_set(this, _lastSelectedFocus, highlight.clone());
+            if (mergedParent) {
+                highlight.assign(mergedParent);
+            }
+        }), _class_private_field_set(this, _onModifyGetCellCoords, (row, column, topmost, source)=>{
+            if (row < 0 || column < 0) {
+                return;
+            }
+            const mergeParent = this.mergedCellsCollection.get(row, column);
+            if (!mergeParent) {
+                return;
+            }
+            const { row: mergeRow, col: mergeColumn, colspan, rowspan } = mergeParent;
+            const topStartRow = mergeRow;
+            const topStartColumn = mergeColumn;
+            const bottomEndRow = mergeRow + rowspan - 1;
+            const bottomEndColumn = mergeColumn + colspan - 1;
+            if (source === 'render' && this.getSetting('virtualized')) {
+                const overlayName = this.hot.view.getActiveOverlayName();
+                const firstRenderedRow = [
+                    'top',
+                    'top_inline_start_corner'
+                ].includes(overlayName) ? 0 : this.hot.getFirstRenderedVisibleRow();
+                const firstRenderedColumn = [
+                    'inline_start',
+                    'top_inline_start_corner',
+                    'bottom_inline_start_corner'
+                ].includes(overlayName) ? 0 : this.hot.getFirstRenderedVisibleColumn();
+                return [
+                    clamp(firstRenderedRow, topStartRow, bottomEndRow),
+                    clamp(firstRenderedColumn, topStartColumn, bottomEndColumn),
+                    clamp(this.hot.getLastRenderedVisibleRow(), topStartRow, bottomEndRow),
+                    clamp(this.hot.getLastRenderedVisibleColumn(), topStartColumn, bottomEndColumn)
+                ];
+            }
+            return [
+                topStartRow,
+                topStartColumn,
+                bottomEndRow,
+                bottomEndColumn
+            ];
+        }), _class_private_field_set(this, _onBeforeSetRangeStart, ()=>{
+            _class_private_field_set(this, _lastSelectedFocus, null);
+        }), _class_private_field_set(this, _onBeforeSelectionFocusSet, ()=>{
+            if (!_class_private_field_get(this, _lastSelectedFocus) || _class_private_field_get(this, _lastSelectedFocus).isCell()) {
+                return;
+            }
+            const selectedRange = this.hot.getSelectedRangeActive();
+            if (!selectedRange) {
+                return;
+            }
+            const verticalDir = selectedRange.getVerticalDirection();
+            const horizontalDir = selectedRange.getHorizontalDirection();
+            const focusCoords = _class_private_field_get(this, _lastSelectedFocus).clone().normalize();
+            if (focusCoords.row === null || focusCoords.col === null) {
+                return;
+            }
+            _class_private_field_get(this, _focusOrder).setActiveNode(focusCoords.row, focusCoords.col);
+            if (_class_private_field_get(this, _lastFocusDelta).row > 0 || _class_private_field_get(this, _lastFocusDelta).col > 0) {
+                _class_private_field_get(this, _focusOrder).setPrevNodeAsActive();
+            } else if (horizontalDir === 'E-W' && _class_private_field_get(this, _lastFocusDelta).col < 0 || verticalDir === 'S-N' && _class_private_field_get(this, _lastFocusDelta).row < 0) {
+                _class_private_field_get(this, _focusOrder).setNextNodeAsActive();
+            }
+        }), _class_private_field_set(this, _onAfterSelectionFocusSet, (row, column)=>{
+            const { columnIndexMapper, rowIndexMapper } = this.hot;
+            let activeSelectionLayerIndex = this.hot.getActiveSelectionLayerIndex();
+            let notHiddenRowIndex = null;
+            let notHiddenColumnIndex = null;
+            if (_class_private_field_get(this, _lastFocusDelta).col < 0) {
+                const { rowEnd, colEnd, selectionLayer } = _class_private_field_get(this, _focusOrder).getPrevHorizontalNode();
+                notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colEnd, -1);
+                notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowEnd, -1);
+                activeSelectionLayerIndex = selectionLayer;
+            } else if (_class_private_field_get(this, _lastFocusDelta).col > 0) {
+                const { rowStart, colStart, selectionLayer } = _class_private_field_get(this, _focusOrder).getNextHorizontalNode();
+                notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colStart, 1);
+                notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowStart, 1);
+                activeSelectionLayerIndex = selectionLayer;
+            } else if (_class_private_field_get(this, _lastFocusDelta).row < 0) {
+                const { rowEnd, colEnd, selectionLayer } = _class_private_field_get(this, _focusOrder).getPrevVerticalNode();
+                notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colEnd, -1);
+                notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowEnd, -1);
+                activeSelectionLayerIndex = selectionLayer;
+            } else if (_class_private_field_get(this, _lastFocusDelta).row > 0) {
+                const { rowStart, colStart, selectionLayer } = _class_private_field_get(this, _focusOrder).getNextVerticalNode();
+                notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colStart, 1);
+                notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowStart, 1);
+                activeSelectionLayerIndex = selectionLayer;
+            }
+            if (notHiddenRowIndex !== null || notHiddenColumnIndex !== null) {
+                this.hot.selection.setActiveSelectionLayerIndex(activeSelectionLayerIndex);
+                const selectedRange = this.hot.getSelectedRangeActive();
+                const resolvedRow = notHiddenRowIndex ?? 0;
+                const resolvedCol = notHiddenColumnIndex ?? 0;
+                const coords = this.hot._createCellCoords(resolvedRow, resolvedCol);
+                const mergeParent = this.mergedCellsCollection.get(resolvedRow, resolvedCol);
+                const focusHighlight = this.hot.selection.highlight.getFocus();
+                row = resolvedRow;
+                column = resolvedCol;
+                if (selectedRange) {
+                    if (mergeParent) {
+                        selectedRange.highlight.assign({
+                            row: this.hot.rowIndexMapper.getNearestNotHiddenIndex(mergeParent.row, 1) ?? undefined,
+                            col: this.hot.columnIndexMapper.getNearestNotHiddenIndex(mergeParent.col, 1) ?? undefined
+                        });
+                    } else {
+                        selectedRange.highlight.assign(coords);
+                    }
+                }
+                focusHighlight.clear();
+                focusHighlight.add(coords).commit();
+            }
+            _class_private_field_get(this, _focusOrder).setActiveNode(row, column, activeSelectionLayerIndex);
+            _class_private_field_set(this, _lastFocusDelta, {
+                row: 0,
+                col: 0
+            });
+        }), _class_private_field_set(this, _onAfterSelectionEnd, ()=>{
+            const selectedRanges = this.hot.getSelectedRange();
+            if (selectedRanges) {
+                _class_private_field_get(this, _focusOrder).buildFocusOrder(selectedRanges);
+            }
+        }), _class_private_field_set(this, _onAfterGetCellMeta, (row, col, cellProperties)=>{
+            const mergeParent = this.mergedCellsCollection.get(row, col);
+            if (mergeParent) {
+                if (mergeParent.row !== row || mergeParent.col !== col) {
+                    cellProperties.copyable = false;
+                    cellProperties.hidden = true;
+                } else {
+                    cellProperties.rowspan = mergeParent.rowspan;
+                    cellProperties.colspan = mergeParent.colspan;
+                    cellProperties.spanned = true;
+                }
+            }
+        }), _class_private_field_set(this, _onAfterViewportRowCalculatorOverride, (calc)=>{
+            if (this.getSetting('virtualized')) {
+                return;
+            }
+            const nrOfColumns = this.hot.countCols();
+            this.modifyViewportRowStart(calc, nrOfColumns);
+            this.modifyViewportRowEnd(calc, nrOfColumns);
+        }), _class_private_field_set(this, _onAfterViewportColumnCalculatorOverride, (calc)=>{
+            if (this.getSetting('virtualized')) {
+                return;
+            }
+            const nrOfRows = this.hot.countRows();
+            this.modifyViewportColumnStart(calc, nrOfRows);
+            this.modifyViewportColumnEnd(calc, nrOfRows);
+        }), _class_private_field_set(this, _onModifyAutofillRange, (fullArea, baseArea)=>{
+            const dragDirection = this.autofillCalculations.getDirection(baseArea, fullArea);
+            if (this.autofillCalculations.dragAreaOverlapsCollections(baseArea, fullArea, dragDirection)) {
+                return baseArea;
+            }
+            const from = this.hot._createCellCoords(baseArea[0], baseArea[1]);
+            const to = this.hot._createCellCoords(baseArea[2], baseArea[3]);
+            const range = this.hot._createCellRange(from, from, to);
+            const mergedCellsWithinSelectionArea = this.mergedCellsCollection.getWithinRange(range);
+            if (mergedCellsWithinSelectionArea.length === 0) {
+                return fullArea;
+            }
+            return this.autofillCalculations.snapDragArea(baseArea, fullArea, dragDirection, mergedCellsWithinSelectionArea);
+        }), _class_private_field_set(this, _onAfterCreateCol, (column, count)=>{
+            this.mergedCellsCollection.shiftCollections('right', column, count);
+        }), _class_private_field_set(this, _onAfterRemoveCol, (column, count)=>{
+            this.mergedCellsCollection.shiftCollections('left', column, count);
+        }), _class_private_field_set(this, _onAfterCreateRow, (row, count, source)=>{
+            if (source === 'auto') {
+                return;
+            }
+            this.mergedCellsCollection.shiftCollections('down', row, count);
+        }), _class_private_field_set(this, _onAfterRemoveRow, (row, count)=>{
+            this.mergedCellsCollection.shiftCollections('up', row, count);
+        }), _class_private_field_set(this, _onBeforeColumnMove, (_columns, _finalIndex, _dropIndex, movePossible)=>{
+            if (!movePossible || !_class_private_field_get(this, _initialized)) {
+                _class_private_field_set(this, _columnMoveSnapshot, null);
+                return;
+            }
+            _class_private_field_set(this, _columnMoveSnapshot, this.mergedCellsCollection.capturePhysicalSpans('column'));
+        }), _class_private_field_set(this, _onAfterColumnMove, (_columns, _finalIndex, _dropIndex, _movePossible, orderChanged)=>{
+            const snapshot = _class_private_field_get(this, _columnMoveSnapshot);
+            _class_private_field_set(this, _columnMoveSnapshot, null);
+            if (!orderChanged || !snapshot) {
+                return;
+            }
+            this.mergedCellsCollection.translateAfterAxisMove('column', snapshot);
+            this.hot.render();
+        }), _class_private_field_set(this, _onBeforeRowMove, (_rows, _finalIndex, _dropIndex, movePossible)=>{
+            if (!movePossible || !_class_private_field_get(this, _initialized)) {
+                _class_private_field_set(this, _rowMoveSnapshot, null);
+                return;
+            }
+            _class_private_field_set(this, _rowMoveSnapshot, this.mergedCellsCollection.capturePhysicalSpans('row'));
+        }), _class_private_field_set(this, _onAfterRowMove, (_rows, _finalIndex, _dropIndex, _movePossible, orderChanged)=>{
+            const snapshot = _class_private_field_get(this, _rowMoveSnapshot);
+            _class_private_field_set(this, _rowMoveSnapshot, null);
+            if (!orderChanged || !snapshot) {
+                return;
+            }
+            this.mergedCellsCollection.translateAfterAxisMove('row', snapshot);
+            this.hot.render();
+        }), _class_private_field_set(this, _onBeforeColumnFreeze, (_column, performed)=>{
+            if (!performed || !_class_private_field_get(this, _initialized)) {
+                _class_private_field_set(this, _columnMoveSnapshot, null);
+                return;
+            }
+            _class_private_field_set(this, _columnMoveSnapshot, this.mergedCellsCollection.capturePhysicalSpans('column'));
+        }), _class_private_field_set(this, _onAfterColumnFreeze, (_column, performed)=>{
+            const snapshot = _class_private_field_get(this, _columnMoveSnapshot);
+            _class_private_field_set(this, _columnMoveSnapshot, null);
+            if (!performed || !snapshot) {
+                return;
+            }
+            this.mergedCellsCollection.translateAfterAxisMove('column', snapshot);
+            this.hot.render();
+        }), _class_private_field_set(this, _onAfterChange, (changes, source)=>{
+            if (source !== 'Autofill.fill') {
+                return;
+            }
+            this.autofillCalculations.recreateAfterDataPopulation(changes);
+        }), _class_private_field_set(this, _onBeforeDrawAreaBorders, (corners, className)=>{
+            if (className && className === 'area') {
+                const selectedRange = this.hot.getSelectedRangeActive();
+                if (!selectedRange) {
+                    return;
+                }
+                const mergedCellsWithinRange = this.mergedCellsCollection.getWithinRange(selectedRange);
+                arrayEach(mergedCellsWithinRange, (mergedCell)=>{
+                    if (selectedRange.getBottomEndCorner().row === mergedCell.getLastRow() && selectedRange.getBottomEndCorner().col === mergedCell.getLastColumn()) {
+                        corners[2] = mergedCell.row;
+                        corners[3] = mergedCell.col;
+                    }
+                });
+            }
+        }), _class_private_field_set(this, _onAfterDrawSelection, (currentRow, currentColumn, cornersOfSelection, layerLevel)=>{
+            // Nothing's selected (hook might be triggered by the custom borders)
+            if (!cornersOfSelection) {
+                return;
+            }
+            return this.selectionCalculations.getSelectedMergedCellClassName(currentRow, currentColumn, cornersOfSelection, layerLevel);
+        }), _class_private_field_set(this, _onBeforeRemoveCellClassNames, ()=>{
+            return this.selectionCalculations.getSelectedMergedCellClassNameToRemove();
+        }), _class_private_field_set(this, _onBeforeBeginEditing, (row, column, initialValue, event)=>{
+            if (!(event instanceof MouseEvent)) {
+                return;
+            }
+            const selection = this.hot.getSelectedRangeActive();
+            if (!selection) {
+                return;
+            }
+            const mergeCell = this.mergedCellsCollection.getByRange(selection);
+            if (!mergeCell) {
+                return;
+            }
+            const from = this.hot._createCellCoords(mergeCell.row, mergeCell.col);
+            const to = this.hot._createCellCoords(mergeCell.row + mergeCell.rowspan - 1, mergeCell.col + mergeCell.colspan - 1);
+            return this.hot.selection.getLayerLevel() === 0 && selection.isEqual(this.hot._createCellRange(from, from, to));
+        }), _class_private_field_set(this, _onModifyRowHeightByOverlayName, (height, row, overlayType)=>{
+            if (this.hot.getSettings().rowHeaders || // merged cells do not work with the bottom overlays
+            overlayType === 'bottom' || overlayType === 'bottom_inline_start_corner') {
+                return height;
+            }
+            let firstColumn;
+            let lastColumn;
+            if (overlayType === 'master') {
+                firstColumn = this.hot.getFirstRenderedVisibleColumn();
+                lastColumn = this.hot.getLastRenderedVisibleColumn();
+            } else {
+                const activeOverlay = this.hot.view.getOverlayByName(overlayType);
+                const overlayWtTable = activeOverlay?.clone?.wtTable;
+                if (!overlayWtTable) {
+                    return height;
+                }
+                firstColumn = this.hot.columnIndexMapper.getVisualFromRenderableIndex(overlayWtTable.getFirstRenderedColumn());
+                lastColumn = this.hot.columnIndexMapper.getVisualFromRenderableIndex(overlayWtTable.getLastRenderedColumn());
+            }
+            if (firstColumn === null || firstColumn === undefined) {
+                return height;
+            }
+            const firstMergedCellInRow = this.mergedCellsCollection.get(row, firstColumn);
+            if (!firstMergedCellInRow) {
+                return height;
+            }
+            const from = this.hot._createCellCoords(row, firstColumn);
+            const to = this.hot._createCellCoords(row, lastColumn ?? firstColumn);
+            const viewportRange = this.hot._createCellRange(from, from, to);
+            const mergedCellsWithinRange = this.mergedCellsCollection.getWithinRange(viewportRange, true);
+            const maxRowspan = mergedCellsWithinRange.reduce((acc, { rowspan })=>Math.max(acc, rowspan), 1);
+            let rowspanCorrection = 0;
+            if (mergedCellsWithinRange.length > 1 && mergedCellsWithinRange[0].rowspan < maxRowspan) {
+                rowspanCorrection = maxRowspan - mergedCellsWithinRange[0].rowspan;
+            }
+            mergedCellsWithinRange.forEach(({ rowspan })=>{
+                let rowspanAfterCorrection = 0;
+                if (overlayType === 'top' || overlayType === 'top_inline_start_corner') {
+                    rowspanAfterCorrection = Math.min(maxRowspan, this.hot.view.countNotHiddenFixedRowsTop() - row);
+                } else {
+                    rowspanAfterCorrection = rowspan - rowspanCorrection;
+                }
+                height = Math.max(height ?? 0, sumCellsHeights(this.hot, row, rowspanAfterCorrection));
+            });
+            return height;
+        });
     }
-    return [
-        topStartRow,
-        topStartColumn,
-        bottomEndRow,
-        bottomEndColumn
-    ];
 }
 function addMergeActionsToContextMenu(defaultOptions) {
     defaultOptions.items.push({
         name: '---------'
     }, toggleMergeItem(this));
 }
-function onBeforeSetRangeStart() {
-    _class_private_field_set(this, _lastSelectedFocus, null);
-}
-function onBeforeSelectionFocusSet() {
-    if (_class_private_field_get(this, _lastSelectedFocus).isCell()) {
-        return;
-    }
-    const selectedRange = this.hot.getSelectedRangeActive();
-    const verticalDir = selectedRange.getVerticalDirection();
-    const horizontalDir = selectedRange.getHorizontalDirection();
-    const focusCoords = _class_private_field_get(this, _lastSelectedFocus).clone().normalize();
-    _class_private_field_get(this, _focusOrder).setActiveNode(focusCoords.row, focusCoords.col);
-    if (_class_private_field_get(this, _lastFocusDelta).row > 0 || _class_private_field_get(this, _lastFocusDelta).col > 0) {
-        _class_private_field_get(this, _focusOrder).setPrevNodeAsActive();
-    } else if (horizontalDir === 'E-W' && _class_private_field_get(this, _lastFocusDelta).col < 0 || verticalDir === 'S-N' && _class_private_field_get(this, _lastFocusDelta).row < 0) {
-        _class_private_field_get(this, _focusOrder).setNextNodeAsActive();
-    }
-}
-function onAfterSelectionFocusSet(row, column) {
-    const { columnIndexMapper, rowIndexMapper } = this.hot;
-    let activeSelectionLayerIndex = this.hot.getActiveSelectionLayerIndex();
-    let notHiddenRowIndex = null;
-    let notHiddenColumnIndex = null;
-    if (_class_private_field_get(this, _lastFocusDelta).col < 0) {
-        const { rowEnd, colEnd, selectionLayer } = _class_private_field_get(this, _focusOrder).getPrevHorizontalNode();
-        notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colEnd, -1);
-        notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowEnd, -1);
-        activeSelectionLayerIndex = selectionLayer;
-    } else if (_class_private_field_get(this, _lastFocusDelta).col > 0) {
-        const { rowStart, colStart, selectionLayer } = _class_private_field_get(this, _focusOrder).getNextHorizontalNode();
-        notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colStart, 1);
-        notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowStart, 1);
-        activeSelectionLayerIndex = selectionLayer;
-    } else if (_class_private_field_get(this, _lastFocusDelta).row < 0) {
-        const { rowEnd, colEnd, selectionLayer } = _class_private_field_get(this, _focusOrder).getPrevVerticalNode();
-        notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colEnd, -1);
-        notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowEnd, -1);
-        activeSelectionLayerIndex = selectionLayer;
-    } else if (_class_private_field_get(this, _lastFocusDelta).row > 0) {
-        const { rowStart, colStart, selectionLayer } = _class_private_field_get(this, _focusOrder).getNextVerticalNode();
-        notHiddenColumnIndex = columnIndexMapper.getNearestNotHiddenIndex(colStart, 1);
-        notHiddenRowIndex = rowIndexMapper.getNearestNotHiddenIndex(rowStart, 1);
-        activeSelectionLayerIndex = selectionLayer;
-    }
-    if (notHiddenRowIndex !== null || notHiddenColumnIndex !== null) {
-        this.hot.selection.setActiveSelectionLayerIndex(activeSelectionLayerIndex);
-        const selectedRange = this.hot.getSelectedRangeActive();
-        const coords = this.hot._createCellCoords(notHiddenRowIndex, notHiddenColumnIndex);
-        const mergeParent = this.mergedCellsCollection.get(coords.row, coords.col);
-        const focusHighlight = this.hot.selection.highlight.getFocus();
-        row = coords.row;
-        column = coords.col;
-        if (mergeParent) {
-            selectedRange.highlight.assign({
-                row: this.hot.rowIndexMapper.getNearestNotHiddenIndex(mergeParent.row, 1),
-                col: this.hot.columnIndexMapper.getNearestNotHiddenIndex(mergeParent.col, 1)
-            });
-        } else {
-            selectedRange.highlight.assign(coords);
-        }
-        focusHighlight.clear();
-        focusHighlight.add(coords).commit();
-    }
-    _class_private_field_get(this, _focusOrder).setActiveNode(row, column, activeSelectionLayerIndex);
-    _class_private_field_set(this, _lastFocusDelta, {
-        row: 0,
-        col: 0
-    });
-}
-function onAfterSelectionEnd() {
-    _class_private_field_get(this, _focusOrder).buildFocusOrder(this.hot.getSelectedRange());
-}
-function onAfterGetCellMeta(row, col, cellProperties) {
-    const mergeParent = this.mergedCellsCollection.get(row, col);
-    if (mergeParent) {
-        if (mergeParent.row !== row || mergeParent.col !== col) {
-            cellProperties.copyable = false;
-        } else {
-            cellProperties.rowspan = mergeParent.rowspan;
-            cellProperties.colspan = mergeParent.colspan;
-        }
-    }
-}
-function onAfterViewportRowCalculatorOverride(calc) {
-    if (this.getSetting('virtualized')) {
-        return;
-    }
-    const nrOfColumns = this.hot.countCols();
-    this.modifyViewportRowStart(calc, nrOfColumns);
-    this.modifyViewportRowEnd(calc, nrOfColumns);
-}
-function onAfterViewportColumnCalculatorOverride(calc) {
-    if (this.getSetting('virtualized')) {
-        return;
-    }
-    const nrOfRows = this.hot.countRows();
-    this.modifyViewportColumnStart(calc, nrOfRows);
-    this.modifyViewportColumnEnd(calc, nrOfRows);
-}
-function onModifyAutofillRange(fullArea, baseArea) {
-    const dragDirection = this.autofillCalculations.getDirection(baseArea, fullArea);
-    if (this.autofillCalculations.dragAreaOverlapsCollections(baseArea, fullArea, dragDirection)) {
-        return baseArea;
-    }
-    const from = this.hot._createCellCoords(baseArea[0], baseArea[1]);
-    const to = this.hot._createCellCoords(baseArea[2], baseArea[3]);
-    const range = this.hot._createCellRange(from, from, to);
-    const mergedCellsWithinSelectionArea = this.mergedCellsCollection.getWithinRange(range);
-    if (mergedCellsWithinSelectionArea.length === 0) {
-        return fullArea;
-    }
-    return this.autofillCalculations.snapDragArea(baseArea, fullArea, dragDirection, mergedCellsWithinSelectionArea);
-}
-function onAfterCreateCol(column, count) {
-    this.mergedCellsCollection.shiftCollections('right', column, count);
-}
-function onAfterRemoveCol(column, count) {
-    this.mergedCellsCollection.shiftCollections('left', column, count);
-}
-function onAfterCreateRow(row, count, source) {
-    if (source === 'auto') {
-        return;
-    }
-    this.mergedCellsCollection.shiftCollections('down', row, count);
-}
-function onAfterRemoveRow(row, count) {
-    this.mergedCellsCollection.shiftCollections('up', row, count);
-}
-function onAfterChange(changes, source) {
-    if (source !== 'Autofill.fill') {
-        return;
-    }
-    this.autofillCalculations.recreateAfterDataPopulation(changes);
-}
-function onBeforeDrawAreaBorders(corners, className) {
-    if (className && className === 'area') {
-        const selectedRange = this.hot.getSelectedRangeActive();
-        const mergedCellsWithinRange = this.mergedCellsCollection.getWithinRange(selectedRange);
-        arrayEach(mergedCellsWithinRange, (mergedCell)=>{
-            if (selectedRange.getBottomEndCorner().row === mergedCell.getLastRow() && selectedRange.getBottomEndCorner().col === mergedCell.getLastColumn()) {
-                corners[2] = mergedCell.row;
-                corners[3] = mergedCell.col;
-            }
-        });
-    }
-}
-function onAfterDrawSelection(currentRow, currentColumn, cornersOfSelection, layerLevel) {
-    // Nothing's selected (hook might be triggered by the custom borders)
-    if (!cornersOfSelection) {
-        return;
-    }
-    return this.selectionCalculations.getSelectedMergedCellClassName(currentRow, currentColumn, cornersOfSelection, layerLevel);
-}
-function onBeforeRemoveCellClassNames() {
-    return this.selectionCalculations.getSelectedMergedCellClassNameToRemove();
-}
-function onBeforeBeginEditing(row, column, initialValue, event) {
-    if (!(event instanceof MouseEvent)) {
-        return;
-    }
-    const selection = this.hot.getSelectedRangeActive();
-    const mergeCell = this.mergedCellsCollection.getByRange(selection);
-    if (!mergeCell) {
-        return;
-    }
-    const from = this.hot._createCellCoords(mergeCell.row, mergeCell.col);
-    const to = this.hot._createCellCoords(mergeCell.row + mergeCell.rowspan - 1, mergeCell.col + mergeCell.colspan - 1);
-    return this.hot.selection.getLayerLevel() === 0 && selection.isEqual(this.hot._createCellRange(from, from, to));
-}
-function onModifyRowHeightByOverlayName(height, row, overlayType) {
-    if (this.hot.getSettings().rowHeaders || // merged cells do not work with the bottom overlays
-    overlayType === 'bottom' || overlayType === 'bottom_inline_start_corner') {
-        return height;
-    }
-    let firstColumn;
-    let lastColumn;
-    if (overlayType === 'master') {
-        firstColumn = this.hot.getFirstRenderedVisibleColumn();
-        lastColumn = this.hot.getLastRenderedVisibleColumn();
-    } else {
-        const activeOverlay = this.hot.view.getOverlayByName(overlayType);
-        firstColumn = this.hot.columnIndexMapper.getVisualFromRenderableIndex(activeOverlay.clone.wtTable.getFirstRenderedColumn());
-        lastColumn = this.hot.columnIndexMapper.getVisualFromRenderableIndex(activeOverlay.clone.wtTable.getLastRenderedColumn());
-    }
-    const firstMergedCellInRow = this.mergedCellsCollection.get(row, firstColumn);
-    if (!firstMergedCellInRow) {
-        return height;
-    }
-    const from = this.hot._createCellCoords(row, firstColumn);
-    const to = this.hot._createCellCoords(row, lastColumn);
-    const viewportRange = this.hot._createCellRange(from, from, to);
-    const mergedCellsWithinRange = this.mergedCellsCollection.getWithinRange(viewportRange, true);
-    const maxRowspan = mergedCellsWithinRange.reduce((acc, { rowspan })=>Math.max(acc, rowspan), 1);
-    let rowspanCorrection = 0;
-    if (mergedCellsWithinRange.length > 1 && mergedCellsWithinRange[0].rowspan < maxRowspan) {
-        rowspanCorrection = maxRowspan - mergedCellsWithinRange[0].rowspan;
-    }
-    mergedCellsWithinRange.forEach(({ rowspan })=>{
-        let rowspanAfterCorrection = 0;
-        if (overlayType === 'top' || overlayType === 'top_inline_start_corner') {
-            rowspanAfterCorrection = Math.min(maxRowspan, this.hot.view.countNotHiddenFixedRowsTop() - row);
-        } else {
-            rowspanAfterCorrection = rowspan - rowspanCorrection;
-        }
-        height = Math.max(height ?? 0, sumCellsHeights(this.hot, row, rowspanAfterCorrection));
-    });
-    return height;
-}