handsontable 0.0.0-next-ff10728-20250410 → 0.0.0-next-d9b3885-20250415

package/dist/handsontable.full.js

@@ -25,8 +25,8 @@
  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING FROM
  * USE OR INABILITY TO USE THIS SOFTWARE.
  *
- * Version: 0.0.0-next-ff10728-20250410
- * Release date: 20/02/2025 (built at 10/04/2025 06:43:56)
+ * Version: 0.0.0-next-d9b3885-20250415
+ * Release date: 19/03/2025 (built at 15/04/2025 10:06:49)
  */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
@@ -42681,7 +42681,7 @@ exports.CellRange = _base.CellRange;
 var _registry = __webpack_require__(764);
 var _eventManager = _interopRequireWildcard(__webpack_require__(522));
 var _translations = __webpack_require__(625);
-var _jquery = _interopRequireDefault(__webpack_require__(1099));
+var _jquery = _interopRequireDefault(__webpack_require__(1100));
 var _ghostTable = _interopRequireDefault(__webpack_require__(843));
 var parseTableHelpers = _interopRequireWildcard(__webpack_require__(524));
 var arrayHelpers = _interopRequireWildcard(__webpack_require__(495));
@@ -42855,8 +42855,8 @@ Handsontable.hooks = _hooks.Hooks.getSingleton();
 Handsontable.CellCoords = _src.CellCoords;
 Handsontable.CellRange = _src.CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "10/04/2025 06:43:56";
-Handsontable.version = "0.0.0-next-ff10728-20250410";
+Handsontable.buildDate = "15/04/2025 10:06:49";
+Handsontable.version = "0.0.0-next-d9b3885-20250415";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,
@@ -42963,6 +42963,12 @@ const deprecationWarns = new Set();
  * by using React's `ref` feature (read more on the [Instance methods](@/guides/getting-started/react-methods/react-methods.md) page).
  * :::
  *
+ * ::: only-for angular
+ * To use these methods, associate a Handsontable instance with your instance
+ * of the [`HotTable` component](@/guides/getting-started/installation/installation.md#5-use-the-hottable-component),
+ * by using `@ViewChild` decorator (read more on the [Instance access](@/guides/getting-started/angular-hot-instance/angular-hot-instance.md) page).
+ * :::
+ *
  * ## How to call a method
  *
  * ::: only-for javascript
@@ -42993,6 +42999,39 @@ const deprecationWarns = new Set();
  * ```
  * :::
  *
+ * ::: only-for angular
+ * ```ts
+ * import { Component, ViewChild, AfterViewInit } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableComponent,
+ *   HotTableModule,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     columns: [{}],
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access the Handsontable instance
+ *     // Call a method
+ *     this.hotTable?.hotInstance?.setDataAtCell(0, 0, "new value");
+ *   }
+ * }
+ * ```
+ * :::
+ *
  * @param {HTMLElement} rootElement The element to which the Handsontable instance is injected.
  * @param {object} userSettings The user defined options.
  * @param {boolean} [rootInstanceSymbol=false] Indicates if the instance is root of all later instances created.
@@ -43110,7 +43149,6 @@ function Core(rootElement, userSettings) {
   const globalMeta = metaManager.getGlobalMeta();
   const pluginsRegistry = (0, _uniqueMap.createUniqueMap)();
   this.container = this.rootDocument.createElement('div');
-  this.renderCall = false;
   rootElement.insertBefore(this.container, rootElement.firstChild);
   if ((0, _rootInstance.isRootInstance)(this)) {
     (0, _mixed._injectProductInfo)(userSettings.licenseKey, rootElement);
@@ -43142,6 +43180,9 @@ function Core(rootElement, userSettings) {
   this.rowIndexMapper.addLocalHook('indexesSequenceChange', source => {
     instance.runHooks('afterRowSequenceChange', source);
   });
+  eventManager.addEventListener(this.rootDocument.documentElement, 'compositionstart', event => {
+    instance.runHooks('beforeCompositionStart', event);
+  });
   dataSource = new _dataSource.default(instance);
   if (!this.rootElement.id || this.rootElement.id.substring(0, 3) === 'ht_') {
     this.rootElement.id = this.guid; // if root element does not have an id, assign a random id
@@ -43221,6 +43262,7 @@ function Core(rootElement, userSettings) {
     let {
       hiddenIndexesChanged
     } = _ref;
+    this.forceFullRender = true;
     if (hiddenIndexesChanged) {
       this.selection.commit();
     }
@@ -43504,13 +43546,6 @@ function Core(rootElement, userSettings) {
                 }
               }
               const totalRows = instance.countRows();
-              if (totalRows === 0) {
-                selection.deselect();
-              } else if (source === 'ContextMenu.removeRow') {
-                selection.refresh();
-              } else {
-                selection.shiftRows(groupIndex, -groupAmount);
-              }
               const fixedRowsTop = tableMeta.fixedRowsTop;
               if (fixedRowsTop >= calcIndex + 1) {
                 tableMeta.fixedRowsTop -= Math.min(groupAmount, fixedRowsTop - calcIndex);
@@ -43519,6 +43554,13 @@ function Core(rootElement, userSettings) {
               if (fixedRowsBottom && calcIndex >= totalRows - fixedRowsBottom) {
                 tableMeta.fixedRowsBottom -= Math.min(groupAmount, fixedRowsBottom);
               }
+              if (totalRows === 0) {
+                selection.deselect();
+              } else if (source === 'ContextMenu.removeRow') {
+                selection.refresh();
+              } else {
+                selection.shiftRows(groupIndex, -groupAmount);
+              }
               offset += groupAmount;
             });
           };
@@ -43928,8 +43970,7 @@ function Core(rootElement, userSettings) {
       (0, _index.installFocusCatcher)(instance);
     }
     instance.runHooks('init');
-    this.forceFullRender = true; // used when data was changed
-    this.view.render();
+    this.render();
 
     // Run the logic only if it's the table's initialization and the root element is not visible.
     if (!!firstRun && instance.rootElement.offsetParent === null) {
@@ -44102,13 +44143,11 @@ function Core(rootElement, userSettings) {
       datamap.set(changes[i][0], changes[i][1], changes[i][3]);
     }
     const hasChanges = changes.length > 0;
-    instance.forceFullRender = true; // used when data was changed or when all cells need to be re-rendered
-
     if (hasChanges) {
       grid.adjustRowsAndCols();
       instance.runHooks('beforeChangeRender', changes, source);
       editorManager.closeEditor();
-      instance.view.render();
+      instance.render();
       editorManager.prepareEditor();
       instance.view.adjustElementsSize();
       instance.runHooks('afterChange', changes, source || 'edit');
@@ -44117,7 +44156,7 @@ function Core(rootElement, userSettings) {
         activeEditor.refreshValue();
       }
     } else {
-      instance.view.render();
+      instance.render();
     }
   }
 
@@ -44267,9 +44306,22 @@ function Core(rootElement, userSettings) {
           ...tableMeta
         };
       }
-      if (cellProperties.type === 'numeric' && typeof newValue === 'string' && (0, _number.isNumericLike)(newValue)) {
+      const {
+        type,
+        checkedTemplate,
+        uncheckedTemplate
+      } = cellProperties;
+      if (type === 'numeric' && typeof newValue === 'string' && (0, _number.isNumericLike)(newValue)) {
         filteredChanges[i][3] = getParsedNumber(newValue);
       }
+      if (type === 'checkbox') {
+        const stringifiedValue = (0, _mixed.stringify)(newValue);
+        const isChecked = stringifiedValue === (0, _mixed.stringify)(checkedTemplate);
+        const isUnchecked = stringifiedValue === (0, _mixed.stringify)(uncheckedTemplate);
+        if (isChecked || isUnchecked) {
+          filteredChanges[i][3] = isChecked ? checkedTemplate : uncheckedTemplate;
+        }
+      }
     }
     return filteredChanges;
   }
@@ -44671,11 +44723,7 @@ function Core(rootElement, userSettings) {
     const nextValue = this.renderSuspendedCounter - 1;
     this.renderSuspendedCounter = Math.max(nextValue, 0);
     if (!this.isRenderSuspended() && nextValue === this.renderSuspendedCounter) {
-      if (this.renderCall) {
-        this.render();
-      } else {
-        instance.view.render();
-      }
+      instance.view.render();
     }
   };
 
@@ -44691,9 +44739,8 @@ function Core(rootElement, userSettings) {
    */
   this.render = function () {
     if (this.view) {
-      this.renderCall = true;
-      this.forceFullRender = true; // used when data was changed or when all cells need to be re-rendered
-
+      // used when data was changed or when all cells need to be re-rendered (slow render)
+      this.forceFullRender = true;
       if (!this.isRenderSuspended()) {
         instance.view.render();
       }
@@ -45306,8 +45353,7 @@ function Core(rootElement, userSettings) {
     }
     grid.adjustRowsAndCols();
     if (instance.view && !firstRun) {
-      instance.forceFullRender = true; // used when data was changed
-      instance.view.render();
+      instance.render();
       instance.view._wt.wtOverlays.adjustElementsSize();
     }
     if (!init && instance.view && (currentHeight === '' || height === '' || height === undefined) && currentHeight !== height) {
@@ -51419,8 +51465,8 @@ exports.isChildOf = isChildOf;
 exports.isDetached = isDetached;
 exports.isHTMLElement = isHTMLElement;
 exports.isInput = isInput;
+exports.isInternalElement = isInternalElement;
 exports.isOutsideInput = isOutsideInput;
-exports.isThisHotChild = isThisHotChild;
 exports.isVisible = isVisible;
 exports.makeElementContentEditableAndSelectItsContent = makeElementContentEditableAndSelectItsContent;
 exports.matchesCSSRules = matchesCSSRules;
@@ -51481,7 +51527,7 @@ function getParent(element) {
  * @param {HTMLElement} thisHotContainer The Handsontable container.
  * @returns {boolean}
  */
-function isThisHotChild(element, thisHotContainer) {
+function isInternalElement(element, thisHotContainer) {
   const closestHandsontableContainer = element.closest('.handsontable');
   return !!closestHandsontableContainer && (closestHandsontableContainer.parentNode === thisHotContainer || closestHandsontableContainer === thisHotContainer);
 }
@@ -54188,7 +54234,7 @@ const domMessages = {
 function _injectProductInfo(key, element) {
   const hasValidType = !isEmpty(key);
   const isNonCommercial = typeof key === 'string' && key.toLowerCase() === 'non-commercial-and-evaluation';
-  const hotVersion = "0.0.0-next-ff10728-20250410";
+  const hotVersion = "0.0.0-next-d9b3885-20250415";
   let keyValidityDate;
   let consoleMessageState = 'invalid';
   let domMessageState = 'invalid';
@@ -54196,7 +54242,7 @@ function _injectProductInfo(key, element) {
   const schemaValidity = _checkKeySchema(key);
   if (hasValidType || isNonCommercial || schemaValidity) {
     if (schemaValidity) {
-      const releaseDate = (0, _moment.default)("20/02/2025", 'DD/MM/YYYY');
+      const releaseDate = (0, _moment.default)("19/03/2025", 'DD/MM/YYYY');
       const releaseDays = Math.floor(releaseDate.toDate().getTime() / 8.64e7);
       const keyValidityDays = _extractTime(key);
       keyValidityDate = (0, _moment.default)((keyValidityDays + 1) * 8.64e7, 'x').format('MMMM DD, YYYY');
@@ -61903,7 +61949,7 @@ const platforms = {
   mac: tester(platform => /^Mac/.test(platform)),
   win: tester(platform => /^Win/.test(platform)),
   linux: tester(platform => /^Linux/.test(platform)),
-  ios: tester(ua => /iPhone|iPad|iPod/i.test(ua))
+  ios: tester(platform => /iPhone|iPad|iPod/i.test(platform))
 };
 
 /**
@@ -62331,6 +62377,9 @@ function getProperty(object, name) {
  * @param {*} value Value to be assigned at the provided property.
  */
 function setProperty(object, name, value) {
+  if (typeof name !== 'string') {
+    return;
+  }
   const names = name.split('.');
   let workingObject = object;
   names.forEach((propName, index) => {
@@ -62697,13 +62746,7 @@ class EditorManager {
     this.selection = _selection;
     this.eventManager = new _eventManager.default(hotInstance);
     this.hot.addHook('afterDocumentKeyDown', event => _assertClassBrand(_EditorManager_brand, this, _onAfterDocumentKeyDown).call(this, event));
-
-    // Open editor when text composition is started (IME editor)
-    this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'compositionstart', event => {
-      if (!this.destroyed && this.hot.isListening()) {
-        this.openEditor('', event);
-      }
-    });
+    this.hot.addHook('beforeCompositionStart', event => _assertClassBrand(_EditorManager_brand, this, _onAfterDocumentKeyDown).call(this, event));
     this.hot.view._wt.update('onCellDblClick', (event, coords, elem) => _assertClassBrand(_EditorManager_brand, this, _onCellDblClick).call(this, event, coords, elem));
   }
 
@@ -63892,6 +63935,22 @@ exports.__esModule = true;
  * />
  * :::
  *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   afterChange: (changes, source) => {
+ *     changes?.forEach(([row, prop, oldValue, newValue]) => {
+ *       // Some logic...
+ *     });
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings" />
+ * ```
+ * :::
+ *
  * ::: only-for javascript
  * ```js
  * // using events as plugin hooks
@@ -63996,6 +64055,22 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   afterChange: (changes, source) => {
+ *     changes?.forEach(([row, prop, oldValue, newValue]) => {
+ *       // Some logic...
+ *     });
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 'afterChange',
 /**
@@ -64099,6 +64174,21 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   beforeCreateCol: (data, coords) => {
+ *     // Return `false` to cancel column inserting.
+ *     return false;
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 'beforeCreateCol',
 /**
@@ -64179,6 +64269,14 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * @returns {string[]|undefined} Can return an `Array` of `String`s. Each of these strings will act like class names to be removed from all the cells in the table.
  */
 'beforeRemoveCellClassNames',
+/**
+ * Hook fired after `compositionstart` event is handled.
+ *
+ * @event Hooks#beforeCompositionStart
+ * @since 15.3.0
+ * @param {Event} event A native `composition` event object.
+ */
+'beforeCompositionStart',
 /**
  * Fired after getting the cell settings.
  *
@@ -64474,6 +64572,31 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  *   }}
  * />
  * ```
