handsontable 0.0.0-next-8951d31-20250210 → 0.0.0-next-508ffe1-20250211

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-8951d31-20250210
- * Release date: 16/12/2024 (built at 10/02/2025 11:00:22)
+ * Version: 0.0.0-next-508ffe1-20250211
+ * Release date: 16/12/2024 (built at 11/02/2025 09:50:32)
  */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
@@ -42855,8 +42855,8 @@ Handsontable.hooks = _hooks.Hooks.getSingleton();
 Handsontable.CellCoords = _src.CellCoords;
 Handsontable.CellRange = _src.CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "10/02/2025 11:00:22";
-Handsontable.version = "0.0.0-next-8951d31-20250210";
+Handsontable.buildDate = "11/02/2025 09:50:32";
+Handsontable.version = "0.0.0-next-508ffe1-20250211";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,
@@ -46374,7 +46374,33 @@ function Core(rootElement, userSettings) {
    * @returns {number}
    */
   this._getColWidthFromSettings = function (col) {
-    return tableMeta.colWidths[col];
+    let width;
+
+    // We currently don't support cell meta objects for headers (negative values)
+    if (col >= 0) {
+      const cellProperties = instance.getCellMeta(0, col);
+      width = cellProperties.width;
+    }
+    if (width === undefined || width === tableMeta.width) {
+      width = tableMeta.colWidths;
+    }
+    if (width !== undefined && width !== null) {
+      switch (typeof width) {
+        case 'object':
+          // array
+          width = width[col];
+          break;
+        case 'function':
+          width = width(col);
+          break;
+        default:
+          break;
+      }
+      if (typeof width === 'string') {
+        width = parseInt(width, 10);
+      }
+    }
+    return width;
   };
 
   /**
@@ -46388,7 +46414,12 @@ function Core(rootElement, userSettings) {
    * @fires Hooks#modifyColWidth
    */
   this.getColWidth = function (column, source) {
-    return instance._getColWidthFromSettings(column);
+    let width = instance._getColWidthFromSettings(column);
+    width = instance.runHooks('modifyColWidth', width, column, source);
+    if (width === undefined) {
+      width = _src.DEFAULT_COLUMN_WIDTH;
+    }
+    return width;
   };
 
   /**
@@ -46401,7 +46432,24 @@ function Core(rootElement, userSettings) {
    * @returns {number}
    */
   this._getRowHeightFromSettings = function (row) {
-    return tableMeta.rowHeights;
+    let height = tableMeta.rowHeights;
+    if (height !== undefined && height !== null) {
+      switch (typeof height) {
+        case 'object':
+          // array
+          height = height[row];
+          break;
+        case 'function':
+          height = height(row);
+          break;
+        default:
+          break;
+      }
+      if (typeof height === 'string') {
+        height = parseInt(height, 10);
+      }
+    }
+    return height;
   };
 
   /**
@@ -46432,7 +46480,9 @@ function Core(rootElement, userSettings) {
    * @fires Hooks#modifyRowHeight
    */
   this.getRowHeight = function (row, source) {
-    return instance._getRowHeightFromSettings(row);
+    let height = instance._getRowHeightFromSettings(row);
+    height = instance.runHooks('modifyRowHeight', height, row, source);
+    return height;
   };
 
   /**
@@ -52659,7 +52709,7 @@ function sanitize(string, options) {
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
-/*! @license DOMPurify 3.2.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.3/LICENSE */
+/*! @license DOMPurify 3.2.4 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.4/LICENSE */
 
 
 
@@ -52700,8 +52750,10 @@ if (!construct) {
   };
 }
 const arrayForEach = unapply(Array.prototype.forEach);
+const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
 const arrayPop = unapply(Array.prototype.pop);
 const arrayPush = unapply(Array.prototype.push);
+const arraySplice = unapply(Array.prototype.splice);
 const stringToLowerCase = unapply(String.prototype.toLowerCase);
 const stringToString = unapply(String.prototype.toString);
 const stringMatch = unapply(String.prototype.match);
@@ -52857,7 +52909,7 @@ const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:x
 // eslint-disable-next-line unicorn/better-regex
 const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
 const ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
-const TMPLIT_EXPR = seal(/\$\{[\w\W]*}/gm); // eslint-disable-line unicorn/better-regex
+const TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm); // eslint-disable-line unicorn/better-regex
 const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/); // eslint-disable-line no-useless-escape
 const ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
 const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
