handsontable 14.0.0-next-4fd76bc-20231114 → 14.0.0-next-bdc44e7-20231115

package/plugins/manualColumnResize/manualColumnResize.mjs

@@ -3,15 +3,12 @@ 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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
-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 _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 _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+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, outerHeight, isDetached } from "../../helpers/dom/element.mjs";
 import { arrayEach } from "../../helpers/array.mjs";
@@ -35,6 +32,21 @@ const PERSISTENT_STATE_KEY = 'manualColumnWidths';
  * - handle - the draggable element that sets the desired width of the column.
  * - guide - the helper guide that shows the desired width as a vertical guide.
  */
+var _currentTH = /*#__PURE__*/new WeakMap();
+var _currentCol = /*#__PURE__*/new WeakMap();
+var _selectedCols = /*#__PURE__*/new WeakMap();
+var _currentWidth = /*#__PURE__*/new WeakMap();
+var _newSize = /*#__PURE__*/new WeakMap();
+var _startY = /*#__PURE__*/new WeakMap();
+var _startWidth = /*#__PURE__*/new WeakMap();
+var _startOffset = /*#__PURE__*/new WeakMap();
+var _handle = /*#__PURE__*/new WeakMap();
+var _guide = /*#__PURE__*/new WeakMap();
+var _pressed = /*#__PURE__*/new WeakMap();
+var _isTriggeredByRMB = /*#__PURE__*/new WeakMap();
+var _dblclick = /*#__PURE__*/new WeakMap();
+var _autoresizeTimeout = /*#__PURE__*/new WeakMap();
+var _columnWidthsMap = /*#__PURE__*/new WeakMap();
 var _config = /*#__PURE__*/new WeakMap();
 var _onMapInit = /*#__PURE__*/new WeakSet();
 var _onMouseOver = /*#__PURE__*/new WeakSet();