+ * :::
+ *
+ * ::: only-for angular
+ * ```ts
+* settings = {
+*   afterSelection: (
+*     row,
+*     column,
+*     row2,
+*     column2,
+*     preventScrolling,
+*     selectionLayerLevel
+*   ) => {
+*     // If set to `false` (default): when cell selection is outside the viewport,
+*     // Handsontable scrolls the viewport to cell selection's end corner.
+*     // If set to `true`: when cell selection is outside the viewport,
+*     // Handsontable doesn't scroll to cell selection's end corner.
+*     preventScrolling.value = true;
+*   },
+* };
+* ```
+*
+* ```html
+* <hot-table [settings]="settings"></hot-table>
+* ```
  * :::
  */
 'afterSelection',
@@ -64513,6 +64636,28 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   afterSelectionByProp: (
+ *     row,
+ *     column,
+ *     row2,
+ *     column2,
+ *     preventScrolling,
+ *     selectionLayerLevel
+ *   ) => {
+ *     // Setting if prevent scrolling after selection
+ *     preventScrolling.value = true;
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 'afterSelectionByProp',
 /**
@@ -64577,6 +64722,24 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   afterSelectionFocusSet: (row, column, preventScrolling) => {
+ *     // If set to `false` (default): when focused cell selection is outside the viewport,
+ *     // Handsontable scrolls the viewport to that cell.
+ *     // If set to `true`: when focused cell selection is outside the viewport,
+ *     // Handsontable doesn't scroll the viewport.
+ *     preventScrolling.value = true;
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 'afterSelectionFocusSet',
 /**
@@ -64611,6 +64774,22 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   beforeSelectColumns: (from, to, highlight) => {
+ *     // Extend the column selection by one column left and one column right.
+ *     from.col = Math.max(from.col - 1, 0);
+ *     to.col = Math.min(to.col + 1, this.countCols() - 1);
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 'beforeSelectColumns',
 /**
@@ -64655,6 +64834,22 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   beforeSelectRows: (from, to, highlight) => {
+ *     // Extend the row selection by one row up and one row down.
+ *     from.row = Math.max(from.row - 1, 0);
+ *     to.row = Math.min(to.row + 1, this.countRows() - 1);
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 'beforeSelectRows',
 /**
@@ -64875,6 +65070,42 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ * ::: only-for angular
+ *```ts
+ * // To alter a single change, overwrite the desired value with `changes[i][3]`
+ * settings1 = {
+ *   beforeChange: (changes, source) => {
+ *     // [[row, prop, oldVal, newVal], ...]
+ *     changes[0][3] = 10;
+ *   },
+ * };
+ *
+ * // To ignore a single change, set `changes[i]` to `null`
+ * // or remove `changes[i]` from the array, by using changes.splice(i, 1).
+ * settings2 = {
+ *   beforeChange: (changes, source) => {
+ *     // [[row, prop, oldVal, newVal], ...]
+ *     changes[0] = null;
+ *   },
+ * };
+ *
+ * // To ignore all changes, return `false`
+ * // or set the array's length to 0 (`changes.length = 0`)
+ * settings3 = {
+ *   beforeChange: (changes, source) => {
+ *     // [[row, prop, oldVal, newVal], ...]
+ *     return false;
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings1"></hot-table>
+ * <hot-table [settings]="settings2"></hot-table>
+ * <hot-table [settings]="settings3"></hot-table>
+ * ```
+ *
+ * :::
  */
 'beforeChange',
 /**
@@ -65485,6 +65716,32 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ *```ts
+ * // To disregard a single row, remove it from the array using data.splice(i, 1).
+ * settings1 = {
+ *   beforeCut: (data, coords) => {
+ *     // data -> [[1, 2, 3], [4, 5, 6]]
+ *     data.splice(0, 1);
+ *     // data -> [[4, 5, 6]]
+ *     // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}]
+ *   },
+ * };
+ *
+ * // To cancel a cutting action, just return `false`.
+ * settings2 = {
+ *   beforeCut: (data, coords) => {
+ *     return false;
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings1"></hot-table>
+ * <hot-table [settings]="settings2"></hot-table>
+ * ```
+ * :::
  */
 'beforeCut',
 /**
@@ -65557,6 +65814,32 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * ...
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * // To disregard a single row, remove it from the array using data.splice(i, 1).
+ * settings1 = {
+ *   beforeCopy: (data, coords) => {
+ *     // data -> [[1, 2, 3], [4, 5, 6]]
+ *     data.splice(0, 1);
+ *     // data -> [[4, 5, 6]]
+ *     // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}]
+ *   },
+ * };
+ *
+ * // To cancel copying, return false from the callback.
+ * settings2 = {
+ *   beforeCopy: (data, coords) => {
+ *     return false;
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings1"></hot-table>
+ * <hot-table [settings]="settings2"></hot-table>
+ * ```
+ * :::
  */
 'beforeCopy',
 /**
@@ -65619,6 +65902,32 @@ const REGISTERED_HOOKS = exports.REGISTERED_HOOKS = [/* eslint-disable jsdoc/req
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * // To disregard a single row, remove it from the array using data.splice(i, 1).
+ * settings1 = {
+ *   beforePaste: (data, coords) => {
+ *     // data -> [[1, 2, 3], [4, 5, 6]]
+ *     data.splice(0, 1);
+ *     // data -> [[4, 5, 6]]
+ *     // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}]
+ *   },
+ * };
+ *
+ * // To cancel pasting, return false from the callback.
+ * settings2 = {
+ *   beforePaste: (data, coords) => {
+ *     return false;
+ *   },
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings1"></hot-table>
+ * <hot-table [settings]="settings2"></hot-table>
+ * ```
+ * :::
  */
 'beforePaste',
 /**
@@ -68795,16 +69104,16 @@ class TableView {
    */
   render() {
     if (!this.hot.isRenderSuspended()) {
-      this.hot.runHooks('beforeRender', this.hot.forceFullRender);
+      const isFullRender = this.hot.forceFullRender;
+      this.hot.runHooks('beforeRender', isFullRender);
       if (this.postponedAdjustElementsSize) {
         this.postponedAdjustElementsSize = false;
         this.adjustElementsSize();
       }
-      this._wt.draw(!this.hot.forceFullRender);
+      this._wt.draw(!isFullRender);
       _assertClassBrand(_TableView_brand, this, _updateScrollbarClassNames).call(this);
-      this.hot.runHooks('afterRender', this.hot.forceFullRender);
+      this.hot.runHooks('afterRender', isFullRender);
       this.hot.forceFullRender = false;
-      this.hot.renderCall = false;
     }
   }
 
@@ -69711,8 +70020,7 @@ class TableView {
     this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'click', () => {
       if (this.settings.observeDOMVisibility) {
         if (this._wt.drawInterrupted) {
-          this.hot.forceFullRender = true;
-          this.render();
+          this.hot.render();
         }
       }
     });
@@ -69785,7 +70093,6 @@ class TableView {
    */
   beforeRender(force, skipRender) {
     if (force) {
-      // this.hot.forceFullRender = did Handsontable request full render?
       this.hot.runHooks('beforeViewRender', this.hot.forceFullRender, skipRender);
     }
   }
@@ -69799,7 +70106,6 @@ class TableView {
    */
   afterRender(force) {
     if (force) {
-      // this.hot.forceFullRender = did Handsontable request full render?
       this.hot.runHooks('afterViewRender', this.hot.forceFullRender);
     }
   }
@@ -71905,6 +72211,20 @@ class CellRange {
     return this;
   }
 
+  /**
+   * Normalizes the coordinates in your `CellRange` instance to the nearest valid position.
+   *
+   * Coordinates that point to headers (negative values) are normalized to `0`.
+   *
+   * @returns {CellRange}
+   */
+  normalize() {
+    this.highlight.normalize();
+    this.from.normalize();
+    this.to.normalize();
+    return this;
+  }
+
   /**
    * Checks if the coordinates in your `CellRange` instance are valid
    * in the context of given table parameters.
@@ -74526,8 +74846,8 @@ class Table {
       } else {
         this.tableOffset = this.dataAccessObject.parentTableOffset;
       }
-      const startRow = totalRows > 0 ? this.getFirstRenderedRow() : 0;
-      const startColumn = totalColumns > 0 ? this.getFirstRenderedColumn() : 0;
+      const startRow = Math.max(this.getFirstRenderedRow(), 0);
+      const startColumn = Math.max(this.getFirstRenderedColumn(), 0);
       this.rowFilter = new _row.default(startRow, totalRows, columnHeadersCount);
       this.columnFilter = new _column.default(startColumn, totalColumns, rowHeadersCount);
       let performRedraw = true;
@@ -74845,6 +75165,9 @@ class Table {
       return null;
     }
     const TR = cellElement.parentNode;
+    if (!TR) {
+      return null;
+    }
     const CONTAINER = TR.parentNode;
     let row = (0, _element.index)(TR);
     let col = cellElement.cellIndex;
@@ -75664,7 +75987,10 @@ class RowHeadersRenderer extends _base.BaseRenderer {
       const orderView = this.obtainOrderView(TR);
       const cellsView = cells.obtainOrderView(TR);
       orderView.appendView(cellsView).setSize(rowHeadersCount).setOffset(0).start();
-      for (let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) {
+
+      // Reading the row header renderers in reverse because of how the Eco Renderers handle rendering
+      // (prepending the nodes when rendering row headers).
+      for (let visibleColumnIndex = rowHeadersCount - 1; visibleColumnIndex >= 0; visibleColumnIndex--) {
         orderView.render();
         const TH = orderView.getCurrentNode();
         TH.className = '';
@@ -77529,16 +77855,11 @@ const stickyRowsBottom = {
    * @this Table
    */
   getFirstRenderedRow() {
-    const totalRows = this.wtSettings.getSetting('totalRows');
-    const fixedRowsBottom = this.wtSettings.getSetting('fixedRowsBottom');
-    const index = totalRows - fixedRowsBottom;
-    if (totalRows === 0 || fixedRowsBottom === 0) {
+    const allStickyRows = this.getRenderedRowsCount();
+    if (allStickyRows === 0) {
       return -1;
     }
-    if (index < 0) {
-      return 0;
-    }
-    return index;
+    return this.wtSettings.getSetting('totalRows') - allStickyRows;
   },
   /**
    * Get the source index of the first row fully visible in the viewport. If no rows are fully visible, returns an error code: -1.
@@ -77567,6 +77888,10 @@ const stickyRowsBottom = {
    * @this Table
    */
   getLastRenderedRow() {
+    const allStickyRows = this.getRenderedRowsCount();
+    if (allStickyRows === 0) {
+      return -1;
+    }
     return this.wtSettings.getSetting('totalRows') - 1;
   },
   /**
@@ -77596,8 +77921,7 @@ const stickyRowsBottom = {
    * @this Table
    */
   getRenderedRowsCount() {
-    const totalRows = this.wtSettings.getSetting('totalRows');
-    return Math.min(this.wtSettings.getSetting('fixedRowsBottom'), totalRows);
+    return Math.min(this.wtSettings.getSetting('totalRows'), this.wtSettings.getSetting('fixedRowsBottom'));
   },
   /**
    * Get the number of fully visible rows in the viewport.
@@ -77652,8 +77976,8 @@ const stickyColumnsStart = {
    * @this Table
    */
   getFirstRenderedColumn() {
-    const totalColumns = this.wtSettings.getSetting('totalColumns');
-    if (totalColumns === 0) {
+    const allStickyColumns = this.getRenderedColumnsCount();
+    if (allStickyColumns === 0) {
       return -1;
     }
     return 0;
@@ -77714,8 +78038,7 @@ const stickyColumnsStart = {
    * @this Table
    */
   getRenderedColumnsCount() {
-    const totalColumns = this.wtSettings.getSetting('totalColumns');
-    return Math.min(this.wtSettings.getSetting('fixedColumnsStart'), totalColumns);
+    return Math.min(this.wtSettings.getSetting('totalColumns'), this.wtSettings.getSetting('fixedColumnsStart'));
   },
   /**
    * Get the number of fully visible columns in the viewport.
@@ -81169,6 +81492,11 @@ class Border {
     const lastRenderedRow = wtTable.getLastRenderedRow();
     const firstRenderedColumn = wtTable.getFirstRenderedColumn();
     const lastRenderedColumn = wtTable.getLastRenderedColumn();
+    if (firstRenderedColumn < 0 && lastRenderedColumn < 0 || firstRenderedRow < 0 && lastRenderedRow < 0) {
+      // ...also when overlays have rendered only headers skip it
+      this.disappear();
+      return;
+    }
     let fromTD;
     if (isMultiple) {
       fromColumn = Math.max(fromColumn, firstRenderedColumn);
@@ -81663,8 +81991,8 @@ const stickyRowsTop = {
    * @this Table
    */
   getFirstRenderedRow() {
-    const totalRows = this.wtSettings.getSetting('totalRows');
-    if (totalRows === 0) {
+    const allStickyRows = this.getRenderedRowsCount();
+    if (allStickyRows === 0) {
       return -1;
     }
     return 0;
@@ -81725,8 +82053,7 @@ const stickyRowsTop = {
    * @this Table
    */
   getRenderedRowsCount() {
-    const totalRows = this.wtSettings.getSetting('totalRows');
-    return Math.min(this.wtSettings.getSetting('fixedRowsTop'), totalRows);
+    return Math.min(this.wtSettings.getSetting('totalRows'), this.wtSettings.getSetting('fixedRowsTop'));
   },
   /**
    * Get the number of fully visible rows in the viewport.
@@ -87974,7 +88301,9 @@ class Selection {
       col: (0, _number.clamp)(to.col, 0, countColumns - 1)
     });
     this.selectedRange.ranges.push(range);
-    this.highlight.getFocus().add(highlight).commit().syncWith(range);
+    if (this.highlight.isEnabledFor(_highlight.FOCUS_TYPE, this.selectedRange.current().highlight)) {
+      this.highlight.getFocus().add(highlight).commit().syncWith(range);
+    }
     this.applyAndCommit(range);
   }
 
@@ -90127,8 +90456,6 @@ class DataMap {
       }
     }
     this.hot.runHooks('afterCreateRow', newVisualRowIndex, numberOfCreatedRows, source);
-    this.hot.forceFullRender = true; // used when data was changed
-
     return {
       delta: numberOfCreatedRows,
       startPhysicalIndex: physicalRowIndex
@@ -90214,8 +90541,6 @@ class DataMap {
     }
     const newVisualColumnIndex = this.hot.toVisualColumn(startPhysicalIndex);
     this.hot.runHooks('afterCreateCol', newVisualColumnIndex, numberOfCreatedCols, source);
-    this.hot.forceFullRender = true; // used when data was changed
-
     this.refreshDuckSchema();
     return {
       delta: numberOfCreatedCols,
@@ -90262,8 +90587,6 @@ class DataMap {
       this.metaManager.removeRow(rowPhysicalIndex, 1);
     });
     this.hot.runHooks('afterRemoveRow', rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes, source);
-    this.hot.forceFullRender = true; // used when data was changed
-
     return true;
   }
 
@@ -90323,7 +90646,6 @@ class DataMap {
       }
     }
     this.hot.runHooks('afterRemoveCol', columnIndex, amount, removedPhysicalIndexes, source);
-    this.hot.forceFullRender = true; // used when data was changed
     this.refreshDuckSchema();
     return true;
   }
@@ -91546,6 +91868,33 @@ var _object = __webpack_require__(499);
  * ```
  * :::
  *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: [
+ *     ["A1", "B1", "C1", "D1", "E1"],
+ *     ["A2", "B2", "C2", "D2", "E2"],
+ *     ["A3", "B3", "C3", "D3", "E3"],
+ *     ["A4", "B4", "C4", "D4", "E4"],
+ *     ["A5", "B5", "C5", "D5", "E5"],
+ *   ],
+ *   width: 400,
+ *   height: 300,
+ *   colHeaders: true,
+ *   rowHeaders: true,
+ *   customBorders: true,
+ *   dropdownMenu: true,
+ *   multiColumnSorting: true,
+ *   filters: true,
+ *   manualRowMove: true,
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings" />
+ * ```
+ * :::
+ *
  * Depending on your needs, you can apply [configuration options](@/api/options.md) to different elements of your grid:
  * - [The entire grid](@/guides/getting-started/configuration-options/configuration-options.md#set-grid-options)
  * - [Individual columns](@/guides/getting-started/configuration-options/configuration-options.md#set-column-options)
@@ -94112,6 +94461,7 @@ var _default = () => {
      * | `'de-CH'`           | German - Switzerland        |
      * | `'de-DE'`           | German - Germany            |
      * | `'es-MX'`           | Spanish - Mexico            |
+     * | `'fa-IR'`           | Persian - Iran              |
      * | `'fr-FR'`           | French - France             |
      * | `'hr-HR'`           | Croatian - Croatia          |
      * | `'it-IT'`           | Italian - Italy             |
@@ -99943,7 +100293,7 @@ function createInputElement(hot) {
   input.name = '__htFocusCatcher';
   input.classList.add('htFocusCatcher');
   if (hot.getSettings().ariaTags) {
-    (0, _element.setAttribute)(input, [(0, _a11y.A11Y_PRESENTATION)(), (0, _a11y.A11Y_HIDDEN)()]);
+    (0, _element.setAttribute)(input, [(0, _a11y.A11Y_LABEL)('Focus catcher')]);
   }
   return input;
 }
@@ -101185,7 +101535,7 @@ class TextEditor extends _baseEditor.BaseEditor {
    */
   close() {
     this.autoResize.unObserve();
-    if ((0, _element.isThisHotChild)(this.hot.rootDocument.activeElement, this.hot.rootElement)) {
+    if ((0, _element.isInternalElement)(this.hot.rootDocument.activeElement, this.hot.rootElement)) {
       this.hot.listen(); // don't refocus the table if user focused some cell outside of HT on purpose
     }
     this.hideEditableElement();
@@ -102028,6 +102378,7 @@ var _string = __webpack_require__(352);
 var _unicode = __webpack_require__(508);
 var _textRenderer = __webpack_require__(760);
 var _a11y = __webpack_require__(496);
+var _function = __webpack_require__(497);
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -102040,6 +102391,7 @@ const EDITOR_TYPE = exports.EDITOR_TYPE = 'autocomplete';
  * @class AutocompleteEditor
  */
 var _idPrefix = /*#__PURE__*/new WeakMap();
+var _focusDebounced = /*#__PURE__*/new WeakMap();
 var _AutocompleteEditor_brand = /*#__PURE__*/new WeakSet();
 class AutocompleteEditor extends _handsontableEditor.HandsontableEditor {
   constructor() {
@@ -102072,6 +102424,12 @@ class AutocompleteEditor extends _handsontableEditor.HandsontableEditor {
      * @type {string}
      */
     _classPrivateFieldInitSpec(this, _idPrefix, this.hot.guid.slice(0, 9));
+    /**
+     * Runs focus method after debounce.
+     */
+    _classPrivateFieldInitSpec(this, _focusDebounced, (0, _function.debounce)(() => {
+      this.focus();
+    }, 100));
     /**
      * Filters and sorts by relevance.
      *
@@ -102157,7 +102515,6 @@ class AutocompleteEditor extends _handsontableEditor.HandsontableEditor {
     }
     return this.TEXTAREA.value;
   }
-
   /**
    * Creates an editor's elements and adds necessary CSS classnames.
    */
@@ -102203,10 +102560,10 @@ class AutocompleteEditor extends _handsontableEditor.HandsontableEditor {
     this.showEditableElement();
     this.focus();
     this.addHook('beforeKeyDown', event => this.onBeforeKeyDown(event));
+    this.htEditor.addHook('afterScroll', _classPrivateFieldGet(_focusDebounced, this));
     this.htEditor.updateSettings({
       colWidths: trimDropdown ? [(0, _element.outerWidth)(this.TEXTAREA) - 2] : undefined,
       autoColumnSize: true,
-      autoRowSize: true,
       renderer: (hotInstance, TD, row, col, prop, value, cellProperties) => {
         (0, _textRenderer.textRenderer)(hotInstance, TD, row, col, prop, value, cellProperties);
         const {
@@ -102478,7 +102835,10 @@ class AutocompleteEditor extends _handsontableEditor.HandsontableEditor {
     const maxItems = Math.min(this.cellProperties.visibleRows, this.strippedChoices.length);
     const height = Array.from({
       length: maxItems
-    }, (_, i) => i).reduce((h, index) => h + this.htEditor.getRowHeight(index), 0);
+    }, (_, i) => i).reduce((totalHeight, index) => {
+      const rowHeight = this.htEditor.getRowHeight(index) || this.htEditor.view.getDefaultRowHeight();
+      return totalHeight + rowHeight;
+    }, 0);
     return height + borderVerticalCompensation + 1;
   }
 
@@ -102576,7 +102936,7 @@ exports.AutocompleteEditor = AutocompleteEditor;
 function _fixDropdownWidth() {
   if (this.htEditor.view.hasVerticalScroll()) {
     this.htEditor.updateSettings({
-      width: this.htEditor.getSettings().width + (0, _element.getScrollbarWidth)(this.hot.rootDocument)
+      width: this.getWidth() + (0, _element.getScrollbarWidth)(this.hot.rootDocument)
     });
   }
 }
@@ -111981,25 +112341,25 @@ var _manualRowResize = __webpack_require__(1020);
 exports.ManualRowResize = _manualRowResize.ManualRowResize;
 var _mergeCells = __webpack_require__(1022);
 exports.MergeCells = _mergeCells.MergeCells;
-var _multiColumnSorting = __webpack_require__(1036);
+var _multiColumnSorting = __webpack_require__(1037);
 exports.MultiColumnSorting = _multiColumnSorting.MultiColumnSorting;
-var _multipleSelectionHandles = __webpack_require__(1040);
+var _multipleSelectionHandles = __webpack_require__(1041);
 exports.MultipleSelectionHandles = _multipleSelectionHandles.MultipleSelectionHandles;
-var _nestedHeaders = __webpack_require__(1042);
+var _nestedHeaders = __webpack_require__(1043);
 exports.NestedHeaders = _nestedHeaders.NestedHeaders;
-var _nestedRows = __webpack_require__(1058);
+var _nestedRows = __webpack_require__(1059);
 exports.NestedRows = _nestedRows.NestedRows;
-var _persistentState = __webpack_require__(1066);
+var _persistentState = __webpack_require__(1067);
 exports.PersistentState = _persistentState.PersistentState;
-var _search = __webpack_require__(1069);
+var _search = __webpack_require__(1070);
 exports.Search = _search.Search;
-var _stretchColumns = __webpack_require__(1071);
+var _stretchColumns = __webpack_require__(1072);
 exports.StretchColumns = _stretchColumns.StretchColumns;
-var _touchScroll = __webpack_require__(1077);
+var _touchScroll = __webpack_require__(1078);
 exports.TouchScroll = _touchScroll.TouchScroll;
-var _trimRows = __webpack_require__(1079);
+var _trimRows = __webpack_require__(1080);
 exports.TrimRows = _trimRows.TrimRows;
-var _undoRedo = __webpack_require__(1081);
+var _undoRedo = __webpack_require__(1082);
 exports.UndoRedo = _undoRedo.UndoRedo;
 var _registry = __webpack_require__(532);
 exports.registerPlugin = _registry.registerPlugin;
@@ -112190,6 +112550,53 @@ const COLUMN_SIZE_MAP_NAME = 'autoColumnSize';
  * }
  * ```
  * :::
+ *
+ * ::: only-for angular
+ *
+ * ```ts
+ * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableModule,
+ *   HotTableComponent,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   selector: "app-example",
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     data: this.getData(),
+ *     autoColumnSize: true,
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access to plugin instance:
+ *     const hot = this.hotTable.hotInstance;
+ *     const plugin = hot.getPlugin("autoColumnSize");
+ *
+ *     plugin.getColumnWidth(4);
+ *
+ *     if (plugin.isEnabled()) {
+ *       // code...
+ *     }
+ *   }
+ *
+ *   private getData(): any[] {
+ *     //get some data
+ *   }
+ * }
+ * ```
+ *
+ * :::
  */
 /* eslint-enable jsdoc/require-description-complete-sentence */
 var _isInitialized = /*#__PURE__*/new WeakMap();
@@ -112388,7 +112795,7 @@ class AutoColumnSize extends _base.BasePlugin {
     if (firstVisibleColumn === -1 || lastVisibleColumn === -1) {
       return;
     }
-    const overwriteCache = this.hot.renderCall;
+    const overwriteCache = this.hot.forceFullRender;
     this.calculateColumnsWidth({
       from: firstVisibleColumn,
       to: lastVisibleColumn
@@ -113195,6 +113602,9 @@ class GhostTable {
     this.table = this.createTable(this.hot.table.className);
     this.table.colGroup.appendChild(this.createColGroupsCol(row));
     this.table.tr.appendChild(this.createRow(row));
+    if (row === 0) {
+      (0, _element.addClass)(this.table.table, 'htGhostTableFirstRow');
+    }
     this.container.container.appendChild(this.table.fragment);
     rowObject.table = this.table.table;
   }
@@ -114588,6 +114998,51 @@ const ROW_WIDTHS_MAP_NAME = 'autoRowSize';
  * }
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableModule,
+ *   HotTableComponent,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   selector: "app-example",
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     data: this.getData(),
+ *     autoRowSize: true,
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access to plugin instance:
+ *     const hot = this.hotTable.hotInstance;
+ *     const plugin = hot.getPlugin("autoRowSize");
+ *
+ *     plugin.getRowHeight(4);
+ *
+ *     if (plugin.isEnabled()) {
+ *       // code...
+ *     }
+ *   }
+ *
+ *   private getData(): any[] {
+ *     // get some data
+ *   }
+ * }
+ * ```
+ * :::
  */
 /* eslint-enable jsdoc/require-description-complete-sentence */
 var _visualRowsToRefresh = /*#__PURE__*/new WeakMap();
@@ -114782,7 +115237,7 @@ class AutoRowSize extends _base.BasePlugin {
     if (firstVisibleRow === -1 || lastVisibleRow === -1) {
       return;
     }
-    const overwriteCache = this.hot.renderCall;
+    const overwriteCache = this.hot.forceFullRender;
     this.calculateRowsHeight({
       from: firstVisibleRow,
       to: lastVisibleRow
@@ -114883,11 +115338,6 @@ class AutoRowSize extends _base.BasePlugin {
 
         // @TODO Should call once per render cycle, currently fired separately in different plugins
         this.hot.view.adjustElementsSize();
-
-        // tmp
-        if (this.hot.view._wt.wtOverlays.inlineStartOverlay.needFullRender) {
-          this.hot.view._wt.wtOverlays.inlineStartOverlay.clone.draw();
-        }
       }
     };
     const syncLimit = this.getSyncCalculationLimit();
@@ -115221,6 +115671,19 @@ const bindTypeToMapStrategy = new Map([['loose', _looseBindsMap.default], ['stri
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: getData(),
+ *   bindRowsWithHeaders: true,
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings" />
+ * ```
+ * :::
  */
 var _BindRowsWithHeaders_brand = /*#__PURE__*/new WeakSet();
 class BindRowsWithHeaders extends _base.BasePlugin {
@@ -115520,6 +115983,37 @@ const actionDictionary = new Map([['collapse', {
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * // Enable the collapsibleColumns plugin
+ * settings = {
+ *   data: generateDataObj(),
+ *   colHeaders: true,
+ *   rowHeaders: true,
+ *   nestedHeaders: true,
+ *   // enable plugin
+ *   collapsibleColumns: true,
+ * };
+ *
+ * // Or enable and configure specific collapsible columns
+ * settings = {
+ *   data: generateDataObj(),
+ *   colHeaders: true,
+ *   rowHeaders: true,
+ *   nestedHeaders: true,
+ *   // enable and configure which columns can be collapsed
+ *   collapsibleColumns: [
+ *     { row: -4, col: 1, collapsible: true },
+ *     { row: -3, col: 5, collapsible: true },
+ *   ],
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 var _collapsedColumnsMap = /*#__PURE__*/new WeakMap();
 var _CollapsibleColumns_brand = /*#__PURE__*/new WeakSet();
@@ -116338,10 +116832,6 @@ class ColumnSorting extends _base.BasePlugin {
     this.hot.runHooks('afterColumnSort', currentSortConfig, sortPossible ? destinationSortConfigs : currentSortConfig, sortPossible);
     if (sortPossible) {
       this.hot.render();
-      // TODO: Workaround? This triggers fast redraw. One test won't pass after removal.
-      // It should be refactored / described.
-      this.hot.forceFullRender = false;
-      this.hot.view.render();
     }
   }
 
@@ -117806,6 +118296,39 @@ const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 220;
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: getData(),
+ *   colHeaders: true,
+ *   rowHeaders: true,
+ *   columnSummary: [
+ *     {
+ *       type: "min",
+ *       destinationRow: 4,
+ *       destinationColumn: 1,
+ *     },
+ *     {
+ *       type: "max",
+ *       destinationRow: 0,
+ *       destinationColumn: 3,
+ *       reversedRowCoords: true,
+ *     },
+ *     {
+ *       type: "sum",
+ *       destinationRow: 4,
+ *       destinationColumn: 5,
+ *       forceNumeric: true,
+ *     },
+ *   ],
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 var _ColumnSummary_brand = /*#__PURE__*/new WeakSet();
 class ColumnSummary extends _base.BasePlugin {
@@ -118895,6 +119418,59 @@ const SHORTCUTS_CONTEXT_NAME = `plugin:${PLUGIN_KEY}`;
  * commentsPlugin.removeComment();
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableModule,
+ *   HotTableComponent,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   selector: "app-example",
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     data: this.getData(),
+ *     comments: true,
+ *     cell: [
+ *       { row: 1, col: 1, comment: { value: "Foo" } },
+ *       { row: 2, col: 2, comment: { value: "Bar" } },
+ *     ],
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access to plugin instance:
+ *     const hot = this.hotTable.hotInstance;
+ *     const commentsPlugin = hot.getPlugin("comments");
+ *
+ *     // Manage comments programmatically:
+ *     commentsPlugin.setCommentAtCell(1, 6, "Comment contents");
+ *     commentsPlugin.showAtCell(1, 6);
+ *     commentsPlugin.removeCommentAtCell(1, 6);
+ *
+ *     // You can also set range once and use proper methods:
+ *     commentsPlugin.setRange({ from: { row: 1, col: 6 } });
+ *     commentsPlugin.setComment("Comment contents");
+ *     commentsPlugin.show();
+ *   }
+ *
+ *   private getData(): any[] {
+ *     // get some data
+ *   }
+ * }
+ * ```
+ * :::
  */
 var _editor = /*#__PURE__*/new WeakMap();
 var _displaySwitch = /*#__PURE__*/new WeakMap();
@@ -119008,6 +119584,7 @@ class Comments extends _base.BasePlugin {
     this.addHook('afterScroll', () => _assertClassBrand(_Comments_brand, this, _onAfterScroll).call(this));
     this.addHook('afterBeginEditing', () => this.hide());
     this.addHook('afterDocumentKeyDown', event => _assertClassBrand(_Comments_brand, this, _onAfterDocumentKeyDown).call(this, event));
+    this.addHook('beforeCompositionStart', event => _assertClassBrand(_Comments_brand, this, _onAfterDocumentKeyDown).call(this, event));
     this.addHook('afterSetTheme', function () {
       for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
         args[_key2] = arguments[_key2];
@@ -122142,6 +122719,7 @@ class Menu {
       layoutDirection: this.hot.isRtl() ? 'rtl' : 'ltr',
       ariaTags: false,
       themeName: this.hot.getCurrentThemeName(),
+      beforeRefreshDimensions: () => false,
       beforeOnCellMouseOver: (event, coords) => {
         _classPrivateFieldGet(_navigator, this).setCurrentPage(coords.row);
       },
@@ -122685,7 +123263,11 @@ class Positioner {
   setPositionAboveCursor() {
     let top = _classPrivateFieldGet(_offset, this).above + _classPrivateFieldGet(_cursor, this).top - _classPrivateFieldGet(_container, this).offsetHeight;
     if (_classPrivateFieldGet(_parentContainer, this)) {
-      top = _classPrivateFieldGet(_cursor, this).top + _classPrivateFieldGet(_cursor, this).cellHeight - _classPrivateFieldGet(_container, this).offsetHeight + 3;
+      const rootWindow = _classPrivateFieldGet(_parentContainer, this).ownerDocument.defaultView;
+      const style = rootWindow.getComputedStyle(_classPrivateFieldGet(_parentContainer, this).querySelector('.ht_master'));
+      const paddingTop = Number.parseInt(style.paddingTop, 10);
+      const borderTop = Number.parseInt(style.borderTop, 10);
+      top = _classPrivateFieldGet(_cursor, this).top + _classPrivateFieldGet(_cursor, this).cellHeight - _classPrivateFieldGet(_container, this).scrollHeight + paddingTop + borderTop;
     }
     _classPrivateFieldGet(_container, this).style.top = `${top}px`;
   }
@@ -122696,7 +123278,11 @@ class Positioner {
   setPositionBelowCursor() {
     let top = _classPrivateFieldGet(_offset, this).below + _classPrivateFieldGet(_cursor, this).top + 1;
     if (_classPrivateFieldGet(_parentContainer, this)) {
-      top = _classPrivateFieldGet(_cursor, this).top - 1;
+      const rootWindow = _classPrivateFieldGet(_parentContainer, this).ownerDocument.defaultView;
+      const style = rootWindow.getComputedStyle(_classPrivateFieldGet(_parentContainer, this).querySelector('.ht_master'));
+      const paddingTop = Number.parseInt(style.paddingTop, 10);
+      const borderTop = Number.parseInt(style.borderTop, 10);
+      top = _classPrivateFieldGet(_cursor, this).top - paddingTop - borderTop - 1;
     }
     _classPrivateFieldGet(_container, this).style.top = `${top}px`;
   }
@@ -123437,7 +124023,7 @@ function createDefaultShortcutsList(menu) {
     keys: [['ArrowUp']],
     callback: () => menu.getNavigator().toPreviousItem()
   }, {
-    keys: [['ArrowRight']],
+    keys: [[hot.isRtl() ? 'ArrowLeft' : 'ArrowRight']],
     callback: () => {
       const selection = hotMenu.getSelectedLast();
       if (selection) {
@@ -123448,7 +124034,7 @@ function createDefaultShortcutsList(menu) {
       }
     }
   }, {
-    keys: [['ArrowLeft']],
+    keys: [[hot.isRtl() ? 'ArrowRight' : 'ArrowLeft']],
     callback: () => {
       const selection = hotMenu.getSelectedLast();
       if (selection && menu.isSubMenu()) {
@@ -123838,6 +124424,9 @@ class CopyPaste extends _base.BasePlugin {
       return _assertClassBrand(_CopyPaste_brand, _this, _onAfterSelection).call(_this, ...args);
     });
     this.addHook('afterSelectionEnd', () => _assertClassBrand(_CopyPaste_brand, this, _onAfterSelectionEnd).call(this));
+
+    // Events are attached to the document, not the root table element - as it should,
+    // for Chrome 133 and lower to copy/paste/cut work properly (#dev-2277).
     this.eventManager.addEventListener(this.hot.rootDocument, 'copy', function () {
       return _this.onCopy(...arguments);
     });
@@ -124144,12 +124733,10 @@ class CopyPaste extends _base.BasePlugin {
    * @private
    */
   onCopy(event) {
-    var _event$target, _this$hot$getSelected;
+    const eventTarget = event.composedPath()[0];
     const focusedElement = this.hot.getFocusManager().getRefocusElement();
-    const isHotInput = (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.hasAttribute('data-hot-input');
-    const selectedCell = (_this$hot$getSelected = this.hot.getSelectedRangeLast()) === null || _this$hot$getSelected === void 0 ? void 0 : _this$hot$getSelected.highlight;
-    const TD = selectedCell ? this.hot.getCell(selectedCell.row, selectedCell.col, true) : null;
-    if (!this.hot.isListening() && !_classPrivateFieldGet(_isTriggeredByCopy, this) || this.isEditorOpened() || (0, _element.isHTMLElement)(event.target) && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body && TD !== event.target)) {
+    const isHotInput = eventTarget === null || eventTarget === void 0 ? void 0 : eventTarget.hasAttribute('data-hot-input');
+    if (!this.hot.isListening() && !_classPrivateFieldGet(_isTriggeredByCopy, this) || this.isEditorOpened() || (0, _element.isHTMLElement)(eventTarget) && (isHotInput && eventTarget !== focusedElement || !isHotInput && eventTarget !== this.hot.rootDocument.body && !(0, _element.isInternalElement)(eventTarget, this.hot.rootElement))) {
       return;
     }
     event.preventDefault();
@@ -124179,12 +124766,10 @@ class CopyPaste extends _base.BasePlugin {
    * @private
    */
   onCut(event) {
-    var _event$target2, _this$hot$getSelected2;
+    const eventTarget = event.composedPath()[0];
     const focusedElement = this.hot.getFocusManager().getRefocusElement();
-    const isHotInput = (_event$target2 = event.target) === null || _event$target2 === void 0 ? void 0 : _event$target2.hasAttribute('data-hot-input');
-    const selectedCell = (_this$hot$getSelected2 = this.hot.getSelectedRangeLast()) === null || _this$hot$getSelected2 === void 0 ? void 0 : _this$hot$getSelected2.highlight;
-    const TD = selectedCell ? this.hot.getCell(selectedCell.row, selectedCell.col, true) : null;
-    if (!this.hot.isListening() && !_classPrivateFieldGet(_isTriggeredByCut, this) || this.isEditorOpened() || (0, _element.isHTMLElement)(event.target) && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body && TD !== event.target)) {
+    const isHotInput = eventTarget === null || eventTarget === void 0 ? void 0 : eventTarget.hasAttribute('data-hot-input');
+    if (!this.hot.isListening() && !_classPrivateFieldGet(_isTriggeredByCut, this) || this.isEditorOpened() || (0, _element.isHTMLElement)(eventTarget) && (isHotInput && eventTarget !== focusedElement || !isHotInput && eventTarget !== this.hot.rootDocument.body && !(0, _element.isInternalElement)(eventTarget, this.hot.rootElement))) {
       return;
     }
     event.preventDefault();
@@ -124213,12 +124798,10 @@ class CopyPaste extends _base.BasePlugin {
    * @private
    */
   onPaste(event) {
-    var _event$target3, _this$hot$getSelected3;
+    const eventTarget = event.composedPath()[0];
     const focusedElement = this.hot.getFocusManager().getRefocusElement();
-    const isHotInput = (_event$target3 = event.target) === null || _event$target3 === void 0 ? void 0 : _event$target3.hasAttribute('data-hot-input');
-    const selectedCell = (_this$hot$getSelected3 = this.hot.getSelectedRangeLast()) === null || _this$hot$getSelected3 === void 0 ? void 0 : _this$hot$getSelected3.highlight;
-    const TD = selectedCell ? this.hot.getCell(selectedCell.row, selectedCell.col, true) : null;
-    if (!this.hot.isListening() || this.isEditorOpened() || !this.hot.getSelected() || (0, _element.isHTMLElement)(event.target) && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body && TD !== event.target)) {
+    const isHotInput = eventTarget === null || eventTarget === void 0 ? void 0 : eventTarget.hasAttribute('data-hot-input');
+    if (!this.hot.isListening() || this.isEditorOpened() || !this.hot.getSelected() || (0, _element.isHTMLElement)(eventTarget) && (isHotInput && eventTarget !== focusedElement || !isHotInput && eventTarget !== this.hot.rootDocument.body && !(0, _element.isInternalElement)(eventTarget, this.hot.rootElement))) {
       return;
     }
     event.preventDefault();
@@ -124665,6 +125248,9 @@ class PasteEvent {
     this.clipboardData = new _clipboardData.default();
   }
   preventDefault() {}
+  composedPath() {
+    return [];
+  }
 }
 exports["default"] = PasteEvent;
 
@@ -126507,6 +127093,21 @@ const SHORTCUTS_GROUP = PLUGIN_KEY;
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: data,
+ *   comments: true,
+ *   // enable and configure dropdown menu
+ *   dropdownMenu: ["remove_col", "---------", "make_read_only", "alignment"],
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 var _isButtonClicked = /*#__PURE__*/new WeakMap();
 var _DropdownMenu_brand = /*#__PURE__*/new WeakSet();
@@ -127087,6 +127688,64 @@ const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 240;
  * });
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableModule,
+ *   HotTableComponent,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   selector: "app-example",
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     data: this.getData(),
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access to plugin instance:
+ *     const hot = this.hotTable.hotInstance;
+ *     // Access to exportFile plugin instance
+ *     const exportPlugin = hot.getPlugin("exportFile");
+ *
+ *     // Export as a string
+ *     exportPlugin.exportAsString("csv");
+ *
+ *     // Export as a blob object
+ *     exportPlugin.exportAsBlob("csv");
+ *
+ *     // Export to downloadable file (named: MyFile.csv)
+ *     exportPlugin.downloadFile("csv", { filename: "MyFile" });
+ *
+ *     // Export as a string (with specified data range):
+ *     exportPlugin.exportAsString("csv", {
+ *       exportHiddenRows: true, // default false
+ *       exportHiddenColumns: true, // default false
+ *       columnHeaders: true, // default false
+ *       rowHeaders: true, // default false
+ *       columnDelimiter: ";", // default ','
+ *       range: [1, 1, 6, 6], // [startRow, endRow, startColumn, endColumn]
+ *     });
+ *   }
+ *
+ *   private getData(): any[] {
+ *     // get some data
+ *   }
+ * }
+ * ```
+ * :::
  */
 class ExportFile extends _base.BasePlugin {
   static get PLUGIN_KEY() {
@@ -127668,6 +128327,22 @@ const SHORTCUTS_GROUP = PLUGIN_KEY;
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: getData(),
+ *   colHeaders: true,
+ *   rowHeaders: true,
+ *   dropdownMenu: true,
+ *   filters: true,
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 var _menuFocusNavigator = /*#__PURE__*/new WeakMap();
 var _dropdownMenuTraces = /*#__PURE__*/new WeakMap();
@@ -128050,6 +128725,64 @@ class Filters extends _base.BasePlugin {
    * ```
    * :::
    *
+   * ::: only-for angular
+   * ```ts
+   * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+   * import {
+   *   GridSettings,
+   *   HotTableModule,
+   *   HotTableComponent,
+   * } from "@handsontable/angular-wrapper";
+   *
+   * `@Component`({
+   *   selector: "app-example",
+   *   standalone: true,
+   *   imports: [HotTableModule],
+   *   template: ` <div class="ht-theme-main">
+   *     <hot-table [settings]="gridSettings" />
+   *   </div>`,
+   * })
+   * export class ExampleComponent implements AfterViewInit {
+   *   `@ViewChild`(HotTableComponent, { static: false })
+   *   readonly hotTable!: HotTableComponent;
+   *
+   *   readonly gridSettings = <GridSettings>{
+   *     data: this.getData(),
+   *     filters: true,
+   *   };
+   *
+   *   ngAfterViewInit(): void {
+   *     // Access to filters plugin instance
+   *     const hot = this.hotTable.hotInstance;
+   *     const filtersPlugin = hot.getPlugin("filters");
+   *
+   *     // Add filter "Greater than" 95 to column at index 1
+   *     filtersPlugin.addCondition(1, "gt", [95]);
+   *     filtersPlugin.filter();
+   *
+   *     // Add filter "By value" to column at index 1
+   *     // In this case, all values that don't match will be filtered.
+   *     filtersPlugin.addCondition(1, "by_value", [["ing", "ed", "as", "on"]]);
+   *     filtersPlugin.filter();
+   *
+   *     // Add filter "Begins with" with value "de" AND "Not contains" with value "ing"
+   *     filtersPlugin.addCondition(1, "begins_with", ["de"], "conjunction");
+   *     filtersPlugin.addCondition(1, "not_contains", ["ing"], "conjunction");
+   *     filtersPlugin.filter();
+   *
+   *     // Add filter "Begins with" with value "de" OR "Not contains" with value "ing"
+   *     filtersPlugin.addCondition(1, "begins_with", ["de"], "disjunction");
+   *     filtersPlugin.addCondition(1, "not_contains", ["ing"], "disjunction");
+   *     filtersPlugin.filter();
+   *   }
+   *
+   *   private getData(): any[] {
+   *     // Get some data
+   *   }
+   * }
+   * ```
+   * :::
+   *
    * @param {number} column Visual column index.
    * @param {string} name Condition short name.
    * @param {Array} args Condition arguments.
@@ -128132,10 +128865,10 @@ class Filters extends _base.BasePlugin {
    *
    * @returns {Array}
    */
-  /* eslint-enable jsdoc/require-description-complete-sentence */
   exportConditions() {
     return this.conditionCollection.exportAllConditions();
   }
+  /* eslint-enable jsdoc/require-description-complete-sentence */
 
   /**
    * Filters data based on added filter conditions.
@@ -128152,38 +128885,39 @@ class Filters extends _base.BasePlugin {
     let visibleVisualRows = [];
     const conditions = this.exportConditions();
     const allowFiltering = this.hot.runHooks('beforeFilter', conditions, _classPrivateFieldGet(_previousConditionStack, this));
-    if (allowFiltering !== false) {
-      if (needToFilter) {
-        const trimmedRows = [];
-        this.hot.batchExecution(() => {
-          this.filtersRowsMap.clear();
-          visibleVisualRows = (0, _array.arrayMap)(dataFilter.filter(), rowData => rowData.meta.visualRow);
-          const visibleVisualRowsAssertion = (0, _utils.createArrayAssertion)(visibleVisualRows);
-          (0, _number.rangeEach)(this.hot.countSourceRows() - 1, row => {
-            if (!visibleVisualRowsAssertion(row)) {
-              trimmedRows.push(row);
-            }
-          });
-          (0, _array.arrayEach)(trimmedRows, physicalRow => {
-            this.filtersRowsMap.setValueAtIndex(physicalRow, true);
-          });
-        }, true);
-        if (!navigableHeaders && !visibleVisualRows.length) {
-          this.hot.deselectCell();
-        }
-      } else {
+    if (allowFiltering !== false && needToFilter) {
+      const trimmedRows = [];
+      this.hot.batchExecution(() => {
         this.filtersRowsMap.clear();
+        visibleVisualRows = (0, _array.arrayMap)(dataFilter.filter(), rowData => rowData.meta.visualRow);
+        const visibleVisualRowsAssertion = (0, _utils.createArrayAssertion)(visibleVisualRows);
+        (0, _number.rangeEach)(this.hot.countSourceRows() - 1, row => {
+          if (!visibleVisualRowsAssertion(row)) {
+            trimmedRows.push(row);
+          }
+        });
+        (0, _array.arrayEach)(trimmedRows, physicalRow => {
+          this.filtersRowsMap.setValueAtIndex(physicalRow, true);
+        });
+      }, true);
+      if (!navigableHeaders && !visibleVisualRows.length) {
+        this.hot.deselectCell();
       }
       _classPrivateFieldSet(_previousConditionStack, this, this.exportConditions());
-      this.hot.runHooks('afterFilter', conditions);
-      this.hot.view.adjustElementsSize();
-      this.hot.render();
+    } else if (allowFiltering !== false && !needToFilter) {
+      _classPrivateFieldSet(_previousConditionStack, this, this.exportConditions());
+      this.filtersRowsMap.clear();
     } else {
       this.importConditions(_classPrivateFieldGet(_previousConditionStack, this));
     }
     if (this.hot.selection.isSelected()) {
       this.hot.selectCell(navigableHeaders ? -1 : 0, this.hot.getSelectedRangeLast().highlight.col);
     }
+    if (allowFiltering !== false) {
+      this.hot.runHooks('afterFilter', conditions);
+      this.hot.view.adjustElementsSize();
+      this.hot.render();
+    }
   }
 
   /**
@@ -131610,7 +132344,13 @@ class MultipleSelectUI extends _base.BaseUI {
         beforeOnCellMouseUp: () => {
           _classPrivateFieldGet(_itemsBox, this).listen();
         },
-        colWidths: () => _classPrivateFieldGet(_itemsBox, this).container.scrollWidth - (0, _element.getScrollbarWidth)(rootDocument),
+        modifyColWidth: width => {
+          const minWidth = _classPrivateFieldGet(_itemsBox, this).container.scrollWidth - (0, _element.getScrollbarWidth)(rootDocument);
+          if (width !== undefined && width < minWidth) {
+            return minWidth;
+          }
+          return width;
+        },
         maxCols: 1,
         autoWrapCol: true,
         height: 110,
@@ -135233,6 +135973,70 @@ const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 310;
  * hot.render();
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableModule,
+ *   HotTableComponent,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   selector: "app-example",
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     data: this.getData(),
+ *     hiddenColumns: {
+ *       copyPasteEnabled: true,
+ *       indicators: true,
+ *       columns: [1, 2, 5],
+ *     },
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access the `HiddenColumns` plugin's instance
+ *     const hot = this.hotTable.hotInstance;
+ *     const hiddenColumnsPlugin = hot.getPlugin("hiddenColumns");
+ *
+ *     // Hide a single column
+ *     hiddenColumnsPlugin.hideColumn(1);
+ *
+ *     // Hide multiple columns
+ *     hiddenColumnsPlugin.hideColumn(1, 2, 9);
+ *
+ *     // Hide multiple columns as an array
+ *     hiddenColumnsPlugin.hideColumns([1, 2, 9]);
+ *
+ *     // Unhide a single column
+ *     hiddenColumnsPlugin.showColumn(1);
+ *
+ *     // Unhide multiple columns
+ *     hiddenColumnsPlugin.showColumn(1, 2, 9);
+ *
+ *     // Unhide multiple columns as an array
+ *     hiddenColumnsPlugin.showColumns([1, 2, 9]);
+ *
+ *     // To see your changes, re-render your Handsontable instance
+ *     hot.render();
+ *   }
+ *
+ *   private getData(): any[] {
+ *     // Get some data
+ *   }
+ * }
+ * ```
+ * :::
  */
 var _hiddenColumnsMap = /*#__PURE__*/new WeakMap();
 var _HiddenColumns_brand = /*#__PURE__*/new WeakSet();
@@ -135323,8 +136127,8 @@ class HiddenColumns extends _base.BasePlugin {
    * Disables the plugin functionality for this Handsontable instance.
    */
   disablePlugin() {
-    this.hot.columnIndexMapper.unregisterMap(this.pluginName);
     super.disablePlugin();
+    this.hot.columnIndexMapper.unregisterMap(this.pluginName);
     this.resetCellsMeta();
   }
 
@@ -135922,6 +136726,70 @@ const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 320;
  * hot.render();
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableModule,
+ *   HotTableComponent,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   selector: "app-example",
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     data: this.getData(),
+ *     hiddenRows: {
+ *       copyPasteEnabled: true,
+ *       indicators: true,
+ *       rows: [1, 2, 5],
+ *     },
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access the `HiddenRows` plugin's instance
+ *     const hot = this.hotTable.hotInstance;
+ *     const hiddenRowsPlugin = hot.getPlugin("hiddenRows");
+ *
+ *     // Hide a single row
+ *     hiddenRowsPlugin.hideRow(1);
+ *
+ *     // Hide multiple rows
+ *     hiddenRowsPlugin.hideRow(1, 2, 9);
+ *
+ *     // Hide multiple rows as an array
+ *     hiddenRowsPlugin.hideRows([1, 2, 9]);
+ *
+ *     // Unhide a single row
+ *     hiddenRowsPlugin.showRow(1);
+ *
+ *     // Unhide multiple rows
+ *     hiddenRowsPlugin.showRow(1, 2, 9);
+ *
+ *     // Unhide multiple rows as an array
+ *     hiddenRowsPlugin.showRows([1, 2, 9]);
+ *
+ *     // To see your changes, re-render your Handsontable instance
+ *     hot.render();
+ *   }
+ *
+ *   private getData(): any[] {
+ *     // Get some data
+ *   }
+ * }
+ * ```
+ * :::
  */
 var _hiddenRowsMap = /*#__PURE__*/new WeakMap();
 var _HiddenRows_brand = /*#__PURE__*/new WeakSet();
@@ -136012,8 +136880,8 @@ class HiddenRows extends _base.BasePlugin {
    * Disables the plugin functionality for this Handsontable instance.
    */
   disablePlugin() {
-    this.hot.rowIndexMapper.unregisterMap(this.pluginName);
     super.disablePlugin();
+    this.hot.rowIndexMapper.unregisterMap(this.pluginName);
     this.resetCellsMeta();
   }
 
@@ -138052,12 +138920,12 @@ class ManualColumnResize extends _base.BasePlugin {
   setupGuidePosition() {
     const handleHeight = parseInt((0, _element.outerHeight)(_classPrivateFieldGet(_handle, this)), 10);
     const handleBottomPosition = parseInt(_classPrivateFieldGet(_handle, this).style.top, 10) + handleHeight;
-    const maximumVisibleElementHeight = parseInt(this.hot.view.maximumVisibleElementHeight(0), 10);
+    const tableHeight = this.hot.view.getTableHeight();
     (0, _element.addClass)(_classPrivateFieldGet(_handle, this), 'active');
     (0, _element.addClass)(_classPrivateFieldGet(_guide, this), 'active');
     _classPrivateFieldGet(_guide, this).style.top = `${handleBottomPosition}px`;
     this.refreshGuidePosition();
-    _classPrivateFieldGet(_guide, this).style.height = `${maximumVisibleElementHeight - handleHeight}px`;
+    _classPrivateFieldGet(_guide, this).style.height = `${tableHeight - handleHeight}px`;
     this.hot.rootElement.appendChild(_classPrivateFieldGet(_guide, this));
   }
 
@@ -138128,8 +138996,7 @@ class ManualColumnResize extends _base.BasePlugin {
    */
   afterMouseDownTimeout() {
     const render = () => {
-      this.hot.forceFullRender = true;
-      this.hot.view.render(); // updates all
+      this.hot.render();
       this.hot.view.adjustElementsSize();
     };
     const resize = (column, forceRender) => {
@@ -138289,8 +139156,7 @@ function _onMouseMove(event) {
  */
 function _onMouseUp() {
   const render = () => {
-    this.hot.forceFullRender = true;
-    this.hot.view.render(); // updates all
+    this.hot.render();
     this.hot.view.adjustElementsSize();
   };
   const resize = (column, forceRender) => {
@@ -139614,12 +140480,12 @@ class ManualRowResize extends _base.BasePlugin {
   setupGuidePosition() {
     const handleWidth = parseInt((0, _element.outerWidth)(_classPrivateFieldGet(_handle, this)), 10);
     const handleEndPosition = parseInt(_classPrivateFieldGet(_handle, this).style[this.inlineDir], 10) + handleWidth;
-    const maximumVisibleElementWidth = parseInt(this.hot.view.maximumVisibleElementWidth(0), 10);
+    const tableWidth = this.hot.view.getTableWidth();
     (0, _element.addClass)(_classPrivateFieldGet(_handle, this), 'active');
     (0, _element.addClass)(_classPrivateFieldGet(_guide, this), 'active');
     _classPrivateFieldGet(_guide, this).style.top = _classPrivateFieldGet(_handle, this).style.top;
     _classPrivateFieldGet(_guide, this).style[this.inlineDir] = `${handleEndPosition}px`;
-    _classPrivateFieldGet(_guide, this).style.width = `${maximumVisibleElementWidth - handleWidth}px`;
+    _classPrivateFieldGet(_guide, this).style.width = `${tableWidth - handleWidth}px`;
     this.hot.rootElement.appendChild(_classPrivateFieldGet(_guide, this));
   }
 
@@ -139700,8 +140566,7 @@ class ManualRowResize extends _base.BasePlugin {
    */
   afterMouseDownTimeout() {
     const render = () => {
-      this.hot.forceFullRender = true;
-      this.hot.view.render(); // updates all
+      this.hot.render();
       this.hot.view.adjustElementsSize();
     };
     const resize = (row, forceRender) => {
@@ -139829,8 +140694,7 @@ function _onMouseMove(event) {
  */
 function _onMouseUp() {
   const render = () => {
-    this.hot.forceFullRender = true;
-    this.hot.view.render(); // updates all
+    this.hot.render();
     this.hot.view.adjustElementsSize();
   };
   const runHooks = (row, forceRender) => {
@@ -139963,6 +140827,7 @@ var _element = __webpack_require__(351);
 var _browser = __webpack_require__(498);
 var _focusOrder2 = __webpack_require__(1033);
 var _renderer = __webpack_require__(1035);
+var _utils = __webpack_require__(1036);
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -140013,6 +140878,24 @@ const SHORTCUTS_GROUP = PLUGIN_KEY;
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: getData(),
+ *   // Enable plugin
+ *   mergeCells: [
+ *     { row: 0, col: 3, rowspan: 3, colspan: 3 },
+ *     { row: 2, col: 6, rowspan: 2, colspan: 2 },
+ *     { row: 4, col: 8, rowspan: 3, colspan: 3 },
+ *   ],
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 var _lastSelectedFocus = /*#__PURE__*/new WeakMap();
 var _lastFocusDelta = /*#__PURE__*/new WeakMap();
@@ -140595,8 +141478,12 @@ class MergeCells extends _base.BasePlugin {
    * @param {CellRange} cellRange The cell range to merge or unmerged.
    */
   toggleMerge(cellRange) {
-    const mergedCell = this.mergedCellsCollection.get(cellRange.from.row, cellRange.from.col);
-    const mergedCellCoversWholeRange = mergedCell.row === cellRange.from.row && mergedCell.col === cellRange.from.col && mergedCell.row + mergedCell.rowspan - 1 === cellRange.to.row && mergedCell.col + mergedCell.colspan - 1 === cellRange.to.col;
+    const {
+      from,
+      to
+    } = cellRange.clone().normalize();
+    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;
     if (mergedCellCoversWholeRange) {
       this.unmergeRange(cellRange);
     } else {
@@ -141408,36 +142295,10 @@ function _onModifyRowHeightByOverlayName(height, row, overlayType) {
     } else {
       rowspanAfterCorrection = rowspan - rowspanCorrection;
     }
-    height = Math.max(height !== null && height !== void 0 ? height : 0, _assertClassBrand(_MergeCells_brand, this, _sumCellsHeights).call(this, row, rowspanAfterCorrection));
+    height = Math.max(height !== null && height !== void 0 ? height : 0, (0, _utils.sumCellsHeights)(this.hot, row, rowspanAfterCorrection));
   });
   return height;
 }
-/**
- * Sums the heights of the all cells that the merge cell consists of.
- *
- * @param {number} row The visual row index of the merged cell.
- * @param {number} rowspan The rowspan value of the merged cell.
- * @returns {number}
- */
-function _sumCellsHeights(row, rowspan) {
-  const {
-    view,
-    rowIndexMapper
-  } = this.hot;
-  const stylesHandler = view.getStylesHandler();
-  const defaultHeight = view.getDefaultRowHeight();
-  let height = 0;
-  for (let i = row; i < row + rowspan; i++) {
-    if (!rowIndexMapper.isHidden(i)) {
-      var _this$hot$getRowHeigh;
-      height += (_this$hot$getRowHeigh = this.hot.getRowHeight(i)) !== null && _this$hot$getRowHeigh !== void 0 ? _this$hot$getRowHeigh : defaultHeight;
-      if (i === 0 && !stylesHandler.isClassicTheme()) {
-        height += 1; // border-top-width
-      }
-    }
-  }
-  return height;
-}
 
 /***/ }),
 /* 1024 */
@@ -143622,6 +144483,8 @@ var _default = exports["default"] = LinkedList;
 exports.__esModule = true;
 exports.createMergeCellRenderer = createMergeCellRenderer;
 var _object = __webpack_require__(499);
+var _browser = __webpack_require__(498);
+var _utils = __webpack_require__(1036);
 /**
  * Creates a renderer object for the `MergeCells` plugin.
  *
@@ -143637,6 +144500,7 @@ function createMergeCellRenderer(plugin) {
     rowIndexMapper: rowMapper,
     columnIndexMapper: columnMapper
   } = hot;
+  const updateNextCellsHeight = new Map();
 
   /**
    * Runs before the cell is rendered.
@@ -143658,6 +144522,10 @@ function createMergeCellRenderer(plugin) {
     if (!(0, _object.isObject)(mergedCell)) {
       TD.removeAttribute('rowspan');
       TD.removeAttribute('colspan');
+      if ((0, _browser.isSafari)() && updateNextCellsHeight.has(row) && !hot.getSettings().rowHeaders) {
+        TD.style.height = `${updateNextCellsHeight.get(row)}px`;
+        updateNextCellsHeight.delete(row);
+      }
       TD.style.display = '';
       return;
     }
@@ -143669,6 +144537,14 @@ function createMergeCellRenderer(plugin) {
     } = mergedCell;
     const [lastMergedRowIndex, lastMergedColumnIndex] = plugin.translateMergedCellToRenderable(origRow, origRowspan, origColumn, origColspan);
     const isVirtualRenderingEnabled = plugin.getSetting('virtualized');
+
+    // Safari bug fix - the height of the cells next to the merged cell must be defined
+    // so that their height is proportional to the height of the merged cell
+    // (this emulates default behavior in Chrome, FF etc.)
+    if ((0, _browser.isSafari)() && origColumn === 0 && !hot.getSettings().rowHeaders) {
+      const height = (0, _utils.sumCellsHeights)(hot, origRow, origRowspan);
+      updateNextCellsHeight.set(row, height / origRowspan);
+    }
     const renderedRowIndex = rowMapper.getRenderableFromVisualIndex(row);
     const renderedColumnIndex = columnMapper.getRenderableFromVisualIndex(col);
     const maxRowSpan = lastMergedRowIndex - renderedRowIndex + 1; // Number of rendered columns.
@@ -143704,19 +144580,56 @@ function createMergeCellRenderer(plugin) {
 
 /***/ }),
 /* 1036 */
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+exports.__esModule = true;
+exports.sumCellsHeights = sumCellsHeights;
+/**
+ * Calculates the total height of the merged cell.
+ *
+ * @param {Core} hotInstance The Handsontable instance.
+ * @param {*} row The merged cell's row index.
+ * @param {*} rowspan The merged cell height.
+ * @returns {number}
+ */
+function sumCellsHeights(hotInstance, row, rowspan) {
+  const {
+    view,
+    rowIndexMapper
+  } = hotInstance;
+  const stylesHandler = view.getStylesHandler();
+  const defaultHeight = view.getDefaultRowHeight();
+  let height = 0;
+  for (let i = row; i < row + rowspan; i++) {
+    if (!rowIndexMapper.isHidden(i)) {
+      var _hotInstance$getRowHe;
+      height += (_hotInstance$getRowHe = hotInstance.getRowHeight(i)) !== null && _hotInstance$getRowHe !== void 0 ? _hotInstance$getRowHe : defaultHeight;
+      if (i === 0 && !stylesHandler.isClassicTheme()) {
+        height += 1; // border-top-width
+      }
+    }
+  }
+  return height;
+}
+
+/***/ }),
+/* 1037 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _multiColumnSorting = __webpack_require__(1037);
+var _multiColumnSorting = __webpack_require__(1038);
 exports.PLUGIN_KEY = _multiColumnSorting.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _multiColumnSorting.PLUGIN_PRIORITY;
 exports.MultiColumnSorting = _multiColumnSorting.MultiColumnSorting;
 
 /***/ }),
-/* 1037 */
+/* 1038 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -143729,8 +144642,8 @@ var _columnSorting = __webpack_require__(856);
 var _sortService = __webpack_require__(860);
 var _utils = __webpack_require__(859);
 var _element = __webpack_require__(351);
-var _rootComparator = __webpack_require__(1038);
-var _domHelpers = __webpack_require__(1039);
+var _rootComparator = __webpack_require__(1039);
+var _domHelpers = __webpack_require__(1040);
 var _shortcutContexts = __webpack_require__(686);
 const PLUGIN_KEY = exports.PLUGIN_KEY = 'multiColumnSorting';
 const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 170;
@@ -144016,7 +144929,7 @@ class MultiColumnSorting extends _columnSorting.ColumnSorting {
 exports.MultiColumnSorting = MultiColumnSorting;
 
 /***/ }),
-/* 1038 */
+/* 1039 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -144058,7 +144971,7 @@ function rootComparator(sortingOrders, columnMetas) {
 }
 
 /***/ }),
-/* 1039 */
+/* 1040 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -144104,20 +145017,20 @@ function getClassesToRemove(htmlElement) {
 }
 
 /***/ }),
-/* 1040 */
+/* 1041 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _multipleSelectionHandles = __webpack_require__(1041);
+var _multipleSelectionHandles = __webpack_require__(1042);
 exports.PLUGIN_KEY = _multipleSelectionHandles.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _multipleSelectionHandles.PLUGIN_PRIORITY;
 exports.MultipleSelectionHandles = _multipleSelectionHandles.MultipleSelectionHandles;
 
 /***/ }),
-/* 1041 */
+/* 1042 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -144456,20 +145369,20 @@ class MultipleSelectionHandles extends _base.BasePlugin {
 exports.MultipleSelectionHandles = MultipleSelectionHandles;
 
 /***/ }),
-/* 1042 */
+/* 1043 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _nestedHeaders = __webpack_require__(1043);
+var _nestedHeaders = __webpack_require__(1044);
 exports.PLUGIN_KEY = _nestedHeaders.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _nestedHeaders.PLUGIN_PRIORITY;
 exports.NestedHeaders = _nestedHeaders.NestedHeaders;
 
 /***/ }),
-/* 1043 */
+/* 1044 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -144489,8 +145402,8 @@ var _event = __webpack_require__(509);
 var _console = __webpack_require__(512);
 var _selection = __webpack_require__(652);
 var _base = __webpack_require__(841);
-var _stateManager2 = _interopRequireDefault(__webpack_require__(1044));
-var _ghostTable = _interopRequireDefault(__webpack_require__(1057));
+var _stateManager2 = _interopRequireDefault(__webpack_require__(1045));
+var _ghostTable = _interopRequireDefault(__webpack_require__(1058));
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -144545,6 +145458,31 @@ const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 280;
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: getData(),
+ *   nestedHeaders: [
+ *     ["A", { label: "B", colspan: 8, headerClassName: "htRight" }, "C"],
+ *     ["D", { label: "E", colspan: 4 }, { label: "F", colspan: 4 }, "G"],
+ *     [
+ *       "H",
+ *       { label: "I", colspan: 2 },
+ *       { label: "J", colspan: 2 },
+ *       { label: "K", colspan: 2 },
+ *       { label: "L", colspan: 2 },
+ *       "M",
+ *     ],
+ *     ["N", "O", "P", "Q", "R", "S", "T", "U", "V", "W"],
+ *   ],
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 var _stateManager = /*#__PURE__*/new WeakMap();
 var _hidingIndexMapObserver = /*#__PURE__*/new WeakMap();
@@ -145478,7 +146416,7 @@ function _onAfterLoadData(sourceData, initialLoad) {
 }
 
 /***/ }),
-/* 1044 */
+/* 1045 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -145491,11 +146429,11 @@ __webpack_require__(283);
 __webpack_require__(311);
 __webpack_require__(338);
 var _array = __webpack_require__(495);
-var _sourceSettings2 = _interopRequireDefault(__webpack_require__(1045));
-var _headersTree2 = _interopRequireDefault(__webpack_require__(1048));
-var _nodeModifiers = __webpack_require__(1050);
-var _matrixGenerator = __webpack_require__(1056);
-var _tree = __webpack_require__(1049);
+var _sourceSettings2 = _interopRequireDefault(__webpack_require__(1046));
+var _headersTree2 = _interopRequireDefault(__webpack_require__(1049));
+var _nodeModifiers = __webpack_require__(1051);
+var _matrixGenerator = __webpack_require__(1057);
+var _tree = __webpack_require__(1050);
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
@@ -145970,7 +146908,7 @@ class StateManager {
 exports["default"] = StateManager;
 
 /***/ }),
-/* 1045 */
+/* 1046 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -145981,7 +146919,7 @@ __webpack_require__(201);
 __webpack_require__(283);
 var _object = __webpack_require__(499);
 var _array = __webpack_require__(495);
-var _settingsNormalizer = __webpack_require__(1046);
+var _settingsNormalizer = __webpack_require__(1047);
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
@@ -146192,7 +147130,7 @@ class SourceSettings {
 exports["default"] = SourceSettings;
 
 /***/ }),
-/* 1046 */
+/* 1047 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -146204,7 +147142,7 @@ __webpack_require__(283);
 var _array = __webpack_require__(495);
 var _object = __webpack_require__(499);
 var _mixed = __webpack_require__(354);
-var _utils = __webpack_require__(1047);
+var _utils = __webpack_require__(1048);
 /* eslint-disable jsdoc/require-description-complete-sentence */
 
 /**
@@ -146306,7 +147244,7 @@ function normalizeSettings(sourceSettings) {
 }
 
 /***/ }),
-/* 1047 */
+/* 1048 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -146383,7 +147321,7 @@ function createPlaceholderHeaderSettings() {
 }
 
 /***/ }),
-/* 1048 */
+/* 1049 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -146393,7 +147331,7 @@ var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 __webpack_require__(201);
 var _array = __webpack_require__(495);
-var _tree = _interopRequireDefault(__webpack_require__(1049));
+var _tree = _interopRequireDefault(__webpack_require__(1050));
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
@@ -146621,7 +147559,7 @@ class HeadersTree {
 exports["default"] = HeadersTree;
 
 /***/ }),
-/* 1049 */
+/* 1050 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -146840,7 +147778,7 @@ class TreeNode {
 exports["default"] = TreeNode;
 
 /***/ }),
-/* 1050 */
+/* 1051 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -146849,10 +147787,10 @@ exports["default"] = TreeNode;
 exports.__esModule = true;
 exports.triggerNodeModification = triggerNodeModification;
 __webpack_require__(201);
-var _collapse = __webpack_require__(1051);
-var _expand = __webpack_require__(1052);
-var _hideColumn = __webpack_require__(1054);
-var _showColumn = __webpack_require__(1055);
+var _collapse = __webpack_require__(1052);
+var _expand = __webpack_require__(1053);
+var _hideColumn = __webpack_require__(1055);
+var _showColumn = __webpack_require__(1056);
 /**
  * The NodeModifiers module is responsible for the modification of a tree structure
  * in a way to achieve new column headers state.
@@ -146882,7 +147820,7 @@ function triggerNodeModification(actionName, nodeToProcess, gridColumnIndex) {
 }
 
 /***/ }),
-/* 1051 */
+/* 1052 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -146898,8 +147836,8 @@ __webpack_require__(305);
 __webpack_require__(307);
 __webpack_require__(309);
 var _array = __webpack_require__(495);
-var _expand = __webpack_require__(1052);
-var _tree = __webpack_require__(1053);
+var _expand = __webpack_require__(1053);
+var _tree = __webpack_require__(1054);
 /**
  * Collapsing a node is a process where the processing node is collapsed
  * to the colspan width of the first child. All node children, except the
@@ -146992,7 +147930,7 @@ function collapseNode(nodeToProcess) {
 }
 
 /***/ }),
-/* 1052 */
+/* 1053 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -147008,8 +147946,8 @@ __webpack_require__(305);
 __webpack_require__(307);
 __webpack_require__(309);
 var _array = __webpack_require__(495);
-var _collapse = __webpack_require__(1051);
-var _tree = __webpack_require__(1053);
+var _collapse = __webpack_require__(1052);
+var _tree = __webpack_require__(1054);
 /**
  * Expanding a node is a process where the processing node is expanded to
  * its original colspan width. To restore an original state of all node
@@ -147097,7 +148035,7 @@ function expandNode(nodeToProcess) {
 }
 
 /***/ }),
-/* 1053 */
+/* 1054 */
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -147168,7 +148106,7 @@ function isNodeReflectsFirstChildColspan(node) {
 }
 
 /***/ }),
-/* 1054 */
+/* 1055 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -147231,7 +148169,7 @@ the last node, the hide column modification can be applied.`);
 }
 
 /***/ }),
-/* 1055 */
+/* 1056 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -147292,7 +148230,7 @@ the last node, the show column modification can be applied.`);
 }
 
 /***/ }),
-/* 1056 */
+/* 1057 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -147302,7 +148240,7 @@ exports.__esModule = true;
 exports.generateMatrix = generateMatrix;
 __webpack_require__(283);
 var _array = __webpack_require__(495);
-var _utils = __webpack_require__(1047);
+var _utils = __webpack_require__(1048);
 /* eslint-disable jsdoc/require-description-complete-sentence */
 
 /**
@@ -147398,7 +148336,7 @@ function createNestedArrayIfNecessary(array, index) {
 }
 
 /***/ }),
-/* 1057 */
+/* 1058 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -147554,20 +148492,20 @@ class GhostTable {
 var _default = exports["default"] = GhostTable;
 
 /***/ }),
-/* 1058 */
+/* 1059 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _nestedRows = __webpack_require__(1059);
+var _nestedRows = __webpack_require__(1060);
 exports.PLUGIN_KEY = _nestedRows.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _nestedRows.PLUGIN_PRIORITY;
 exports.NestedRows = _nestedRows.NestedRows;
 
 /***/ }),
-/* 1059 */
+/* 1060 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -147589,15 +148527,15 @@ __webpack_require__(329);
 __webpack_require__(530);
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
 var _base = __webpack_require__(841);
-var _dataManager = _interopRequireDefault(__webpack_require__(1060));
-var _collapsing = _interopRequireDefault(__webpack_require__(1061));
-var _headers = _interopRequireDefault(__webpack_require__(1063));
-var _contextMenu = _interopRequireDefault(__webpack_require__(1064));
+var _dataManager = _interopRequireDefault(__webpack_require__(1061));
+var _collapsing = _interopRequireDefault(__webpack_require__(1062));
+var _headers = _interopRequireDefault(__webpack_require__(1064));
+var _contextMenu = _interopRequireDefault(__webpack_require__(1065));
 var _console = __webpack_require__(512);
 var _data = __webpack_require__(622);
 var _translations = __webpack_require__(625);
 var _shortcutContexts = __webpack_require__(686);
-var _rowMoveController = _interopRequireDefault(__webpack_require__(1065));
+var _rowMoveController = _interopRequireDefault(__webpack_require__(1066));
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -148129,7 +149067,7 @@ function _onBeforeLoadData(data) {
 }
 
 /***/ }),
-/* 1060 */
+/* 1061 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -148760,7 +149698,7 @@ class DataManager {
    */
   syncRowWithRawSource(rowElement) {
     let upmostParent = rowElement;
-    let tempParent = null;
+    let tempParent = upmostParent;
     do {
       tempParent = this.getRowParent(tempParent);
       if (tempParent !== null) {
@@ -148768,7 +149706,7 @@ class DataManager {
       }
     } while (tempParent !== null);
     this.plugin.disableCoreAPIModifiers();
-    this.hot.setSourceDataAtCell(this.getRowIndex(upmostParent), '__children', upmostParent.__children, 'NestedRows.syncRowWithRawSource');
+    this.hot.setSourceDataAtCell(this.getRowIndexWithinParent(upmostParent), '__children', upmostParent.__children, 'NestedRows.syncRowWithRawSource');
     this.plugin.enableCoreAPIModifiers();
   }
 
@@ -148845,7 +149783,7 @@ class DataManager {
 var _default = exports["default"] = DataManager;
 
 /***/ }),
-/* 1061 */
+/* 1062 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -148858,8 +149796,8 @@ var _event = __webpack_require__(509);
 var _array = __webpack_require__(495);
 var _number = __webpack_require__(534);
 var _element = __webpack_require__(351);
-var _base = _interopRequireDefault(__webpack_require__(1062));
-var _headers = _interopRequireDefault(__webpack_require__(1063));
+var _base = _interopRequireDefault(__webpack_require__(1063));
+var _headers = _interopRequireDefault(__webpack_require__(1064));
 /**
  * Class responsible for the UI for collapsing and expanding groups.
  *
@@ -149320,7 +150258,7 @@ class CollapsingUI extends _base.default {
 var _default = exports["default"] = CollapsingUI;
 
 /***/ }),
-/* 1062 */
+/* 1063 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -149354,7 +150292,7 @@ class BaseUI {
 var _default = exports["default"] = BaseUI;
 
 /***/ }),
-/* 1063 */
+/* 1064 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -149365,7 +150303,7 @@ exports.__esModule = true;
 var _array = __webpack_require__(495);
 var _number = __webpack_require__(534);
 var _element = __webpack_require__(351);
-var _base = _interopRequireDefault(__webpack_require__(1062));
+var _base = _interopRequireDefault(__webpack_require__(1063));
 var _a11y = __webpack_require__(496);
 /**
  * Class responsible for the UI in the Nested Rows' row headers.
@@ -149498,7 +150436,7 @@ class HeadersUI extends _base.default {
 var _default = exports["default"] = HeadersUI;
 
 /***/ }),
-/* 1064 */
+/* 1065 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -149511,7 +150449,7 @@ var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
 var _number = __webpack_require__(534);
 var _array = __webpack_require__(495);
 var C = _interopRequireWildcard(__webpack_require__(651));
-var _base = _interopRequireDefault(__webpack_require__(1062));
+var _base = _interopRequireDefault(__webpack_require__(1063));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
@@ -149617,7 +150555,7 @@ class ContextMenuUI extends _base.default {
 var _default = exports["default"] = ContextMenuUI;
 
 /***/ }),
-/* 1065 */
+/* 1066 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -149906,20 +150844,20 @@ class RowMoveController {
 exports["default"] = RowMoveController;
 
 /***/ }),
-/* 1066 */
+/* 1067 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _persistentState = __webpack_require__(1067);
+var _persistentState = __webpack_require__(1068);
 exports.PLUGIN_KEY = _persistentState.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _persistentState.PLUGIN_PRIORITY;
 exports.PersistentState = _persistentState.PersistentState;
 
 /***/ }),
-/* 1067 */
+/* 1068 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -149929,7 +150867,7 @@ var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
 var _base = __webpack_require__(841);
-var _storage = _interopRequireDefault(__webpack_require__(1068));
+var _storage = _interopRequireDefault(__webpack_require__(1069));
 var _hooks = __webpack_require__(511);
 _hooks.Hooks.getSingleton().register('persistentStateSave');
 _hooks.Hooks.getSingleton().register('persistentStateLoad');
@@ -150070,7 +151008,7 @@ class PersistentState extends _base.BasePlugin {
 exports.PersistentState = PersistentState;
 
 /***/ }),
-/* 1068 */
+/* 1069 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -150194,20 +151132,20 @@ class Storage {
 var _default = exports["default"] = Storage;
 
 /***/ }),
-/* 1069 */
+/* 1070 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _search = __webpack_require__(1070);
+var _search = __webpack_require__(1071);
 exports.PLUGIN_KEY = _search.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _search.PLUGIN_PRIORITY;
 exports.Search = _search.Search;
 
 /***/ }),
