handsontable 0.0.0-next-53a190b-20240403 → 0.0.0-next-5a535ed-20240403

package/plugins/manualRowResize/manualRowResize.mjs

@@ -1,11 +1,14 @@
-import "core-js/modules/es.error.cause.js";
 import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.error.cause.js";
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { 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; }
-function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
-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"); }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
 import { BasePlugin } from "../base/index.mjs";
 import { addClass, closest, hasClass, removeClass, outerWidth, isDetached } from "../../helpers/dom/element.mjs";
 import { arrayEach } from "../../helpers/array.mjs";
@@ -46,7 +49,13 @@ var _dblclick = /*#__PURE__*/new WeakMap();
 var _autoresizeTimeout = /*#__PURE__*/new WeakMap();
 var _rowHeightsMap = /*#__PURE__*/new WeakMap();
 var _config = /*#__PURE__*/new WeakMap();
-var _ManualRowResize_brand = /*#__PURE__*/new WeakSet();
+var _onMouseOver = /*#__PURE__*/new WeakSet();
+var _onMouseDown = /*#__PURE__*/new WeakSet();
+var _onMouseMove = /*#__PURE__*/new WeakSet();
+var _onMouseUp = /*#__PURE__*/new WeakSet();
+var _onContextMenu = /*#__PURE__*/new WeakSet();
+var _onModifyRowHeight = /*#__PURE__*/new WeakSet();
+var _onMapInit = /*#__PURE__*/new WeakSet();
 export class ManualRowResize extends BasePlugin {
   static get PLUGIN_KEY() {
     return PLUGIN_KEY;
@@ -61,79 +70,162 @@ export class ManualRowResize extends BasePlugin {
 
   constructor(hotInstance) {
     super(hotInstance);
+    /**
+     * Callback to call on map's `init` local hook.
+     */
+    _classPrivateMethodInitSpec(this, _onMapInit);
+    /**
+     * Modifies the provided row height, based on the plugin settings.
+     *
+     * @param {number} height Row height.
+     * @param {number} row Visual row index.
+     * @returns {number}
+     */
+    _classPrivateMethodInitSpec(this, _onModifyRowHeight);
+    /**
+     * Callback for "contextmenu" event triggered on element showing move handle. It removes handle and guide elements.
+     */
+    _classPrivateMethodInitSpec(this, _onContextMenu);
+    /**
+     * 'mouseup' event callback - apply the row resizing.
+     *
+     * @fires Hooks#beforeRowResize
+     * @fires Hooks#afterRowResize
+     */
+    _classPrivateMethodInitSpec(this, _onMouseUp);
+    /**
+     * 'mousemove' event callback - refresh the handle and guide positions, cache the new row height.
+     *
+     * @param {MouseEvent} event The mouse event.
+     */
+    _classPrivateMethodInitSpec(this, _onMouseMove);
+    /**
+     * 'mousedown' event callback.
+     *
+     * @param {MouseEvent} event The mouse event.
+     */
+    _classPrivateMethodInitSpec(this, _onMouseDown);
     /**
      * 'mouseover' event callback - set the handle position.
      *
      * @param {MouseEvent} event The mouse event.
      */
-    _classPrivateMethodInitSpec(this, _ManualRowResize_brand);
-    _classPrivateFieldInitSpec(this, _currentTH, null);
+    _classPrivateMethodInitSpec(this, _onMouseOver);
+    _classPrivateFieldInitSpec(this, _currentTH, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _currentRow, null);
+    _classPrivateFieldInitSpec(this, _currentRow, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number[]}
      */
-    _classPrivateFieldInitSpec(this, _selectedRows, []);
+    _classPrivateFieldInitSpec(this, _selectedRows, {
+      writable: true,
+      value: []
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _currentHeight, null);
+    _classPrivateFieldInitSpec(this, _currentHeight, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _newSize, null);
+    _classPrivateFieldInitSpec(this, _newSize, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _startY, null);
+    _classPrivateFieldInitSpec(this, _startY, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _startHeight, null);
+    _classPrivateFieldInitSpec(this, _startHeight, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _startOffset, null);
+    _classPrivateFieldInitSpec(this, _startOffset, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {HTMLElement}
      */
-    _classPrivateFieldInitSpec(this, _handle, this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _handle, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {HTMLElement}
      */
-    _classPrivateFieldInitSpec(this, _guide, this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _guide, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {boolean}
      */
-    _classPrivateFieldInitSpec(this, _pressed, false);
+    _classPrivateFieldInitSpec(this, _pressed, {
+      writable: true,
+      value: false
+    });
     /**
      * @type {boolean}
      */
-    _classPrivateFieldInitSpec(this, _isTriggeredByRMB, false);
+    _classPrivateFieldInitSpec(this, _isTriggeredByRMB, {
+      writable: true,
+      value: false
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _dblclick, 0);
+    _classPrivateFieldInitSpec(this, _dblclick, {
+      writable: true,
+      value: 0
+    });
     /**
      * @type {number}
      */
-    _classPrivateFieldInitSpec(this, _autoresizeTimeout, null);
+    _classPrivateFieldInitSpec(this, _autoresizeTimeout, {
+      writable: true,
+      value: null
+    });
     /**
      * PhysicalIndexToValueMap to keep and track widths for physical row indexes.
      *
      * @type {PhysicalIndexToValueMap}
      */
-    _classPrivateFieldInitSpec(this, _rowHeightsMap, void 0);
+    _classPrivateFieldInitSpec(this, _rowHeightsMap, {
+      writable: true,
+      value: void 0
+    });
     /**
      * Private pool to save configuration from updateSettings.
      *
      * @type {object}
      */
-    _classPrivateFieldInitSpec(this, _config, void 0);
-    addClass(_classPrivateFieldGet(_handle, this), 'manualRowResizer');
-    addClass(_classPrivateFieldGet(_guide, this), 'manualRowResizerGuide');
+    _classPrivateFieldInitSpec(this, _config, {
+      writable: true,
+      value: void 0
+    });
+    addClass(_classPrivateFieldGet(this, _handle), 'manualRowResizer');
+    addClass(_classPrivateFieldGet(this, _guide), 'manualRowResizerGuide');
   }
 
   /**
@@ -161,10 +253,10 @@ export class ManualRowResize extends BasePlugin {
     if (this.enabled) {
       return;
     }
-    _classPrivateFieldSet(_rowHeightsMap, this, new IndexToValueMap());
-    _classPrivateFieldGet(_rowHeightsMap, this).addLocalHook('init', () => _assertClassBrand(_ManualRowResize_brand, this, _onMapInit).call(this));
-    this.hot.rowIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet(_rowHeightsMap, this));
-    this.addHook('modifyRowHeight', (height, row) => _assertClassBrand(_ManualRowResize_brand, this, _onModifyRowHeight).call(this, height, row));
+    _classPrivateFieldSet(this, _rowHeightsMap, new IndexToValueMap());
+    _classPrivateFieldGet(this, _rowHeightsMap).addLocalHook('init', () => _classPrivateMethodGet(this, _onMapInit, _onMapInit2).call(this));
+    this.hot.rowIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet(this, _rowHeightsMap));
+    this.addHook('modifyRowHeight', (height, row) => _classPrivateMethodGet(this, _onModifyRowHeight, _onModifyRowHeight2).call(this, height, row));
     this.bindEvents();
     super.enablePlugin();
   }
@@ -185,7 +277,7 @@ export class ManualRowResize extends BasePlugin {
    * Disables the plugin functionality for this Handsontable instance.
    */
   disablePlugin() {
-    _classPrivateFieldSet(_config, this, _classPrivateFieldGet(_rowHeightsMap, this).getValues());
+    _classPrivateFieldSet(this, _config, _classPrivateFieldGet(this, _rowHeightsMap).getValues());
     this.hot.rowIndexMapper.unregisterMap(this.pluginName);
     super.disablePlugin();
   }
@@ -197,7 +289,7 @@ export class ManualRowResize extends BasePlugin {
    * @fires Hooks#persistentStateSave
    */
   saveManualRowHeights() {
-    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, _classPrivateFieldGet(_rowHeightsMap, this).getValues());
+    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, _classPrivateFieldGet(this, _rowHeightsMap).getValues());
   }
 
   /**
@@ -223,7 +315,7 @@ export class ManualRowResize extends BasePlugin {
   setManualSize(row, height) {
     const physicalRow = this.hot.toPhysicalRow(row);
     const newHeight = Math.max(height, ViewportRowsCalculator.DEFAULT_HEIGHT);
-    _classPrivateFieldGet(_rowHeightsMap, this).setValueAtIndex(physicalRow, newHeight);
+    _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(physicalRow, newHeight);
     return newHeight;
   }
 
@@ -234,40 +326,40 @@ export class ManualRowResize extends BasePlugin {
    * @param {HTMLCellElement} TH TH HTML element.
    */
   setupHandlePosition(TH) {
-    _classPrivateFieldSet(_currentTH, this, TH);
+    _classPrivateFieldSet(this, _currentTH, TH);
     const {
       view
     } = this.hot;
     const {
       _wt: wt
     } = view;
-    const cellCoords = wt.wtTable.getCoords(_classPrivateFieldGet(_currentTH, this));
+    const cellCoords = wt.wtTable.getCoords(_classPrivateFieldGet(this, _currentTH));
     const row = cellCoords.row;
 
     // Ignore row headers.
     if (row < 0) {
       return;
     }
-    const headerWidth = outerWidth(_classPrivateFieldGet(_currentTH, this));
-    const box = _classPrivateFieldGet(_currentTH, this).getBoundingClientRect();
+    const headerWidth = outerWidth(_classPrivateFieldGet(this, _currentTH));
+    const box = _classPrivateFieldGet(this, _currentTH).getBoundingClientRect();
     // Read "fixedRowsTop" and "fixedRowsBottom" through the Walkontable as in that context, the fixed
     // rows are modified (reduced by the number of hidden rows) by TableView module.
     const fixedRowTop = row < wt.getSetting('fixedRowsTop');
     const fixedRowBottom = row >= view.countNotHiddenRowIndexes(0, 1) - wt.getSetting('fixedRowsBottom');
     let relativeHeaderPosition;
     if (fixedRowTop) {
-      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(_currentTH, this), cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     } else if (fixedRowBottom) {
-      relativeHeaderPosition = wt.wtOverlays.bottomInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(_currentTH, this), cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.bottomInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
 
     // If the TH is not a child of the top-left/bottom-left overlay, recalculate using
     // the left overlay - as this overlay contains the rest of the headers.
     if (!relativeHeaderPosition) {
-      relativeHeaderPosition = wt.wtOverlays.inlineStartOverlay.getRelativeCellPosition(_classPrivateFieldGet(_currentTH, this), cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.inlineStartOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
-    _classPrivateFieldSet(_currentRow, this, this.hot.rowIndexMapper.getVisualFromRenderableIndex(row));
-    _classPrivateFieldSet(_selectedRows, this, []);
+    _classPrivateFieldSet(this, _currentRow, this.hot.rowIndexMapper.getVisualFromRenderableIndex(row));
+    _classPrivateFieldSet(this, _selectedRows, []);
     const isFullRowSelected = this.hot.selection.isSelectedByCorner() || this.hot.selection.isSelectedByRowHeader();
     if (this.hot.selection.isSelected() && isFullRowSelected) {
       const selectionRanges = this.hot.getSelectedRange();
@@ -277,23 +369,23 @@ export class ManualRowResize extends BasePlugin {
 
         // Add every selected row for resize action.
         rangeEach(fromRow, toRow, rowIndex => {
-          if (!_classPrivateFieldGet(_selectedRows, this).includes(rowIndex)) {
-            _classPrivateFieldGet(_selectedRows, this).push(rowIndex);
+          if (!_classPrivateFieldGet(this, _selectedRows).includes(rowIndex)) {
+            _classPrivateFieldGet(this, _selectedRows).push(rowIndex);
           }
         });
       });
     }
 
     // Resizing element beyond the current selection (also when there is no selection).
-    if (!_classPrivateFieldGet(_selectedRows, this).includes(_classPrivateFieldGet(_currentRow, this))) {
-      _classPrivateFieldSet(_selectedRows, this, [_classPrivateFieldGet(_currentRow, this)]);
+    if (!_classPrivateFieldGet(this, _selectedRows).includes(_classPrivateFieldGet(this, _currentRow))) {
+      _classPrivateFieldSet(this, _selectedRows, [_classPrivateFieldGet(this, _currentRow)]);
     }
-    _classPrivateFieldSet(_startOffset, this, relativeHeaderPosition.top - 6);
-    _classPrivateFieldSet(_startHeight, this, parseInt(box.height, 10));
-    _classPrivateFieldGet(_handle, this).style.top = `${_classPrivateFieldGet(_startOffset, this) + _classPrivateFieldGet(_startHeight, this)}px`;
-    _classPrivateFieldGet(_handle, this).style[this.inlineDir] = `${relativeHeaderPosition.start}px`;
-    _classPrivateFieldGet(_handle, this).style.width = `${headerWidth}px`;
-    this.hot.rootElement.appendChild(_classPrivateFieldGet(_handle, this));
+    _classPrivateFieldSet(this, _startOffset, relativeHeaderPosition.top - 6);
+    _classPrivateFieldSet(this, _startHeight, parseInt(box.height, 10));
+    _classPrivateFieldGet(this, _handle).style.top = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _startHeight)}px`;
+    _classPrivateFieldGet(this, _handle).style[this.inlineDir] = `${relativeHeaderPosition.start}px`;
+    _classPrivateFieldGet(this, _handle).style.width = `${headerWidth}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _handle));
   }
 
   /**
@@ -302,7 +394,7 @@ export class ManualRowResize extends BasePlugin {
    * @private
    */
   refreshHandlePosition() {
-    _classPrivateFieldGet(_handle, this).style.top = `${_classPrivateFieldGet(_startOffset, this) + _classPrivateFieldGet(_currentHeight, this)}px`;
+    _classPrivateFieldGet(this, _handle).style.top = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _currentHeight)}px`;
   }
 
   /**
@@ -311,15 +403,15 @@ export class ManualRowResize extends BasePlugin {
    * @private
    */
   setupGuidePosition() {
-    const handleWidth = parseInt(outerWidth(_classPrivateFieldGet(_handle, this)), 10);
-    const handleEndPosition = parseInt(_classPrivateFieldGet(_handle, this).style[this.inlineDir], 10) + handleWidth;
+    const handleWidth = parseInt(outerWidth(_classPrivateFieldGet(this, _handle)), 10);
+    const handleEndPosition = parseInt(_classPrivateFieldGet(this, _handle).style[this.inlineDir], 10) + handleWidth;
     const maximumVisibleElementWidth = parseInt(this.hot.view.maximumVisibleElementWidth(0), 10);
-    addClass(_classPrivateFieldGet(_handle, this), 'active');
-    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`;
-    this.hot.rootElement.appendChild(_classPrivateFieldGet(_guide, this));
+    addClass(_classPrivateFieldGet(this, _handle), 'active');
+    addClass(_classPrivateFieldGet(this, _guide), 'active');
+    _classPrivateFieldGet(this, _guide).style.top = _classPrivateFieldGet(this, _handle).style.top;
+    _classPrivateFieldGet(this, _guide).style[this.inlineDir] = `${handleEndPosition}px`;
+    _classPrivateFieldGet(this, _guide).style.width = `${maximumVisibleElementWidth - handleWidth}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _guide));
   }
 
   /**
@@ -328,7 +420,7 @@ export class ManualRowResize extends BasePlugin {
    * @private
    */
   refreshGuidePosition() {
-    _classPrivateFieldGet(_guide, this).style.top = _classPrivateFieldGet(_handle, this).style.top;
+    _classPrivateFieldGet(this, _guide).style.top = _classPrivateFieldGet(this, _handle).style.top;
   }
 
   /**
@@ -337,8 +429,8 @@ export class ManualRowResize extends BasePlugin {
    * @private
    */
   hideHandleAndGuide() {
-    removeClass(_classPrivateFieldGet(_handle, this), 'active');
-    removeClass(_classPrivateFieldGet(_guide, this), 'active');
+    removeClass(_classPrivateFieldGet(this, _handle), 'active');
+    removeClass(_classPrivateFieldGet(this, _guide), 'active');
   }
 
   /**
@@ -385,10 +477,10 @@ export class ManualRowResize extends BasePlugin {
   getActualRowHeight(row) {
     // TODO: this should utilize `this.hot.getRowHeight` after it's fixed and working properly.
     const walkontableHeight = this.hot.view._wt.wtTable.getRowHeight(row);
-    if (walkontableHeight !== undefined && _classPrivateFieldGet(_newSize, this) < walkontableHeight) {
+    if (walkontableHeight !== undefined && _classPrivateFieldGet(this, _newSize) < walkontableHeight) {
       return walkontableHeight;
     }
-    return _classPrivateFieldGet(_newSize, this);
+    return _classPrivateFieldGet(this, _newSize);
   }
   /**
    * Auto-size row after doubleclick - callback.
@@ -406,38 +498,31 @@ export class ManualRowResize extends BasePlugin {
     const resize = (row, forceRender) => {
       const hookNewSize = this.hot.runHooks('beforeRowResize', this.getActualRowHeight(row), row, true);
       if (hookNewSize !== undefined) {
-        _classPrivateFieldSet(_newSize, this, hookNewSize);
+        _classPrivateFieldSet(this, _newSize, hookNewSize);
       }
-      this.setManualSize(row, _classPrivateFieldGet(_newSize, this)); // double click sets auto row size
+      this.setManualSize(row, _classPrivateFieldGet(this, _newSize)); // double click sets auto row size
 
       this.hot.runHooks('afterRowResize', this.getActualRowHeight(row), row, true);
       if (forceRender) {
         render();
       }
     };
-    if (_classPrivateFieldGet(_dblclick, this) >= 2) {
-      const selectedRowsLength = _classPrivateFieldGet(_selectedRows, this).length;
+    if (_classPrivateFieldGet(this, _dblclick) >= 2) {
+      const selectedRowsLength = _classPrivateFieldGet(this, _selectedRows).length;
       if (selectedRowsLength > 1) {
-        arrayEach(_classPrivateFieldGet(_selectedRows, this), selectedRow => {
+        arrayEach(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           resize(selectedRow);
         });
         render();
       } else {
-        arrayEach(_classPrivateFieldGet(_selectedRows, this), selectedRow => {
+        arrayEach(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           resize(selectedRow, true);
         });
       }
     }
-    _classPrivateFieldSet(_dblclick, this, 0);
-    _classPrivateFieldSet(_autoresizeTimeout, this, null);
+    _classPrivateFieldSet(this, _dblclick, 0);
+    _classPrivateFieldSet(this, _autoresizeTimeout, null);
   }
-
-  /**
-   * 'mousedown' event callback.
-   *
-   * @param {MouseEvent} event The mouse event.
-   */
-
   /**
    * Binds the mouse events.
    *
@@ -448,21 +533,12 @@ export class ManualRowResize extends BasePlugin {
       rootElement,
       rootWindow
     } = this.hot;
-    this.eventManager.addEventListener(rootElement, 'mouseover', e => _assertClassBrand(_ManualRowResize_brand, this, _onMouseOver).call(this, e));
-    this.eventManager.addEventListener(rootElement, 'mousedown', e => _assertClassBrand(_ManualRowResize_brand, this, _onMouseDown).call(this, e));
-    this.eventManager.addEventListener(rootWindow, 'mousemove', e => _assertClassBrand(_ManualRowResize_brand, this, _onMouseMove).call(this, e));
-    this.eventManager.addEventListener(rootWindow, 'mouseup', () => _assertClassBrand(_ManualRowResize_brand, this, _onMouseUp).call(this));
-    this.eventManager.addEventListener(_classPrivateFieldGet(_handle, this), 'contextmenu', () => _assertClassBrand(_ManualRowResize_brand, this, _onContextMenu).call(this));
+    this.eventManager.addEventListener(rootElement, 'mouseover', e => _classPrivateMethodGet(this, _onMouseOver, _onMouseOver2).call(this, e));
+    this.eventManager.addEventListener(rootElement, 'mousedown', e => _classPrivateMethodGet(this, _onMouseDown, _onMouseDown2).call(this, e));
+    this.eventManager.addEventListener(rootWindow, 'mousemove', e => _classPrivateMethodGet(this, _onMouseMove, _onMouseMove2).call(this, e));
+    this.eventManager.addEventListener(rootWindow, 'mouseup', () => _classPrivateMethodGet(this, _onMouseUp, _onMouseUp2).call(this));
+    this.eventManager.addEventListener(_classPrivateFieldGet(this, _handle), 'contextmenu', () => _classPrivateMethodGet(this, _onContextMenu, _onContextMenu2).call(this));
   }
-
-  /**
-   * Modifies the provided row height, based on the plugin settings.
-   *
-   * @param {number} height Row height.
-   * @param {number} row Visual row index.
-   * @returns {number}
-   */
-
   /**
    * Destroys the plugin instance.
    */
@@ -470,7 +546,7 @@ export class ManualRowResize extends BasePlugin {
     super.destroy();
   }
 }
-function _onMouseOver(event) {
+function _onMouseOver2(event) {
   // Workaround for #6926 - if the `event.target` is temporarily detached, we can skip this callback and wait for
   // the next `onmouseover`.
   if (isDetached(event.target)) {
@@ -478,54 +554,43 @@ function _onMouseOver(event) {
   }
 
   // A "mouseover" action is triggered right after executing "contextmenu" event. It should be ignored.
-  if (_classPrivateFieldGet(_isTriggeredByRMB, this) === true) {
+  if (_classPrivateFieldGet(this, _isTriggeredByRMB) === true) {
     return;
   }
   if (this.checkIfRowHeader(event.target)) {
     const th = this.getClosestTHParent(event.target);
     if (th) {
-      if (!_classPrivateFieldGet(_pressed, this)) {
+      if (!_classPrivateFieldGet(this, _pressed)) {
         this.setupHandlePosition(th);
       }
     }
   }
 }
-function _onMouseDown(event) {
+function _onMouseDown2(event) {
   if (hasClass(event.target, 'manualRowResizer')) {
-    this.setupHandlePosition(_classPrivateFieldGet(_currentTH, this));
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
     this.setupGuidePosition();
-    _classPrivateFieldSet(_pressed, this, true);
-    if (_classPrivateFieldGet(_autoresizeTimeout, this) === null) {
-      _classPrivateFieldSet(_autoresizeTimeout, this, setTimeout(() => this.afterMouseDownTimeout(), 500));
-      this.hot._registerTimeout(_classPrivateFieldGet(_autoresizeTimeout, this));
+    _classPrivateFieldSet(this, _pressed, true);
+    if (_classPrivateFieldGet(this, _autoresizeTimeout) === null) {
+      _classPrivateFieldSet(this, _autoresizeTimeout, setTimeout(() => this.afterMouseDownTimeout(), 500));
+      this.hot._registerTimeout(_classPrivateFieldGet(this, _autoresizeTimeout));
     }
-    _classPrivateFieldSet(_dblclick, this, _classPrivateFieldGet(_dblclick, this) + 1);
-    _classPrivateFieldSet(_startY, this, event.pageY);
-    _classPrivateFieldSet(_newSize, this, _classPrivateFieldGet(_startHeight, this));
+    _classPrivateFieldSet(this, _dblclick, _classPrivateFieldGet(this, _dblclick) + 1);
+    _classPrivateFieldSet(this, _startY, event.pageY);
+    _classPrivateFieldSet(this, _newSize, _classPrivateFieldGet(this, _startHeight));
   }
 }
-/**
- * 'mousemove' event callback - refresh the handle and guide positions, cache the new row height.
- *
- * @param {MouseEvent} event The mouse event.
- */
-function _onMouseMove(event) {
-  if (_classPrivateFieldGet(_pressed, this)) {
-    _classPrivateFieldSet(_currentHeight, this, _classPrivateFieldGet(_startHeight, this) + (event.pageY - _classPrivateFieldGet(_startY, this)));
-    arrayEach(_classPrivateFieldGet(_selectedRows, this), selectedRow => {
-      _classPrivateFieldSet(_newSize, this, this.setManualSize(selectedRow, _classPrivateFieldGet(_currentHeight, this)));
+function _onMouseMove2(event) {
+  if (_classPrivateFieldGet(this, _pressed)) {
+    _classPrivateFieldSet(this, _currentHeight, _classPrivateFieldGet(this, _startHeight) + (event.pageY - _classPrivateFieldGet(this, _startY)));
+    arrayEach(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
+      _classPrivateFieldSet(this, _newSize, this.setManualSize(selectedRow, _classPrivateFieldGet(this, _currentHeight)));
     });
     this.refreshHandlePosition();
     this.refreshGuidePosition();
   }
 }
-/**
- * 'mouseup' event callback - apply the row resizing.
- *
- * @fires Hooks#beforeRowResize
- * @fires Hooks#afterRowResize
- */
-function _onMouseUp() {
+function _onMouseUp2() {
   const render = () => {
     this.hot.forceFullRender = true;
     this.hot.view.render(); // updates all
@@ -539,71 +604,65 @@ function _onMouseUp() {
     this.saveManualRowHeights();
     this.hot.runHooks('afterRowResize', this.getActualRowHeight(row), row, false);
   };
-  if (_classPrivateFieldGet(_pressed, this)) {
+  if (_classPrivateFieldGet(this, _pressed)) {
     this.hideHandleAndGuide();
-    _classPrivateFieldSet(_pressed, this, false);
-    if (_classPrivateFieldGet(_newSize, this) !== _classPrivateFieldGet(_startHeight, this)) {
-      const selectedRowsLength = _classPrivateFieldGet(_selectedRows, this).length;
+    _classPrivateFieldSet(this, _pressed, false);
+    if (_classPrivateFieldGet(this, _newSize) !== _classPrivateFieldGet(this, _startHeight)) {
+      const selectedRowsLength = _classPrivateFieldGet(this, _selectedRows).length;
       if (selectedRowsLength > 1) {
-        arrayEach(_classPrivateFieldGet(_selectedRows, this), selectedRow => {
+        arrayEach(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           runHooks(selectedRow);
         });
         render();
       } else {
-        arrayEach(_classPrivateFieldGet(_selectedRows, this), selectedRow => {
+        arrayEach(_classPrivateFieldGet(this, _selectedRows), selectedRow => {
           runHooks(selectedRow, true);
         });
       }
     }
-    this.setupHandlePosition(_classPrivateFieldGet(_currentTH, this));
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
   }
 }
-/**
- * Callback for "contextmenu" event triggered on element showing move handle. It removes handle and guide elements.
- */
-function _onContextMenu() {
+function _onContextMenu2() {
   this.hideHandleAndGuide();
-  this.hot.rootElement.removeChild(_classPrivateFieldGet(_handle, this));
-  this.hot.rootElement.removeChild(_classPrivateFieldGet(_guide, this));
-  _classPrivateFieldSet(_pressed, this, false);
-  _classPrivateFieldSet(_isTriggeredByRMB, this, true);
+  this.hot.rootElement.removeChild(_classPrivateFieldGet(this, _handle));
+  this.hot.rootElement.removeChild(_classPrivateFieldGet(this, _guide));
+  _classPrivateFieldSet(this, _pressed, false);
+  _classPrivateFieldSet(this, _isTriggeredByRMB, true);
 
   // There is thrown "mouseover" event right after opening a context menu. This flag inform that handle
   // shouldn't be drawn just after removing it.
   this.hot._registerImmediate(() => {
-    _classPrivateFieldSet(_isTriggeredByRMB, this, false);
+    _classPrivateFieldSet(this, _isTriggeredByRMB, false);
   });
 }
-function _onModifyRowHeight(height, row) {
+function _onModifyRowHeight2(height, row) {
   let newHeight = height;
   if (this.enabled) {
     const physicalRow = this.hot.toPhysicalRow(row);
-    const rowHeight = _classPrivateFieldGet(_rowHeightsMap, this).getValueAtIndex(physicalRow);
+    const rowHeight = _classPrivateFieldGet(this, _rowHeightsMap).getValueAtIndex(physicalRow);
     if (this.hot.getSettings()[PLUGIN_KEY] && rowHeight) {
       newHeight = rowHeight;
     }
   }
   return newHeight;
 }
-/**
- * Callback to call on map's `init` local hook.
- */
-function _onMapInit() {
+function _onMapInit2() {
   const initialSetting = this.hot.getSettings()[PLUGIN_KEY];
   const loadedManualRowHeights = this.loadManualRowHeights();
   this.hot.batchExecution(() => {
     if (typeof loadedManualRowHeights !== 'undefined') {
       loadedManualRowHeights.forEach((height, index) => {
-        _classPrivateFieldGet(_rowHeightsMap, this).setValueAtIndex(index, height);
+        _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(index, height);
       });
     } else if (Array.isArray(initialSetting)) {
       initialSetting.forEach((height, index) => {
-        _classPrivateFieldGet(_rowHeightsMap, this).setValueAtIndex(index, height);
+        _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(index, height);
       });
-      _classPrivateFieldSet(_config, this, initialSetting);
-    } else if (initialSetting === true && Array.isArray(_classPrivateFieldGet(_config, this))) {
-      _classPrivateFieldGet(_config, this).forEach((height, index) => {
-        _classPrivateFieldGet(_rowHeightsMap, this).setValueAtIndex(index, height);
+      _classPrivateFieldSet(this, _config, initialSetting);
+    } else if (initialSetting === true && Array.isArray(_classPrivateFieldGet(this, _config))) {
+      _classPrivateFieldGet(this, _config).forEach((height, index) => {
+        _classPrivateFieldGet(this, _rowHeightsMap).setValueAtIndex(index, height);
       });
     }
   }, true);