@@ -114,66 +126,110 @@ export class ManualColumnResize extends BasePlugin {
      * @private
      */
     _classPrivateMethodInitSpec(this, _onMapInit);
-    _defineProperty(this, "currentTH", null);
+    _classPrivateFieldInitSpec(this, _currentTH, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "currentCol", null);
+    _classPrivateFieldInitSpec(this, _currentCol, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number[]}
      */
-    _defineProperty(this, "selectedCols", []);
+    _classPrivateFieldInitSpec(this, _selectedCols, {
+      writable: true,
+      value: []
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "currentWidth", null);
+    _classPrivateFieldInitSpec(this, _currentWidth, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "newSize", null);
+    _classPrivateFieldInitSpec(this, _newSize, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "startY", null);
+    _classPrivateFieldInitSpec(this, _startY, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "startWidth", null);
+    _classPrivateFieldInitSpec(this, _startWidth, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "startOffset", null);
+    _classPrivateFieldInitSpec(this, _startOffset, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {HTMLElement}
      */
-    _defineProperty(this, "handle", this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _handle, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {HTMLElement}
      */
-    _defineProperty(this, "guide", this.hot.rootDocument.createElement('DIV'));
+    _classPrivateFieldInitSpec(this, _guide, {
+      writable: true,
+      value: this.hot.rootDocument.createElement('DIV')
+    });
     /**
      * @type {boolean}
      */
-    _defineProperty(this, "pressed", null);
+    _classPrivateFieldInitSpec(this, _pressed, {
+      writable: true,
+      value: null
+    });
     /**
      * @type {boolean}
      */
-    _defineProperty(this, "isTriggeredByRMB", false);
+    _classPrivateFieldInitSpec(this, _isTriggeredByRMB, {
+      writable: true,
+      value: false
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "dblclick", 0);
+    _classPrivateFieldInitSpec(this, _dblclick, {
+      writable: true,
+      value: 0
+    });
     /**
      * @type {number}
      */
-    _defineProperty(this, "autoresizeTimeout", null);
+    _classPrivateFieldInitSpec(this, _autoresizeTimeout, {
+      writable: true,
+      value: null
+    });
     /**
      * PhysicalIndexToValueMap to keep and track widths for physical column indexes.
      *
-     * @private
      * @type {PhysicalIndexToValueMap}
      */
-    _defineProperty(this, "columnWidthsMap", void 0);
+    _classPrivateFieldInitSpec(this, _columnWidthsMap, {
+      writable: true,
+      value: void 0
+    });
     /**
      * Private pool to save configuration from updateSettings.
      *
@@ -183,8 +239,8 @@ export class ManualColumnResize extends BasePlugin {
       writable: true,
       value: void 0
     });
-    addClass(this.handle, 'manualColumnResizer');
-    addClass(this.guide, 'manualColumnResizerGuide');
+    addClass(_classPrivateFieldGet(this, _handle), 'manualColumnResizer');
+    addClass(_classPrivateFieldGet(this, _guide), 'manualColumnResizerGuide');
   }
 
   /**
@@ -212,9 +268,9 @@ export class ManualColumnResize extends BasePlugin {
     if (this.enabled) {
       return;
     }
-    this.columnWidthsMap = new IndexToValueMap();
-    this.columnWidthsMap.addLocalHook('init', () => _classPrivateMethodGet(this, _onMapInit, _onMapInit2).call(this));
-    this.hot.columnIndexMapper.registerMap(this.pluginName, this.columnWidthsMap);
+    _classPrivateFieldSet(this, _columnWidthsMap, new IndexToValueMap());
+    _classPrivateFieldGet(this, _columnWidthsMap).addLocalHook('init', () => _classPrivateMethodGet(this, _onMapInit, _onMapInit2).call(this));
+    this.hot.columnIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet(this, _columnWidthsMap));
     this.addHook('modifyColWidth', (width, col) => _classPrivateMethodGet(this, _onModifyColWidth, _onModifyColWidth2).call(this, width, col));
     this.addHook('beforeStretchingColumnWidth', (stretchedWidth, column) => _classPrivateMethodGet(this, _onBeforeStretchingColumnWidth, _onBeforeStretchingColumnWidth2).call(this, stretchedWidth, column));
     this.addHook('beforeColumnResize', (newSize, column, isDoubleClick) => _classPrivateMethodGet(this, _onBeforeColumnResize, _onBeforeColumnResize2).call(this, newSize, column, isDoubleClick));
@@ -238,7 +294,7 @@ export class ManualColumnResize extends BasePlugin {
    * Disables the plugin functionality for this Handsontable instance.
    */
   disablePlugin() {
-    _classPrivateFieldSet(this, _config, this.columnWidthsMap.getValues());
+    _classPrivateFieldSet(this, _config, _classPrivateFieldGet(this, _columnWidthsMap).getValues());
     this.hot.columnIndexMapper.unregisterMap(this.pluginName);
     super.disablePlugin();
   }
@@ -249,7 +305,7 @@ export class ManualColumnResize extends BasePlugin {
    * @fires Hooks#persistentStateSave
    */
   saveManualColumnWidths() {
-    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, this.columnWidthsMap.getValues());
+    this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, _classPrivateFieldGet(this, _columnWidthsMap).getValues());
   }
 
   /**
@@ -274,7 +330,7 @@ export class ManualColumnResize extends BasePlugin {
   setManualSize(column, width) {
     const newWidth = Math.max(width, 20);
     const physicalColumn = this.hot.toPhysicalColumn(column);
-    this.columnWidthsMap.setValueAtIndex(physicalColumn, newWidth);
+    _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalColumn, newWidth);
     return newWidth;
   }
 
@@ -285,7 +341,7 @@ export class ManualColumnResize extends BasePlugin {
    */
   clearManualSize(column) {
     const physicalColumn = this.hot.toPhysicalColumn(column);
-    this.columnWidthsMap.setValueAtIndex(physicalColumn, null);
+    _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalColumn, null);
   }
   /**
    * Set the resize handle position.
@@ -297,34 +353,34 @@ export class ManualColumnResize extends BasePlugin {
     if (!TH.parentNode) {
       return;
     }
-    this.currentTH = TH;
+    _classPrivateFieldSet(this, _currentTH, TH);
     const {
       _wt: wt
     } = this.hot.view;
-    const cellCoords = wt.wtTable.getCoords(this.currentTH);
+    const cellCoords = wt.wtTable.getCoords(_classPrivateFieldGet(this, _currentTH));
     const col = cellCoords.col;
 
     // Ignore column headers.
     if (col < 0) {
       return;
     }
-    const headerHeight = outerHeight(this.currentTH);
-    const box = this.currentTH.getBoundingClientRect();
+    const headerHeight = outerHeight(_classPrivateFieldGet(this, _currentTH));
+    const box = _classPrivateFieldGet(this, _currentTH).getBoundingClientRect();
     // Read "fixedColumnsStart" through the Walkontable as in that context, the fixed columns
     // are modified (reduced by the number of hidden columns) by TableView module.
     const fixedColumn = col < wt.getSetting('fixedColumnsStart');
     let relativeHeaderPosition;
     if (fixedColumn) {
-      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.topInlineStartCornerOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
 
     // If the TH is not a child of the top-left overlay, recalculate using
     // the top overlay - as this overlay contains the rest of the headers.
     if (!relativeHeaderPosition) {
-      relativeHeaderPosition = wt.wtOverlays.topOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col);
+      relativeHeaderPosition = wt.wtOverlays.topOverlay.getRelativeCellPosition(_classPrivateFieldGet(this, _currentTH), cellCoords.row, cellCoords.col);
     }
-    this.currentCol = this.hot.columnIndexMapper.getVisualFromRenderableIndex(col);
-    this.selectedCols = [];
+    _classPrivateFieldSet(this, _currentCol, this.hot.columnIndexMapper.getVisualFromRenderableIndex(col));
+    _classPrivateFieldSet(this, _selectedCols, []);
     const isFullColumnSelected = this.hot.selection.isSelectedByCorner() || this.hot.selection.isSelectedByColumnHeader();
     if (this.hot.selection.isSelected() && isFullColumnSelected) {
       const selectionRanges = this.hot.getSelectedRange();
@@ -334,23 +390,23 @@ export class ManualColumnResize extends BasePlugin {
 
         // Add every selected column for resize action.
         rangeEach(fromColumn, toColumn, columnIndex => {
-          if (!this.selectedCols.includes(columnIndex)) {
-            this.selectedCols.push(columnIndex);
+          if (!_classPrivateFieldGet(this, _selectedCols).includes(columnIndex)) {
+            _classPrivateFieldGet(this, _selectedCols).push(columnIndex);
           }
         });
       });
     }
 
     // Resizing element beyond the current selection (also when there is no selection).
-    if (!this.selectedCols.includes(this.currentCol)) {
-      this.selectedCols = [this.currentCol];
+    if (!_classPrivateFieldGet(this, _selectedCols).includes(_classPrivateFieldGet(this, _currentCol))) {
+      _classPrivateFieldSet(this, _selectedCols, [_classPrivateFieldGet(this, _currentCol)]);
     }
-    this.startOffset = relativeHeaderPosition.start - 6;
-    this.startWidth = parseInt(box.width, 10);
-    this.handle.style.top = `${relativeHeaderPosition.top}px`;
-    this.handle.style[this.inlineDir] = `${this.startOffset + this.startWidth}px`;
-    this.handle.style.height = `${headerHeight}px`;
-    this.hot.rootElement.appendChild(this.handle);
+    _classPrivateFieldSet(this, _startOffset, relativeHeaderPosition.start - 6);
+    _classPrivateFieldSet(this, _startWidth, parseInt(box.width, 10));
+    _classPrivateFieldGet(this, _handle).style.top = `${relativeHeaderPosition.top}px`;
+    _classPrivateFieldGet(this, _handle).style[this.inlineDir] = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _startWidth)}px`;
+    _classPrivateFieldGet(this, _handle).style.height = `${headerHeight}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _handle));
   }
 
   /**
@@ -359,7 +415,7 @@ export class ManualColumnResize extends BasePlugin {
    * @private
    */
   refreshHandlePosition() {
-    this.handle.style[this.inlineDir] = `${this.startOffset + this.currentWidth}px`;
+    _classPrivateFieldGet(this, _handle).style[this.inlineDir] = `${_classPrivateFieldGet(this, _startOffset) + _classPrivateFieldGet(this, _currentWidth)}px`;
   }
 
   /**
@@ -368,15 +424,15 @@ export class ManualColumnResize extends BasePlugin {
    * @private
    */
   setupGuidePosition() {
-    const handleHeight = parseInt(outerHeight(this.handle), 10);
-    const handleBottomPosition = parseInt(this.handle.style.top, 10) + handleHeight;
+    const handleHeight = parseInt(outerHeight(_classPrivateFieldGet(this, _handle)), 10);
+    const handleBottomPosition = parseInt(_classPrivateFieldGet(this, _handle).style.top, 10) + handleHeight;
     const maximumVisibleElementHeight = parseInt(this.hot.view.maximumVisibleElementHeight(0), 10);
-    addClass(this.handle, 'active');
-    addClass(this.guide, 'active');
-    this.guide.style.top = `${handleBottomPosition}px`;
+    addClass(_classPrivateFieldGet(this, _handle), 'active');
+    addClass(_classPrivateFieldGet(this, _guide), 'active');
+    _classPrivateFieldGet(this, _guide).style.top = `${handleBottomPosition}px`;
     this.refreshGuidePosition();
-    this.guide.style.height = `${maximumVisibleElementHeight - handleHeight}px`;
-    this.hot.rootElement.appendChild(this.guide);
+    _classPrivateFieldGet(this, _guide).style.height = `${maximumVisibleElementHeight - handleHeight}px`;
+    this.hot.rootElement.appendChild(_classPrivateFieldGet(this, _guide));
   }
 
   /**
@@ -385,7 +441,7 @@ export class ManualColumnResize extends BasePlugin {
    * @private
    */
   refreshGuidePosition() {
-    this.guide.style[this.inlineDir] = this.handle.style[this.inlineDir];
+    _classPrivateFieldGet(this, _guide).style[this.inlineDir] = _classPrivateFieldGet(this, _handle).style[this.inlineDir];
   }
 
   /**
@@ -394,8 +450,8 @@ export class ManualColumnResize extends BasePlugin {
    * @private
    */
   hideHandleAndGuide() {
-    removeClass(this.handle, 'active');
-    removeClass(this.guide, 'active');
+    removeClass(_classPrivateFieldGet(this, _handle), 'active');
+    removeClass(_classPrivateFieldGet(this, _guide), 'active');
   }
 
   /**
@@ -439,37 +495,37 @@ export class ManualColumnResize extends BasePlugin {
       this.hot.view.adjustElementsSize(true);
     };
     const resize = (column, forceRender) => {
-      const hookNewSize = this.hot.runHooks('beforeColumnResize', this.newSize, column, true);
+      const hookNewSize = this.hot.runHooks('beforeColumnResize', _classPrivateFieldGet(this, _newSize), column, true);
       if (hookNewSize !== undefined) {
-        this.newSize = hookNewSize;
+        _classPrivateFieldSet(this, _newSize, hookNewSize);
       }
       if (this.hot.getSettings().stretchH === 'all') {
         this.clearManualSize(column);
       } else {
-        this.setManualSize(column, this.newSize); // double click sets by auto row size plugin
+        this.setManualSize(column, _classPrivateFieldGet(this, _newSize)); // double click sets by auto row size plugin
       }
 
       this.saveManualColumnWidths();
-      this.hot.runHooks('afterColumnResize', this.newSize, column, true);
+      this.hot.runHooks('afterColumnResize', _classPrivateFieldGet(this, _newSize), column, true);
       if (forceRender) {
         render();
       }
     };
-    if (this.dblclick >= 2) {
-      const selectedColsLength = this.selectedCols.length;
+    if (_classPrivateFieldGet(this, _dblclick) >= 2) {
+      const selectedColsLength = _classPrivateFieldGet(this, _selectedCols).length;
       if (selectedColsLength > 1) {
-        arrayEach(this.selectedCols, selectedCol => {
+        arrayEach(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol);
         });
         render();
       } else {
-        arrayEach(this.selectedCols, selectedCol => {
+        arrayEach(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol, true);
         });
       }
     }
-    this.dblclick = 0;
-    this.autoresizeTimeout = null;
+    _classPrivateFieldSet(this, _dblclick, 0);
+    _classPrivateFieldSet(this, _autoresizeTimeout, null);
   }
   /**
    * Binds the mouse events.
@@ -485,7 +541,7 @@ export class ManualColumnResize extends BasePlugin {
     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(this.handle, 'contextmenu', () => _classPrivateMethodGet(this, _onContextMenu, _onContextMenu2).call(this));
+    this.eventManager.addEventListener(_classPrivateFieldGet(this, _handle), 'contextmenu', () => _classPrivateMethodGet(this, _onContextMenu, _onContextMenu2).call(this));
   }
   /**
    * Destroys the plugin instance.
@@ -500,20 +556,20 @@ function _onMapInit2() {
   if (typeof loadedManualColumnWidths !== 'undefined') {
     this.hot.batchExecution(() => {
       loadedManualColumnWidths.forEach((width, physicalIndex) => {
-        this.columnWidthsMap.setValueAtIndex(physicalIndex, width);
+        _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalIndex, width);
       });
     }, true);
   } else if (Array.isArray(initialSetting)) {
     this.hot.batchExecution(() => {
       initialSetting.forEach((width, physicalIndex) => {
-        this.columnWidthsMap.setValueAtIndex(physicalIndex, width);
+        _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalIndex, width);
       });
     }, true);
     _classPrivateFieldSet(this, _config, initialSetting);
   } else if (initialSetting === true && Array.isArray(_classPrivateFieldGet(this, _config))) {
     this.hot.batchExecution(() => {
       _classPrivateFieldGet(this, _config).forEach((width, physicalIndex) => {
-        this.columnWidthsMap.setValueAtIndex(physicalIndex, width);
+        _classPrivateFieldGet(this, _columnWidthsMap).setValueAtIndex(physicalIndex, width);
       });
     }, true);
   }
@@ -526,7 +582,7 @@ function _onMouseOver2(event) {
   }
 
   // A "mouseover" action is triggered right after executing "contextmenu" event. It should be ignored.
-  if (this.isTriggeredByRMB === true) {
+  if (_classPrivateFieldGet(this, _isTriggeredByRMB) === true) {
     return;
   }
   if (this.checkIfColumnHeader(event.target)) {
@@ -536,7 +592,7 @@ function _onMouseOver2(event) {
     }
     const colspan = th.getAttribute('colspan');
     if (th && (colspan === null || colspan === '1')) {
-      if (!this.pressed) {
+      if (!_classPrivateFieldGet(this, _pressed)) {
         this.setupHandlePosition(th);
       }
     }
@@ -544,24 +600,24 @@ function _onMouseOver2(event) {
 }
 function _onMouseDown2(event) {
   if (hasClass(event.target, 'manualColumnResizer')) {
-    this.setupHandlePosition(this.currentTH);
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
     this.setupGuidePosition();
-    this.pressed = true;
-    if (this.autoresizeTimeout === null) {
-      this.autoresizeTimeout = setTimeout(() => this.afterMouseDownTimeout(), 500);
-      this.hot._registerTimeout(this.autoresizeTimeout);
+    _classPrivateFieldSet(this, _pressed, true);
+    if (_classPrivateFieldGet(this, _autoresizeTimeout) === null) {
+      _classPrivateFieldSet(this, _autoresizeTimeout, setTimeout(() => this.afterMouseDownTimeout(), 500));
+      this.hot._registerTimeout(_classPrivateFieldGet(this, _autoresizeTimeout));
     }
-    this.dblclick += 1;
+    _classPrivateFieldSet(this, _dblclick, _classPrivateFieldGet(this, _dblclick) + 1);
     this.startX = event.pageX;
-    this.newSize = this.startWidth;
+    _classPrivateFieldSet(this, _newSize, _classPrivateFieldGet(this, _startWidth));
   }
 }
 function _onMouseMove2(event) {
-  if (this.pressed) {
+  if (_classPrivateFieldGet(this, _pressed)) {
     const change = (event.pageX - this.startX) * this.hot.getDirectionFactor();
-    this.currentWidth = this.startWidth + change;
-    arrayEach(this.selectedCols, selectedCol => {
-      this.newSize = this.setManualSize(selectedCol, this.currentWidth);
+    _classPrivateFieldSet(this, _currentWidth, _classPrivateFieldGet(this, _startWidth) + change);
+    arrayEach(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
+      _classPrivateFieldSet(this, _newSize, this.setManualSize(selectedCol, _classPrivateFieldGet(this, _currentWidth)));
     });
     this.refreshHandlePosition();
     this.refreshGuidePosition();
@@ -574,50 +630,50 @@ function _onMouseUp2() {
     this.hot.view.adjustElementsSize(true);
   };
   const resize = (column, forceRender) => {
-    this.hot.runHooks('beforeColumnResize', this.newSize, column, false);
+    this.hot.runHooks('beforeColumnResize', _classPrivateFieldGet(this, _newSize), column, false);
     if (forceRender) {
       render();
     }
     this.saveManualColumnWidths();
-    this.hot.runHooks('afterColumnResize', this.newSize, column, false);
+    this.hot.runHooks('afterColumnResize', _classPrivateFieldGet(this, _newSize), column, false);
   };
-  if (this.pressed) {
+  if (_classPrivateFieldGet(this, _pressed)) {
     this.hideHandleAndGuide();
-    this.pressed = false;
-    if (this.newSize !== this.startWidth) {
-      const selectedColsLength = this.selectedCols.length;
+    _classPrivateFieldSet(this, _pressed, false);
+    if (_classPrivateFieldGet(this, _newSize) !== _classPrivateFieldGet(this, _startWidth)) {
+      const selectedColsLength = _classPrivateFieldGet(this, _selectedCols).length;
       if (selectedColsLength > 1) {
-        arrayEach(this.selectedCols, selectedCol => {
+        arrayEach(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol);
         });
         render();
       } else {
-        arrayEach(this.selectedCols, selectedCol => {
+        arrayEach(_classPrivateFieldGet(this, _selectedCols), selectedCol => {
           resize(selectedCol, true);
         });
       }
     }
-    this.setupHandlePosition(this.currentTH);
+    this.setupHandlePosition(_classPrivateFieldGet(this, _currentTH));
   }
 }
 function _onContextMenu2() {
   this.hideHandleAndGuide();
-  this.hot.rootElement.removeChild(this.handle);
-  this.hot.rootElement.removeChild(this.guide);
-  this.pressed = false;
-  this.isTriggeredByRMB = 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(() => {
-    this.isTriggeredByRMB = false;
+    _classPrivateFieldSet(this, _isTriggeredByRMB, false);
   });
 }
 function _onModifyColWidth2(width, column) {
   let newWidth = width;
   if (this.enabled) {
     const physicalColumn = this.hot.toPhysicalColumn(column);
-    const columnWidth = this.columnWidthsMap.getValueAtIndex(physicalColumn);
+    const columnWidth = _classPrivateFieldGet(this, _columnWidthsMap).getValueAtIndex(physicalColumn);
     if (this.hot.getSettings()[PLUGIN_KEY] && columnWidth) {
       newWidth = columnWidth;
     }
@@ -625,7 +681,7 @@ function _onModifyColWidth2(width, column) {
   return newWidth;
 }
 function _onBeforeStretchingColumnWidth2(stretchedWidth, column) {
-  let width = this.columnWidthsMap.getValueAtIndex(column);
+  let width = _classPrivateFieldGet(this, _columnWidthsMap).getValueAtIndex(column);
   if (width === null) {
     width = stretchedWidth;
   }