-/* 1070 */
+/* 1071 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -150515,20 +151453,20 @@ function _onBeforeRenderer(TD, row, col, prop, value, cellProperties) {
 }
 
 /***/ }),
-/* 1071 */
+/* 1072 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _stretchColumns = __webpack_require__(1072);
+var _stretchColumns = __webpack_require__(1073);
 exports.PLUGIN_KEY = _stretchColumns.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _stretchColumns.PLUGIN_PRIORITY;
 exports.StretchColumns = _stretchColumns.StretchColumns;
 
 /***/ }),
-/* 1072 */
+/* 1073 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -150539,7 +151477,7 @@ __webpack_require__(201);
 __webpack_require__(311);
 __webpack_require__(329);
 var _base = __webpack_require__(841);
-var _calculator = __webpack_require__(1073);
+var _calculator = __webpack_require__(1074);
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -150596,6 +151534,19 @@ const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 155;
  * />
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * settings = {
+ *   data: getData(),
+ *   stretchH: "all",
+ * };
+ * ```
+ *
+ * ```html
+ * <hot-table [settings]="settings"></hot-table>
+ * ```
+ * :::
  */
 /* eslint-enable jsdoc/require-description-complete-sentence */
 var _stretchCalculator = /*#__PURE__*/new WeakMap();