@@ -52957,9 +53009,9 @@ const _createHooksMap = function _createHooksMap() {
 function createDOMPurify() {
   let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
   const DOMPurify = root => createDOMPurify(root);
-  DOMPurify.version = '3.2.3';
+  DOMPurify.version = '3.2.4';
   DOMPurify.removed = [];
-  if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document) {
+  if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
     // Not running in a browser, provide a factory function
     // so that you can pass your own Window
     DOMPurify.isSupported = false;
@@ -53978,7 +54030,11 @@ function createDOMPurify() {
     }
     arrayPush(hooks[entryPoint], hookFunction);
   };
-  DOMPurify.removeHook = function (entryPoint) {
+  DOMPurify.removeHook = function (entryPoint, hookFunction) {
+    if (hookFunction !== undefined) {
+      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+      return index === -1 ? undefined : arraySplice(hooks[entryPoint], index, 1)[0];
+    }
     return arrayPop(hooks[entryPoint]);
   };
   DOMPurify.removeHooks = function (entryPoint) {
@@ -54139,7 +54195,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-8951d31-20250210";
+  const hotVersion = "0.0.0-next-508ffe1-20250211";
   let keyValidityDate;
   let consoleMessageState = 'invalid';
   let domMessageState = 'invalid';
@@ -71271,7 +71327,11 @@ class ViewportColumnsCalculator extends _viewportBase.ViewportBaseCalculator {
    * @returns {number}
    */
   getColumnWidth(column) {
-    return this.columnWidthFn(column);
+    const width = this.columnWidthFn(column);
+    if (isNaN(width)) {
+      return DEFAULT_WIDTH;
+    }
+    return width;
   }
 }
 exports.ViewportColumnsCalculator = ViewportColumnsCalculator;
@@ -71466,7 +71526,11 @@ class ViewportRowsCalculator extends _viewportBase.ViewportBaseCalculator {
    * @returns {number}
    */
   getRowHeight(row) {
-    return this.rowHeightFn(row);
+    const rowHeight = this.rowHeightFn(row);
+    if (isNaN(rowHeight)) {
+      return this.defaultHeight;
+    }
+    return rowHeight;
   }
 }
 exports.ViewportRowsCalculator = ViewportRowsCalculator;
@@ -74452,6 +74516,16 @@ class Table {
         this.resetOversizedRows();
         this.tableRenderer.setActiveOverlayName(this.name).setViewportSize(this.getRenderedRowsCount(), this.getRenderedColumnsCount()).setFilters(this.rowFilter, this.columnFilter).render();
         if (this.isMaster) {
+          this.markOversizedColumnHeaders();
+        }
+        this.adjustColumnHeaderHeights();
+        if (this.isMaster || this.is(_overlay.CLONE_BOTTOM)) {
+          this.markOversizedRows();
+        }
+        if (this.isMaster) {
+          if (!this.wtSettings.getSetting('externalRowCalculator')) {
+            wtViewport.createVisibleCalculators();
+          }
           wtOverlays.refresh(false);
           wtOverlays.applyToDOM();
           this.wtSettings.getSetting('onDraw', true);
@@ -74493,18 +74567,85 @@ class Table {
   /**
    * @param {number} col The visual column index.
    */
-  markIfOversizedColumnHeader(col) {}
+  markIfOversizedColumnHeader(col) {
+    const sourceColIndex = this.columnFilter.renderedToSource(col);
+    let level = this.wtSettings.getSetting('columnHeaders').length;
+    const defaultRowHeight = this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    let previousColHeaderHeight;
+    let currentHeader;
+    let currentHeaderHeight;
+    const columnHeaderHeightSetting = this.wtSettings.getSetting('columnHeaderHeight') || [];
+    while (level) {
+      level -= 1;
+      previousColHeaderHeight = this.getColumnHeaderHeight(level);
+      currentHeader = this.getColumnHeader(sourceColIndex, level);
+      if (!currentHeader) {
+        /* eslint-disable no-continue */
+        continue;
+      }
+      currentHeaderHeight = (0, _element.innerHeight)(currentHeader);
+      if (!previousColHeaderHeight && defaultRowHeight < currentHeaderHeight || previousColHeaderHeight < currentHeaderHeight) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = currentHeaderHeight;
+      }
+      if (Array.isArray(columnHeaderHeightSetting)) {
+        if (columnHeaderHeightSetting[level] !== null && columnHeaderHeightSetting[level] !== undefined) {
+          this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level];
+        }
+      } else if (!isNaN(columnHeaderHeightSetting)) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting;
+      }
+      if (this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) {
+        this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting; // eslint-disable-line max-len
+      }
+    }
+  }
 
   /**
    *
    */
-  adjustColumnHeaderHeights() {}
+  adjustColumnHeaderHeights() {
+    const {
+      wtSettings
+    } = this;
+    const children = this.THEAD.childNodes;
+    const oversizedColumnHeaders = this.dataAccessObject.wtViewport.oversizedColumnHeaders;
+    const columnHeaders = wtSettings.getSetting('columnHeaders');
+    for (let i = 0, len = columnHeaders.length; i < len; i++) {
+      if (oversizedColumnHeaders[i]) {
+        if (!children[i] || children[i].childNodes.length === 0) {
+          return;
+        }
+        children[i].childNodes[0].style.height = `${oversizedColumnHeaders[i]}px`;
+      }
+    }
+  }
 
   /**
    * Resets cache of row heights. The cache should be cached for each render cycle in a case
    * when new cell values have content which increases/decreases cell height.
    */
-  resetOversizedRows() {}
+  resetOversizedRows() {
+    const {
+      wtSettings
+    } = this;
+    const {
+      wtViewport
+    } = this.dataAccessObject;
+    if (!this.isMaster && !this.is(_overlay.CLONE_BOTTOM)) {
+      return;
+    }
+    if (!wtSettings.getSetting('externalRowCalculator')) {
+      const rowsToRender = this.getRenderedRowsCount();
+
+      // Reset the oversized row cache for rendered rows
+      for (let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
+        const sourceRow = this.rowFilter.renderedToSource(visibleRowIndex);
+        if (wtViewport.oversizedRows && wtViewport.oversizedRows[sourceRow]) {
+          wtViewport.oversizedRows[sourceRow] = undefined;
+        }
+      }
+    }
+  }
 
   /**
    * Get cell element at coords.
@@ -74702,7 +74843,46 @@ class Table {
   /**
    * Check if any of the rendered rows is higher than expected, and if so, cache them.
    */
-  markOversizedRows() {}
+  markOversizedRows() {
+    if (this.wtSettings.getSetting('externalRowCalculator')) {
+      return;
+    }
+    let rowCount = this.TBODY.childNodes.length;
+    const expectedTableHeight = rowCount * this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    const actualTableHeight = (0, _element.innerHeight)(this.TBODY) - 1;
+    const borderBoxSizing = this.wot.stylesHandler.areCellsBorderBox();
+    const rowHeightFn = borderBoxSizing ? _element.outerHeight : _element.innerHeight;
+    const borderCompensation = borderBoxSizing ? 0 : 1;
+    const firstRowBorderCompensation = borderBoxSizing ? 1 : 0;
+    let previousRowHeight;
+    let rowCurrentHeight;
+    let sourceRowIndex;
+    let currentTr;
+    let rowHeader;
+    if (expectedTableHeight === actualTableHeight && !this.wtSettings.getSetting('fixedRowsBottom')) {
+      // If the actual table height equals rowCount * default single row height, no row is oversized -> no need to iterate over them
+      return;
+    }
+    while (rowCount) {
+      rowCount -= 1;
+      sourceRowIndex = this.rowFilter.renderedToSource(rowCount);
+      previousRowHeight = this.getRowHeight(sourceRowIndex);
+      currentTr = this.getTrForRow(sourceRowIndex);
+      rowHeader = currentTr.querySelector('th');
+      const topBorderCompensation = sourceRowIndex === 0 ? firstRowBorderCompensation : 0;
+      if (rowHeader) {
+        rowCurrentHeight = rowHeightFn(rowHeader);
+      } else {
+        rowCurrentHeight = rowHeightFn(currentTr) - borderCompensation;
+      }
+      if (!previousRowHeight && this.dataAccessObject.stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight < rowCurrentHeight) {
+        if (!borderBoxSizing) {
+          rowCurrentHeight += 1;
+        }
+        this.dataAccessObject.wtViewport.oversizedRows[sourceRowIndex] = rowCurrentHeight;
+      }
+    }
+  }
 
   /**
    * @param {number} row The visual row index.
@@ -75017,7 +75197,32 @@ class Table {
    * @returns {number}
    */
   _modifyRowHeaderWidth(rowHeaderWidthFactory) {
-    return 50;
+    let widths = (0, _function.isFunction)(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null;
+    if (Array.isArray(widths)) {
+      widths = [...widths];
+      widths[widths.length - 1] = this._correctRowHeaderWidth(widths[widths.length - 1]);
+    } else {
+      widths = this._correctRowHeaderWidth(widths);
+    }
+    return widths;
+  }
+
+  /**
+   * Correct row header width if necessary.
+   *
+   * @private
+   * @param {number} width The width to process.
+   * @returns {number}
+   */
+  _correctRowHeaderWidth(width) {
+    let rowHeaderWidth = width;
+    if (typeof width !== 'number') {
+      rowHeaderWidth = this.wtSettings.getSetting('defaultColumnWidth');
+    }
+    if (this.correctHeaderWidth) {
+      rowHeaderWidth += 1;
+    }
+    return rowHeaderWidth;
   }
 }
 var _default = exports["default"] = Table;
@@ -75430,9 +75635,6 @@ class RowHeadersRenderer extends _base.BaseRenderer {
       for (let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) {
         orderView.render();
         const TH = orderView.getCurrentNode();
-        if (TH.innerHTML !== '') {
-          continue;
-        }
         TH.className = '';
         TH.removeAttribute('style');
 
@@ -76378,7 +76580,7 @@ var _a11y = __webpack_require__(496);
  */
 class ColumnHeadersRenderer extends _base.BaseRenderer {
   constructor(rootNode) {
-    super('TR', rootNode); // NodePool is not implemented for this renderer yet
+    super(null, rootNode); // NodePool is not implemented for this renderer yet
   }
 
   /**
@@ -76446,9 +76648,6 @@ class ColumnHeadersRenderer extends _base.BaseRenderer {
         // eslint-disable-line max-len
         const sourceColumnIndex = this.table.renderedColumnToSource(renderedColumnIndex);
         const TH = TR.childNodes[renderedColumnIndex + rowHeadersCount];
-        if (TH.innerHTML !== '') {
-          continue;
-        }
         TH.className = '';
         TH.removeAttribute('style');
 
@@ -76739,14 +76938,11 @@ class CellsRenderer extends _base.BaseRenderer {
       this.sourceRowIndex = sourceRowIndex;
       const orderView = this.obtainOrderView(TR);
       const rowHeadersView = rowHeaders.obtainOrderView(TR);
-      orderView.prependView(rowHeadersView).setSize(columnsToRender).setOffset(this.table.renderedColumnToSource(0)).start();
+      orderView.prependView(rowHeadersView).setSize(columnsToRender).setOffset(0).start();
       for (let visibleColumnIndex = 0; visibleColumnIndex < columnsToRender; visibleColumnIndex++) {
         orderView.render();
         const sourceColumnIndex = this.table.renderedColumnToSource(visibleColumnIndex);
         const TD = orderView.getCurrentNode();
-        if (TD.innerHTML !== '') {
-          continue;
-        }
         if (!(0, _element.hasClass)(TD, 'hide')) {
           // Workaround for hidden columns plugin
           TD.className = '';
@@ -77156,7 +77352,8 @@ class ColumnUtils {
    * @returns {number}
    */
   getWidth(sourceIndex) {
-    return this.wtSettings.getSetting('columnWidth', sourceIndex);
+    const width = this.wtSettings.getSetting('columnWidth', sourceIndex) || this.wtSettings.getSetting('defaultColumnWidth');
+    return width;
   }
 
   /**
@@ -77166,7 +77363,12 @@ class ColumnUtils {
    * @returns {number}
    */
   getHeaderHeight(level) {
-    return this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    let height = this.dataAccessObject.stylesHandler.getDefaultRowHeight();
+    const oversizedHeight = this.dataAccessObject.wtViewport.oversizedColumnHeaders[level];
+    if (oversizedHeight !== undefined) {
+      height = height ? Math.max(height, oversizedHeight) : oversizedHeight;
+    }
+    return height;
   }
 
   /**
@@ -77176,13 +77378,28 @@ class ColumnUtils {
    * @returns {number}
    */
   getHeaderWidth(sourceIndex) {
-    return 50;
+    return this.headerWidths.get(this.dataAccessObject.wtTable.columnFilter.sourceToRendered(sourceIndex));
   }
 
   /**
    * Calculates column header widths that can be retrieved from the cache.
    */
-  calculateWidths() {}
+  calculateWidths() {
+    const {
+      wtSettings
+    } = this;
+    let rowHeaderWidthSetting = wtSettings.getSetting('rowHeaderWidth');
+    rowHeaderWidthSetting = wtSettings.getSetting('onModifyRowHeaderWidth', rowHeaderWidthSetting);
+    if (rowHeaderWidthSetting !== null && rowHeaderWidthSetting !== undefined) {
+      const rowHeadersCount = wtSettings.getSetting('rowHeaders').length;
+      const defaultColumnWidth = wtSettings.getSetting('defaultColumnWidth');
+      for (let visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) {
+        let width = Array.isArray(rowHeaderWidthSetting) ? rowHeaderWidthSetting[visibleColumnIndex] : rowHeaderWidthSetting;
+        width = width === null || width === undefined ? defaultColumnWidth : width;
+        this.headerWidths.set(visibleColumnIndex, width);
+      }
+    }
+  }
 }
 exports["default"] = ColumnUtils;
 
@@ -77226,7 +77443,12 @@ class RowUtils {
    * @returns {number}
    */
   getHeight(sourceIndex) {
-    return this.wtSettings.getSetting('rowHeight', sourceIndex);
+    let height = this.wtSettings.getSetting('rowHeight', sourceIndex);
+    const oversizedHeight = this.dataAccessObject.wtViewport.oversizedRows[sourceIndex];
+    if (oversizedHeight !== undefined) {
+      height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
+    }
+    return height;
   }
 
   /**
@@ -77237,7 +77459,12 @@ class RowUtils {
    * @returns {number}
    */
   getHeightByOverlayName(sourceIndex, overlayName) {
-    return this.wtSettings.getSetting('rowHeight', sourceIndex);
+    let height = this.wtSettings.getSetting('rowHeightByOverlayName', sourceIndex, overlayName);
+    const oversizedHeight = this.dataAccessObject.wtViewport.oversizedRows[sourceIndex];
+    if (oversizedHeight !== undefined) {
+      height = height === undefined ? oversizedHeight : Math.max(height, oversizedHeight);
+    }
+    return height;
   }
 }
 exports["default"] = RowUtils;
@@ -79234,7 +79461,14 @@ class InlineStartOverlay extends _base.Overlay {
    * @returns {number} Width sum.
    */
   sumCellSizes(from, to) {
-    return (to - from) * 80;
+    const defaultColumnWidth = this.wtSettings.getSetting('defaultColumnWidth');
+    let column = from;
+    let sum = 0;
+    while (column < to) {
+      sum += this.wot.wtTable.getColumnWidth(column) || defaultColumnWidth;
+      column += 1;
+    }
+    return sum;
   }
 
   /**
@@ -81617,7 +81851,15 @@ class TopOverlay extends _base.Overlay {
    * @returns {number} Height sum.
    */
   sumCellSizes(from, to) {
-    return (to - from) * 29;
+    const defaultRowHeight = this.wot.stylesHandler.getDefaultRowHeight();
+    let row = from;
+    let sum = 0;
+    while (row < to) {
+      const height = this.wot.wtTable.getRowHeight(row);
+      sum += height === undefined ? defaultRowHeight : height;
+      row += 1;
+    }
+    return sum;
   }
 
   /**
@@ -82330,6 +82572,7 @@ class Viewport {
     this.domBindings = domBindings;
     this.wtSettings = wtSettings;
     this.wtTable = wtTable;
+    this.oversizedRows = [];
     this.oversizedColumnHeaders = [];
     this.hasOversizedColumnHeadersMarked = {};
     this.clientHeight = 0;
@@ -82484,14 +82727,47 @@ class Viewport {
    * @returns {number}
    */
   getColumnHeaderHeight() {
-    return 59;
+    const columnHeaders = this.wtSettings.getSetting('columnHeaders');
+    if (!columnHeaders.length) {
+      this.columnHeaderHeight = 0;
+    } else if (isNaN(this.columnHeaderHeight)) {
+      this.columnHeaderHeight = (0, _element.outerHeight)(this.wtTable.THEAD);
+    }
+    return this.columnHeaderHeight;
   }
 
   /**
    * @returns {number}
    */
   getRowHeaderWidth() {
-    return 50;
+    const rowHeadersWidthSetting = this.wtSettings.getSetting('rowHeaderWidth');
+    const rowHeaders = this.wtSettings.getSetting('rowHeaders');
+    if (rowHeadersWidthSetting) {
+      this.rowHeaderWidth = 0;
+      for (let i = 0, len = rowHeaders.length; i < len; i++) {
+        this.rowHeaderWidth += rowHeadersWidthSetting[i] || rowHeadersWidthSetting;
+      }
+    }
+    if (isNaN(this.rowHeaderWidth)) {
+      if (rowHeaders.length) {
+        let TH = this.wtTable.TABLE.querySelector('TH');
+        this.rowHeaderWidth = 0;
+        for (let i = 0, len = rowHeaders.length; i < len; i++) {
+          if (TH) {
+            this.rowHeaderWidth += (0, _element.outerWidth)(TH);
+            TH = TH.nextSibling;
+          } else {
+            // yes this is a cheat but it worked like that before, just taking assumption from CSS instead of measuring.
+            // TODO: proper fix
+            this.rowHeaderWidth += 50;
+          }
+        }
+      } else {
+        this.rowHeaderWidth = 0;
+      }
+    }
+    this.rowHeaderWidth = this.wtSettings.getSetting('onModifyRowHeaderWidth', this.rowHeaderWidth) || this.rowHeaderWidth;
+    return this.rowHeaderWidth;
   }
 
   /**
@@ -101451,14 +101727,9 @@ function textRenderer(hotInstance, TD, row, col, prop, value, cellProperties) {
   if (cellProperties.trimWhitespace) {
     escaped = escaped.trim();
   }
-  if (TD.firstChild) {
-    (0, _element.fastInnerText)(TD.firstChild, escaped);
-  } else {
-    const div = hotInstance.rootDocument.createElement('div');
-    div.style.height = '20px';
-    TD.appendChild(div);
-    (0, _element.fastInnerText)(div, escaped);
-  }
+
+  // this is faster than innerHTML. See: https://github.com/handsontable/handsontable/wiki/JavaScript-&-DOM-performance-tips
+  (0, _element.fastInnerText)(TD, escaped);
 }
 textRenderer.RENDERER_TYPE = RENDERER_TYPE;
 
@@ -123722,10 +123993,12 @@ class CopyPaste extends _base.BasePlugin {
    * @private
    */
   onCopy(event) {
-    var _event$target;
+    var _event$target, _this$hot$getSelected;
     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');
-    if (!this.hot.isListening() && !_classPrivateFieldGet(_isTriggeredByCopy, this) || this.isEditorOpened() || event.target instanceof HTMLElement && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body)) {
+    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() || event.target instanceof HTMLElement && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body && TD !== event.target)) {
       return;
     }
     event.preventDefault();
@@ -123755,10 +124028,12 @@ class CopyPaste extends _base.BasePlugin {
    * @private
    */
   onCut(event) {
-    var _event$target2;
+    var _event$target2, _this$hot$getSelected2;
     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');
-    if (!this.hot.isListening() && !_classPrivateFieldGet(_isTriggeredByCut, this) || this.isEditorOpened() || event.target instanceof HTMLElement && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body)) {
+    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() || event.target instanceof HTMLElement && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body && TD !== event.target)) {
       return;
     }
     event.preventDefault();
@@ -123787,10 +124062,12 @@ class CopyPaste extends _base.BasePlugin {
    * @private
    */
   onPaste(event) {
-    var _event$target3;
+    var _event$target3, _this$hot$getSelected3;
     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');
-    if (!this.hot.isListening() || this.isEditorOpened() || !this.hot.getSelected() || event.target instanceof HTMLElement && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body)) {
+    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() || event.target instanceof HTMLElement && (isHotInput && event.target !== focusedElement || !isHotInput && event.target !== this.hot.rootDocument.body && TD !== event.target)) {
       return;
     }
     event.preventDefault();