@@ -150756,7 +151707,7 @@ function _onBeforeRender(fullRender) {
 }
 
 /***/ }),
-/* 1073 */
+/* 1074 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -150768,8 +151719,8 @@ __webpack_require__(311);
 __webpack_require__(329);
 var _src = __webpack_require__(540);
 var _element = __webpack_require__(351);
-var _all = __webpack_require__(1074);
-var _last = __webpack_require__(1076);
+var _all = __webpack_require__(1075);
+var _last = __webpack_require__(1077);
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -150924,7 +151875,7 @@ function _overwriteColumnWidthFn(columnWidth, columnVisualIndex) {
 }
 
 /***/ }),
-/* 1074 */
+/* 1075 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -150936,7 +151887,7 @@ __webpack_require__(311);
 __webpack_require__(329);
 __webpack_require__(530);
 var _src = __webpack_require__(540);
-var _base = __webpack_require__(1075);
+var _base = __webpack_require__(1076);
 /**
  * The strategy calculates the column widths by stretching all columns evenly.
  *
@@ -151001,7 +151952,7 @@ class StretchAllStrategy extends _base.StretchStrategy {
 exports.StretchAllStrategy = StretchAllStrategy;
 
 /***/ }),
-/* 1075 */
+/* 1076 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -151090,7 +152041,7 @@ class StretchStrategy {
 exports.StretchStrategy = StretchStrategy;
 
 /***/ }),
-/* 1076 */
+/* 1077 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -151100,7 +152051,7 @@ exports.__esModule = true;
 __webpack_require__(201);
 __webpack_require__(311);
 __webpack_require__(530);
-var _base = __webpack_require__(1075);
+var _base = __webpack_require__(1076);
 function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
@@ -151175,20 +152126,20 @@ class StretchLastStrategy extends _base.StretchStrategy {
 exports.StretchLastStrategy = StretchLastStrategy;
 
 /***/ }),
-/* 1077 */
+/* 1078 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _touchScroll = __webpack_require__(1078);
+var _touchScroll = __webpack_require__(1079);
 exports.PLUGIN_KEY = _touchScroll.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _touchScroll.PLUGIN_PRIORITY;
 exports.TouchScroll = _touchScroll.TouchScroll;
 
 /***/ }),
-/* 1078 */
+/* 1079 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -151377,20 +152328,20 @@ function _onAfterMomentumScroll() {
 }
 
 /***/ }),
-/* 1079 */
+/* 1080 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _trimRows = __webpack_require__(1080);
+var _trimRows = __webpack_require__(1081);
 exports.PLUGIN_KEY = _trimRows.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _trimRows.PLUGIN_PRIORITY;
 exports.TrimRows = _trimRows.TrimRows;
 
 /***/ }),
-/* 1080 */
+/* 1081 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -151505,6 +152456,67 @@ const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 330;
  * hot.render();
  * ```
  * :::
+ *
+ * ::: only-for angular
+ * ```ts
+ * import { AfterViewInit, Component, ViewChild } from "@angular/core";
+ * import {
+ *   GridSettings,
+ *   HotTableModule,
+ *   HotTableComponent,
+ * } from "@handsontable/angular-wrapper";
+ *
+ * `@Component`({
+ *   selector: "app-example",
+ *   standalone: true,
+ *   imports: [HotTableModule],
+ *   template: ` <div class="ht-theme-main">
+ *     <hot-table [settings]="gridSettings" />
+ *   </div>`,
+ * })
+ * export class ExampleComponent implements AfterViewInit {
+ *   `@ViewChild`(HotTableComponent, { static: false })
+ *   readonly hotTable!: HotTableComponent;
+ *
+ *   readonly gridSettings = <GridSettings>{
+ *     data: this.getData(),
+ *     // Hide selected rows on table initialization
+ *     trimRows: [1, 2, 5],
+ *   };
+ *
+ *   ngAfterViewInit(): void {
+ *     // Access the trimRows plugin instance
+ *     const hot = this.hotTable.hotInstance;
+ *     const trimRowsPlugin = hot.getPlugin("trimRows");
+ *
+ *     // Hide a single row
+ *     trimRowsPlugin.trimRow(1);
+ *
+ *     // Hide multiple rows
+ *     trimRowsPlugin.trimRow(1, 2, 9);
+ *
+ *     // Or as an array
+ *     trimRowsPlugin.trimRows([1, 2, 9]);
+ *
+ *     // Show a single row
+ *     trimRowsPlugin.untrimRow(1);
+ *
+ *     // Show multiple rows
+ *     trimRowsPlugin.untrimRow(1, 2, 9);
+ *
+ *     // Or as an array
+ *     trimRowsPlugin.untrimRows([1, 2, 9]);
+ *
+ *     // Re-render table to see the changes
+ *     hot.render();
+ *   }
+ *
+ *   private getData(): any[] {
+ *     // Get some data
+ *   }
+ * }
+ * ```
+ * :::
  */
 var _TrimRows_brand = /*#__PURE__*/new WeakSet();
 class TrimRows extends _base.BasePlugin {
@@ -151722,20 +152734,20 @@ function _onMapInit() {
 }
 
 /***/ }),
-/* 1081 */
+/* 1082 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 
 exports.__esModule = true;
-var _undoRedo = __webpack_require__(1082);
+var _undoRedo = __webpack_require__(1083);
 exports.PLUGIN_KEY = _undoRedo.PLUGIN_KEY;
 exports.PLUGIN_PRIORITY = _undoRedo.PLUGIN_PRIORITY;
 exports.UndoRedo = _undoRedo.UndoRedo;
 
 /***/ }),
-/* 1082 */
+/* 1083 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -151758,7 +152770,7 @@ var _hooks = __webpack_require__(511);
 var _object = __webpack_require__(499);
 var _templateLiteralTag = __webpack_require__(494);
 var _console = __webpack_require__(512);
-var _actions = __webpack_require__(1083);
+var _actions = __webpack_require__(1084);
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
 function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
 function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
@@ -152128,7 +153140,7 @@ function _removeAPIFromCore() {
 }
 
 /***/ }),
-/* 1083 */
+/* 1084 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152138,18 +153150,18 @@ exports.__esModule = true;
 exports.registerActions = registerActions;
 __webpack_require__(311);
 __webpack_require__(329);
-var _cellAlignment = __webpack_require__(1084);
-var _columnMove = __webpack_require__(1086);
-var _columnSort = __webpack_require__(1087);
-var _createColumn = __webpack_require__(1088);
-var _createRow = __webpack_require__(1089);
-var _dataChange = __webpack_require__(1090);
-var _filters = __webpack_require__(1091);
-var _mergeCells = __webpack_require__(1092);
-var _removeColumn = __webpack_require__(1093);
-var _removeRow = __webpack_require__(1096);
-var _rowMove = __webpack_require__(1097);
-var _unmergeCells = __webpack_require__(1098);
+var _cellAlignment = __webpack_require__(1085);
+var _columnMove = __webpack_require__(1087);
+var _columnSort = __webpack_require__(1088);
+var _createColumn = __webpack_require__(1089);
+var _createRow = __webpack_require__(1090);
+var _dataChange = __webpack_require__(1091);
+var _filters = __webpack_require__(1092);
+var _mergeCells = __webpack_require__(1093);
+var _removeColumn = __webpack_require__(1094);
+var _removeRow = __webpack_require__(1097);
+var _rowMove = __webpack_require__(1098);
+var _unmergeCells = __webpack_require__(1099);
 /**
  * Register all undo/redo actions.
  *
@@ -152161,7 +153173,7 @@ function registerActions(hot, undoRedoPlugin) {
 }
 
 /***/ }),
-/* 1084 */
+/* 1085 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152170,7 +153182,7 @@ function registerActions(hot, undoRedoPlugin) {
 var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 var _utils = __webpack_require__(881);
 var _array = __webpack_require__(495);
 /**
@@ -152250,7 +153262,7 @@ class CellAlignmentAction extends _base.BaseAction {
 exports.CellAlignmentAction = CellAlignmentAction;
 
 /***/ }),
-/* 1085 */
+/* 1086 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152284,7 +153296,7 @@ class BaseAction {
 exports.BaseAction = BaseAction;
 
 /***/ }),
-/* 1086 */
+/* 1087 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152295,7 +153307,7 @@ exports.__esModule = true;
 __webpack_require__(311);
 __webpack_require__(329);
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 var _moves = __webpack_require__(995);
 /**
  * Action that tracks column move changes.
@@ -152372,7 +153384,7 @@ class ColumnMoveAction extends _base.BaseAction {
 exports.ColumnMoveAction = ColumnMoveAction;
 
 /***/ }),
-/* 1087 */
+/* 1088 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152381,7 +153393,7 @@ exports.ColumnMoveAction = ColumnMoveAction;
 var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 /**
  * Action that tracks column sort changes.
  *
@@ -152449,7 +153461,7 @@ class ColumnSortAction extends _base.BaseAction {
 exports.ColumnSortAction = ColumnSortAction;
 
 /***/ }),
-/* 1088 */
+/* 1089 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152458,7 +153470,7 @@ exports.ColumnSortAction = ColumnSortAction;
 var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 /**
  * Action that tracks column creation.
  *
@@ -152513,7 +153525,7 @@ class CreateColumnAction extends _base.BaseAction {
 exports.CreateColumnAction = CreateColumnAction;
 
 /***/ }),
-/* 1089 */
+/* 1090 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152522,7 +153534,7 @@ exports.CreateColumnAction = CreateColumnAction;
 var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 /**
  * Action that tracks row creation.
  *
@@ -152582,7 +153594,7 @@ class CreateRowAction extends _base.BaseAction {
 exports.CreateRowAction = CreateRowAction;
 
 /***/ }),
-/* 1090 */
+/* 1091 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152596,7 +153608,7 @@ __webpack_require__(519);
 __webpack_require__(329);
 __webpack_require__(530);
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 var _object = __webpack_require__(499);
 /**
  * Action that tracks data changes.
@@ -152709,7 +153721,7 @@ class DataChangeAction extends _base.BaseAction {
 exports.DataChangeAction = DataChangeAction;
 
 /***/ }),
-/* 1091 */
+/* 1092 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152720,7 +153732,7 @@ exports.__esModule = true;
 __webpack_require__(311);
 __webpack_require__(323);
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 /**
  * Action that tracks filter changes.
  *
@@ -152779,7 +153791,7 @@ class FiltersAction extends _base.BaseAction {
 exports.FiltersAction = FiltersAction;
 
 /***/ }),
-/* 1092 */
+/* 1093 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152788,7 +153800,7 @@ exports.FiltersAction = FiltersAction;
 var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 /**
  * Action that tracks changes in merged cells.
  *
@@ -152849,7 +153861,7 @@ class MergeCellsAction extends _base.BaseAction {
 exports.MergeCellsAction = MergeCellsAction;
 
 /***/ }),
-/* 1093 */
+/* 1094 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -152861,8 +153873,8 @@ __webpack_require__(283);
 __webpack_require__(311);
 __webpack_require__(329);
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
-var _utils = __webpack_require__(1094);
+var _base = __webpack_require__(1086);
+var _utils = __webpack_require__(1095);
 var _number = __webpack_require__(534);
 var _array = __webpack_require__(495);
 /**
@@ -152890,7 +153902,7 @@ class RemoveColumnAction extends _base.BaseAction {
      */
     (0, _defineProperty2.default)(this, "index", void 0);
     /**
-     * @param {number[]} indexes The visual column indexes.
+     * @param {number[]} indexes The physical column indexes.
      */
     (0, _defineProperty2.default)(this, "indexes", void 0);
     /**
@@ -152956,16 +153968,14 @@ class RemoveColumnAction extends _base.BaseAction {
             headers.push(hot.getSettings().colHeaders[hot.toPhysicalColumn(columnIndex + i)] || null);
           });
         }
-        const columnsMap = hot.columnIndexMapper.getIndexesSequence();
-        const rowsMap = hot.rowIndexMapper.getIndexesSequence();
         return new RemoveColumnAction({
           index: columnIndex,
           indexes,
           data: removedData,
           amount,
           headers,
-          columnPositions: columnsMap,
-          rowPositions: rowsMap,
+          columnPositions: hot.columnIndexMapper.getIndexesSequence(),
+          rowPositions: hot.rowIndexMapper.getIndexesSequence(),
           fixedColumnsStart: hot.getSettings().fixedColumnsStart,
           removedCellMetas: (0, _utils.getCellMetas)(hot, 0, hot.countRows(), columnIndex, lastColumnIndex)
         });
@@ -152992,14 +154002,27 @@ class RemoveColumnAction extends _base.BaseAction {
     }
     const sortedHeaders = (0, _array.arrayMap)(this.headers, sortByIndexes);
     const changes = [];
-    hot.alter('insert_col_start', this.indexes[0], this.indexes.length, 'UndoRedo.undo');
+
+    // The indexes sequence have to be applied twice.
+    //  * First for proper index translation. The alter method accepts a visual index
+    //    and we are able to retrieve the correct index indicating where to add a new row based
+    //    only on the previous order state of the columns;
+    //  * The alter method shifts the indexes (a side-effect), so we need to reapply the indexes sequence
+    //    the same as it was in the previous state;
+    hot.columnIndexMapper.setIndexesSequence(this.columnPositions);
+    hot.alter('insert_col_start', hot.toVisualColumn(this.indexes[0]), this.indexes.length, 'UndoRedo.undo');
+    hot.batchExecution(() => {
+      // Restore row sequence in a case when all columns are removed. the original
+      // row sequence is lost in that case.
+      hot.rowIndexMapper.setIndexesSequence(this.rowPositions);
+      hot.columnIndexMapper.setIndexesSequence(this.columnPositions);
+    }, true);
     (0, _array.arrayEach)(hot.getSourceDataArray(), (rowData, rowIndex) => {
       (0, _array.arrayEach)(ascendingIndexes, (changedIndex, contiquesIndex) => {
         rowData[changedIndex] = sortedData[rowIndex][contiquesIndex];
         changes.push([rowIndex, changedIndex, rowData[changedIndex]]);
       });
     });
-    hot.setSourceDataAtCell(changes, undefined, undefined, 'UndoRedo.undo');
     if (typeof this.headers !== 'undefined') {
       (0, _array.arrayEach)(sortedHeaders, (headerData, columnIndex) => {
         hot.getSettings().colHeaders[ascendingIndexes[columnIndex]] = headerData;
@@ -153009,14 +154032,8 @@ class RemoveColumnAction extends _base.BaseAction {
       let [rowIndex, columnIndex, cellMeta] = _ref2;
       hot.setCellMetaObject(rowIndex, columnIndex, cellMeta);
     });
-    hot.batchExecution(() => {
-      // Restore row sequence in a case when all columns are removed. the original
-      // row sequence is lost in that case.
-      hot.rowIndexMapper.setIndexesSequence(this.rowPositions);
-      hot.columnIndexMapper.setIndexesSequence(this.columnPositions);
-    }, true);
     hot.addHookOnce('afterViewRender', undoneCallback);
-    hot.render();
+    hot.setSourceDataAtCell(changes, null, null, 'UndoRedo.undo');
   }
 
   /**
@@ -153031,7 +154048,7 @@ class RemoveColumnAction extends _base.BaseAction {
 exports.RemoveColumnAction = RemoveColumnAction;
 
 /***/ }),
-/* 1094 */
+/* 1095 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -153040,7 +154057,7 @@ exports.RemoveColumnAction = RemoveColumnAction;
 exports.__esModule = true;
 exports.getCellMetas = getCellMetas;
 __webpack_require__(283);
-__webpack_require__(1095);
+__webpack_require__(1096);
 __webpack_require__(311);
 __webpack_require__(323);
 var _number = __webpack_require__(534);
@@ -153074,7 +154091,7 @@ function getCellMetas(hot, fromRow, toRow, fromColumn, toColumn) {
 }
 
 /***/ }),
-/* 1095 */
+/* 1096 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
@@ -153097,7 +154114,7 @@ $({ target: 'Object', stat: true }, {
 
 
 /***/ }),
-/* 1096 */
+/* 1097 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -153109,8 +154126,8 @@ __webpack_require__(283);
 __webpack_require__(311);
 __webpack_require__(329);
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
-var _utils = __webpack_require__(1094);
+var _base = __webpack_require__(1086);
+var _utils = __webpack_require__(1095);
 var _object = __webpack_require__(499);
 /**
  * Action that tracks changes in row removal.
@@ -153130,7 +154147,7 @@ class RemoveRowAction extends _base.BaseAction {
     } = _ref;
     super('remove_row');
     /**
-     * @param {number} index The visual row index.
+     * @param {number} index The physical row index.
      */
     (0, _defineProperty2.default)(this, "index", void 0);
     /**
@@ -153198,14 +154215,22 @@ class RemoveRowAction extends _base.BaseAction {
         changes.push([this.index + rowIndexDelta, isNaN(columnIndex) ? columnProp : columnIndex, dataRow[columnProp]]);
       });
     });
-    hot.alter('insert_row_above', this.index, this.data.length, 'UndoRedo.undo');
+
+    // The indexes sequence have to be applied twice.
+    //  * First for proper index translation. The alter method accepts a visual index
+    //    and we are able to retrieve the correct index indicating where to add a new row based
+    //    only on the previous order state of the rows;
+    //  * The alter method shifts the indexes (a side-effect), so we need to reapply the indexes sequence
+    //    the same as it was in the previous state;
+    hot.rowIndexMapper.setIndexesSequence(this.rowIndexesSequence);
+    hot.alter('insert_row_above', hot.toVisualRow(this.index), this.data.length, 'UndoRedo.undo');
+    hot.rowIndexMapper.setIndexesSequence(this.rowIndexesSequence);
     this.removedCellMetas.forEach(_ref2 => {
       let [rowIndex, columnIndex, cellMeta] = _ref2;
       hot.setCellMetaObject(rowIndex, columnIndex, cellMeta);
     });
     hot.addHookOnce('afterViewRender', undoneCallback);
     hot.setSourceDataAtCell(changes, null, null, 'UndoRedo.undo');
-    hot.rowIndexMapper.setIndexesSequence(this.rowIndexesSequence);
   }
 
   /**
@@ -153214,13 +154239,13 @@ class RemoveRowAction extends _base.BaseAction {
    */
   redo(hot, redoneCallback) {
     hot.addHookOnce('afterRemoveRow', redoneCallback);
-    hot.alter('remove_row', this.index, this.data.length, 'UndoRedo.redo');
+    hot.alter('remove_row', hot.toVisualRow(this.index), this.data.length, 'UndoRedo.redo');
   }
 }
 exports.RemoveRowAction = RemoveRowAction;
 
 /***/ }),
-/* 1097 */
+/* 1098 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -153231,7 +154256,7 @@ exports.__esModule = true;
 __webpack_require__(311);
 __webpack_require__(329);
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 var _moves = __webpack_require__(995);
 /**
  * Action that tracks row move changes.
@@ -153308,7 +154333,7 @@ class RowMoveAction extends _base.BaseAction {
 exports.RowMoveAction = RowMoveAction;
 
 /***/ }),
-/* 1098 */
+/* 1099 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
@@ -153317,7 +154342,7 @@ exports.RowMoveAction = RowMoveAction;
 var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
 var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
-var _base = __webpack_require__(1085);
+var _base = __webpack_require__(1086);
 /**
  * Action that tracks changes in merged cells.
  *
@@ -153371,7 +154396,7 @@ class UnmergeCellsAction extends _base.BaseAction {
 exports.UnmergeCellsAction = UnmergeCellsAction;
 
 /***/ }),
-/* 1099 */
+/* 1100 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";