handsontable 13.1.0-next-e1a7d2c-20230831 → 14.0.0-next-d97b156-20231027

package/3rdparty/walkontable/src/renderer/rows.js

@@ -5,6 +5,8 @@ var _console = require("./../../../../helpers/console");
 var _templateLiteralTag = require("./../../../../helpers/templateLiteralTag");
 var _orderView = require("./../utils/orderView");
 var _base = _interopRequireDefault(require("./_base"));
+var _element = require("../../../../helpers/dom/element");
+var _a11y = require("../../../../helpers/a11y");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 let performanceWarningAppeared = false;
 
@@ -53,9 +55,20 @@ class RowsRenderer extends _base.default {
       (0, _console.warn)((0, _templateLiteralTag.toSingleLine)`Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting\x20
         the number of rendered rows by specifying the table height and/or turning off the "renderAllRows" option.`);
     }
+    if (this.table.isAriaEnabled()) {
+      (0, _element.setAttribute)(this.rootNode, [(0, _a11y.A11Y_PRESENTATION)()]);
+    }
     this.orderView.setSize(rowsToRender).setOffset(this.table.renderedRowToSource(0)).start();
     for (let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
       this.orderView.render();
+      const TR = this.orderView.getCurrentNode();
+      const sourceRowIndex = this.table.renderedRowToSource(visibleRowIndex);
+      if (this.table.isAriaEnabled()) {
+        var _this$table$rowUtils$, _this$table$rowUtils;
+        (0, _element.setAttribute)(TR, [(0, _a11y.A11Y_ROW)(),
+        // `aria-rowindex` is incremented by both tbody and thead rows.
+        (0, _a11y.A11Y_ROWINDEX)(sourceRowIndex + ((_this$table$rowUtils$ = (_this$table$rowUtils = this.table.rowUtils) === null || _this$table$rowUtils === void 0 || (_this$table$rowUtils = _this$table$rowUtils.dataAccessObject) === null || _this$table$rowUtils === void 0 ? void 0 : _this$table$rowUtils.columnHeaders.length) !== null && _this$table$rowUtils$ !== void 0 ? _this$table$rowUtils$ : 0) + 1)]);
+      }
     }
     this.orderView.end();
   }

package/3rdparty/walkontable/src/renderer/rows.mjs

@@ -2,6 +2,8 @@ import { warn } from "./../../../../helpers/console.mjs";
 import { toSingleLine } from "./../../../../helpers/templateLiteralTag.mjs";
 import { OrderView } from "./../utils/orderView/index.mjs";
 import BaseRenderer from "./_base.mjs";
+import { setAttribute } from "../../../../helpers/dom/element.mjs";
+import { A11Y_PRESENTATION, A11Y_ROW, A11Y_ROWINDEX } from "../../../../helpers/a11y.mjs";
 let performanceWarningAppeared = false;
 
 /**
@@ -49,9 +51,20 @@ export default class RowsRenderer extends BaseRenderer {
       warn(toSingleLine`Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting\x20
         the number of rendered rows by specifying the table height and/or turning off the "renderAllRows" option.`);
     }
+    if (this.table.isAriaEnabled()) {
+      setAttribute(this.rootNode, [A11Y_PRESENTATION()]);
+    }
     this.orderView.setSize(rowsToRender).setOffset(this.table.renderedRowToSource(0)).start();
     for (let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
       this.orderView.render();
+      const TR = this.orderView.getCurrentNode();
+      const sourceRowIndex = this.table.renderedRowToSource(visibleRowIndex);
+      if (this.table.isAriaEnabled()) {
+        var _this$table$rowUtils$, _this$table$rowUtils;
+        setAttribute(TR, [A11Y_ROW(),
+        // `aria-rowindex` is incremented by both tbody and thead rows.
+        A11Y_ROWINDEX(sourceRowIndex + ((_this$table$rowUtils$ = (_this$table$rowUtils = this.table.rowUtils) === null || _this$table$rowUtils === void 0 || (_this$table$rowUtils = _this$table$rowUtils.dataAccessObject) === null || _this$table$rowUtils === void 0 ? void 0 : _this$table$rowUtils.columnHeaders.length) !== null && _this$table$rowUtils$ !== void 0 ? _this$table$rowUtils$ : 0) + 1)]);
+      }
     }
     this.orderView.end();
   }

package/3rdparty/walkontable/src/renderer/table.js

@@ -257,6 +257,15 @@ class TableRenderer {
     return this.columnFilter.renderedToSource(columnIndex);
   }
 
+  /**
+   * Returns `true` if the accessibility-related ARIA tags should be added to the table, `false` otherwise.
+   *
+   * @returns {boolean}
+   */
+  isAriaEnabled() {
+    return this.rowUtils.wtSettings.getSetting('ariaTags');
+  }
+
   /**
    * Renders the table.
    */

package/3rdparty/walkontable/src/renderer/table.mjs

@@ -254,6 +254,15 @@ export default class TableRenderer {
     return this.columnFilter.renderedToSource(columnIndex);
   }
 
+  /**
+   * Returns `true` if the accessibility-related ARIA tags should be added to the table, `false` otherwise.
+   *
+   * @returns {boolean}
+   */
+  isAriaEnabled() {
+    return this.rowUtils.wtSettings.getSetting('ariaTags');
+  }
+
   /**
    * Renders the table.
    */

package/3rdparty/walkontable/src/scroll.js

@@ -88,6 +88,7 @@ class Scroll {
       return false;
     }
     let result = false;
+    column = this.dataAccessObject.wtSettings.getSetting('onBeforeViewportScrollHorizontally', column);
 
     // if there is no fully visible columns use the supporting variable (lastScrolledColumnPos) to
     // determine the snapping direction (left or right)
@@ -137,6 +138,7 @@ class Scroll {
       return false;
     }
     let result = false;
+    row = this.dataAccessObject.wtSettings.getSetting('onBeforeViewportScrollVertically', row);
 
     // if there is no fully visible rows use the supporting variable (lastScrolledRowPos) to
     // determine the snapping direction (top or bottom)
@@ -308,5 +310,4 @@ class Scroll {
     return lastVisibleColumn;
   }
 }
-var _default = Scroll;
-exports.default = _default;
+var _default = exports.default = Scroll;

package/3rdparty/walkontable/src/scroll.mjs

@@ -85,6 +85,7 @@ class Scroll {
       return false;
     }
     let result = false;
+    column = this.dataAccessObject.wtSettings.getSetting('onBeforeViewportScrollHorizontally', column);
 
     // if there is no fully visible columns use the supporting variable (lastScrolledColumnPos) to
     // determine the snapping direction (left or right)
@@ -134,6 +135,7 @@ class Scroll {
       return false;
     }
     let result = false;
+    row = this.dataAccessObject.wtSettings.getSetting('onBeforeViewportScrollVertically', row);
 
     // if there is no fully visible rows use the supporting variable (lastScrolledRowPos) to
     // determine the snapping direction (top or bottom)

package/3rdparty/walkontable/src/{border.js → selection/border/border.js}

@@ -1,10 +1,11 @@
 "use strict";
 
 exports.__esModule = true;
-var _element = require("../../../helpers/dom/element");
-var _event = require("../../../helpers/dom/event");
-var _object = require("../../../helpers/object");
-var _browser = require("../../../helpers/browser");
+var _element = require("../../../../../helpers/dom/element");
+var _event = require("../../../../../helpers/dom/event");
+var _object = require("../../../../../helpers/object");
+var _browser = require("../../../../../helpers/browser");
+var _constants = require("./constants");
 /**
  *
  */
@@ -34,13 +35,7 @@ class Border {
     this.bottomStyle = null;
     this.startStyle = null;
     this.endStyle = null;
-    this.cornerDefaultStyle = {
-      width: '6px',
-      height: '6px',
-      borderWidth: '1px',
-      borderStyle: 'solid',
-      borderColor: '#FFF'
-    };
+    this.cornerDefaultStyle = _constants.CORNER_DEFAULT_STYLE;
     // Offset to moving the corner to be centered relative to the grid.
     this.cornerCenterPointOffset = -(parseInt(this.cornerDefaultStyle.width, 10) / 2);
     this.corner = null;
@@ -250,7 +245,7 @@ class Border {
    * @returns {boolean}
    */
   isPartRange(row, col) {
-    const areaSelection = this.wot.selections.createOrGetArea();
+    const areaSelection = this.wot.selectionManager.getAreaSelection();
     if (areaSelection.cellRange) {
       if (row !== areaSelection.cellRange.to.row || col !== areaSelection.cellRange.to.col) {
         return true;
@@ -673,5 +668,4 @@ class Border {
     this.main.parentNode.removeChild(this.main);
   }
 }
-var _default = Border;
-exports.default = _default;
+var _default = exports.default = Border;

package/3rdparty/walkontable/src/{border.mjs → selection/border/border.mjs}

@@ -1,7 +1,8 @@
-import { addClass, hasClass, removeClass, getComputedStyle, getTrimmingContainer, innerWidth, innerHeight, offset, outerHeight, outerWidth } from "../../../helpers/dom/element.mjs";
-import { stopImmediatePropagation } from "../../../helpers/dom/event.mjs";
-import { objectEach } from "../../../helpers/object.mjs";
-import { isMobileBrowser } from "../../../helpers/browser.mjs";
+import { addClass, hasClass, removeClass, getComputedStyle, getTrimmingContainer, innerWidth, innerHeight, offset, outerHeight, outerWidth } from "../../../../../helpers/dom/element.mjs";
+import { stopImmediatePropagation } from "../../../../../helpers/dom/event.mjs";
+import { objectEach } from "../../../../../helpers/object.mjs";
+import { isMobileBrowser } from "../../../../../helpers/browser.mjs";
+import { CORNER_DEFAULT_STYLE } from "./constants.mjs";
 /**
  *
  */
@@ -31,13 +32,7 @@ class Border {
     this.bottomStyle = null;
     this.startStyle = null;
     this.endStyle = null;
-    this.cornerDefaultStyle = {
-      width: '6px',
-      height: '6px',
-      borderWidth: '1px',
-      borderStyle: 'solid',
-      borderColor: '#FFF'
-    };
+    this.cornerDefaultStyle = CORNER_DEFAULT_STYLE;
     // Offset to moving the corner to be centered relative to the grid.
     this.cornerCenterPointOffset = -(parseInt(this.cornerDefaultStyle.width, 10) / 2);
     this.corner = null;
@@ -247,7 +242,7 @@ class Border {
    * @returns {boolean}
    */
   isPartRange(row, col) {
-    const areaSelection = this.wot.selections.createOrGetArea();
+    const areaSelection = this.wot.selectionManager.getAreaSelection();
     if (areaSelection.cellRange) {
       if (row !== areaSelection.cellRange.to.row || col !== areaSelection.cellRange.to.col) {
         return true;

package/3rdparty/walkontable/src/selection/border/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+/**
+ * Default border corner style.
+ *
+ * @type {object}
+ */
+const CORNER_DEFAULT_STYLE = exports.CORNER_DEFAULT_STYLE = Object.freeze({
+  width: '6px',
+  height: '6px',
+  borderWidth: '1px',
+  borderStyle: 'solid',
+  borderColor: '#FFF'
+});

package/3rdparty/walkontable/src/selection/border/constants.mjs

@@ -0,0 +1,12 @@
+/**
+ * Default border corner style.
+ *
+ * @type {object}
+ */
+export const CORNER_DEFAULT_STYLE = Object.freeze({
+  width: '6px',
+  height: '6px',
+  borderWidth: '1px',
+  borderStyle: 'solid',
+  borderColor: '#FFF'
+});

package/3rdparty/walkontable/src/selection/constants.js

@@ -0,0 +1,54 @@
+"use strict";
+
+exports.__esModule = true;
+/**
+ * Selection type that is visible only if the row or column header is clicked. If that happened
+ * all row or column header layers are highlighted.
+ *
+ * @type {string}
+ */
+const ACTIVE_HEADER_TYPE = exports.ACTIVE_HEADER_TYPE = 'active-header';
+/**
+ * Selection type that is visible only if the a cell or cells are clicked. If that happened
+ * only the most closest to the cells row or column header is highlighted.
+ *
+ * @type {string}
+ */
+const HEADER_TYPE = exports.HEADER_TYPE = 'header';
+/**
+ * Selection type that is visible when a cell or cells are clicked. The selected cells are
+ * highlighted.
+ *
+ * @type {string}
+ */
+const AREA_TYPE = exports.AREA_TYPE = 'area';
+/**
+ * Selection type defines a cell that follows the user (keyboard navigation).
+ *
+ * @type {string}
+ */
+const FOCUS_TYPE = exports.FOCUS_TYPE = 'focus';
+/**
+ * Selection type defines borders for the autofill functionality.
+ *
+ * @type {string}
+ */
+const FILL_TYPE = exports.FILL_TYPE = 'fill';
+/**
+ * Selection type defines highlights for the `currentRowClassName` option.
+ *
+ * @type {string}
+ */
+const ROW_TYPE = exports.ROW_TYPE = 'row';
+/**
+ * Selection type defines highlights for the `currentColumnClassName` option.
+ *
+ * @type {string}
+ */
+const COLUMN_TYPE = exports.COLUMN_TYPE = 'column';
+/**
+ * Selection type defines highlights managed by the CustomBorders plugin.
+ *
+ * @type {string}
+ */
+const CUSTOM_SELECTION_TYPE = exports.CUSTOM_SELECTION_TYPE = 'custom-selection';

package/3rdparty/walkontable/src/selection/constants.mjs

@@ -0,0 +1,51 @@
+/**
+ * Selection type that is visible only if the row or column header is clicked. If that happened
+ * all row or column header layers are highlighted.
+ *
+ * @type {string}
+ */
+export const ACTIVE_HEADER_TYPE = 'active-header';
+/**
+ * Selection type that is visible only if the a cell or cells are clicked. If that happened
+ * only the most closest to the cells row or column header is highlighted.
+ *
+ * @type {string}
+ */
+export const HEADER_TYPE = 'header';
+/**
+ * Selection type that is visible when a cell or cells are clicked. The selected cells are
+ * highlighted.
+ *
+ * @type {string}
+ */
+export const AREA_TYPE = 'area';
+/**
+ * Selection type defines a cell that follows the user (keyboard navigation).
+ *
+ * @type {string}
+ */
+export const FOCUS_TYPE = 'focus';
+/**
+ * Selection type defines borders for the autofill functionality.
+ *
+ * @type {string}
+ */
+export const FILL_TYPE = 'fill';
+/**
+ * Selection type defines highlights for the `currentRowClassName` option.
+ *
+ * @type {string}
+ */
+export const ROW_TYPE = 'row';
+/**
+ * Selection type defines highlights for the `currentColumnClassName` option.
+ *
+ * @type {string}
+ */
+export const COLUMN_TYPE = 'column';
+/**
+ * Selection type defines highlights managed by the CustomBorders plugin.
+ *
+ * @type {string}
+ */
+export const CUSTOM_SELECTION_TYPE = 'custom-selection';

package/3rdparty/walkontable/src/selection/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+var _exportNames = {
+  SelectionManager: true,
+  Selection: true
+};
+var _selection = _interopRequireDefault(require("./selection"));
+exports.Selection = _selection.default;
+var _constants = require("./constants");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  exports[key] = _constants[key];
+});
+var _constants2 = require("./border/constants");
+Object.keys(_constants2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants2[key]) return;
+  exports[key] = _constants2[key];
+});
+var _manager = require("./manager");
+exports.SelectionManager = _manager.SelectionManager;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/3rdparty/walkontable/src/selection/index.mjs

@@ -0,0 +1,5 @@
+import Selection from "./selection.mjs";
+export * from "./constants.mjs";
+export * from "./border/constants.mjs";
+export { SelectionManager } from "./manager.mjs";
+export { Selection };

package/3rdparty/walkontable/src/selection/manager.js

@@ -0,0 +1,274 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.array.unscopables.flat.js");
+require("core-js/modules/es.error.cause.js");
+var _element = require("../../../../helpers/dom/element");
+var _scanner2 = require("./scanner");
+var _border = _interopRequireDefault(require("./border/border"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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 _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 _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+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; } }
+/**
+ * Module responsible for rendering selections (CSS classes) and borders based on the
+ * collection of the Selection instances provided throughout the `selections` Walkontable
+ * setting.
+ *
+ * @private
+ */
+var _activeOverlaysWot = /*#__PURE__*/new WeakMap();
+var _selections = /*#__PURE__*/new WeakMap();
+var _scanner = /*#__PURE__*/new WeakMap();
+var _appliedClasses = /*#__PURE__*/new WeakMap();
+var _destroyListeners = /*#__PURE__*/new WeakMap();
+var _selectionBorders = /*#__PURE__*/new WeakMap();
+var _resetCells = /*#__PURE__*/new WeakSet();
+class SelectionManager {
+  constructor(selections) {
+    /**
+     * Resets the elements to their initial state (remove the CSS classes that are added in the
+     * previous render cycle).
+     */
+    _classPrivateMethodInitSpec(this, _resetCells);
+    /**
+     * The overlay's Walkontable instance that are currently processed.
+     *
+     * @type {Walkontable}
+     */
+    _classPrivateFieldInitSpec(this, _activeOverlaysWot, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The Highlight instance that holds Selections instances within it.
+     *
+     * @type {Highlight|null}
+     */
+    _classPrivateFieldInitSpec(this, _selections, {
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The SelectionScanner allows to scan and collect the cell and header elements that matches
+     * to the coords defined in the selections.
+     *
+     * @type {SelectionScanner}
+     */
+    _classPrivateFieldInitSpec(this, _scanner, {
+      writable: true,
+      value: new _scanner2.SelectionScanner()
+    });
+    /**
+     * The Map tracks applied CSS classes. It's used to reset the elements state to their initial state.
+     *
+     * @type {WeakMap}
+     */
+    _classPrivateFieldInitSpec(this, _appliedClasses, {
+      writable: true,
+      value: new WeakMap()
+    });
+    /**
+     * The Map tracks applied "destroy" listeners for Selection instances.
+     *
+     * @type {WeakMap}
+     */
+    _classPrivateFieldInitSpec(this, _destroyListeners, {
+      writable: true,
+      value: new WeakSet()
+    });
+    /**
+     * The Map holds references to Border classes for Selection instances which requires that when
+     * the "border" setting is defined.
+     *
+     * @type {Map}
+     */
+    _classPrivateFieldInitSpec(this, _selectionBorders, {
+      writable: true,
+      value: new Map()
+    });
+    _classPrivateFieldSet(this, _selections, selections);
+  }
+
+  /**
+   * Sets the active Walkontable instance.
+   *
+   * @param {Walkontable} activeWot The overlays or master Walkontable instance.
+   * @returns {SelectionManager}
+   */
+  setActiveOverlay(activeWot) {
+    _classPrivateFieldSet(this, _activeOverlaysWot, activeWot);
+    _classPrivateFieldGet(this, _scanner).setActiveOverlay(_classPrivateFieldGet(this, _activeOverlaysWot));
+    if (!_classPrivateFieldGet(this, _appliedClasses).has(_classPrivateFieldGet(this, _activeOverlaysWot))) {
+      _classPrivateFieldGet(this, _appliedClasses).set(_classPrivateFieldGet(this, _activeOverlaysWot), new Set());
+    }
+    return this;
+  }
+
+  /**
+   * Gets the Selection instance of the "focus" type.
+   *
+   * @returns {Selection|null}
+   */
+  getFocusSelection() {
+    return _classPrivateFieldGet(this, _selections) !== null ? _classPrivateFieldGet(this, _selections).getFocus() : null;
+  }
+
+  /**
+   * Gets the Selection instance of the "area" type.
+   *
+   * @returns {Selection|null}
+   */
+  getAreaSelection() {
+    return _classPrivateFieldGet(this, _selections) !== null ? _classPrivateFieldGet(this, _selections).createLayeredArea() : null;
+  }
+
+  /**
+   * Gets the Border instance associated with Selection instance.
+   *
+   * @param {Selection} selection The selection instance.
+   * @returns {Border|null} Returns the Border instance (new for each overlay Walkontable instance).
+   */
+  getBorderInstance(selection) {
+    if (!selection.settings.border) {
+      return null;
+    }
+    if (_classPrivateFieldGet(this, _selectionBorders).has(selection)) {
+      const borders = _classPrivateFieldGet(this, _selectionBorders).get(selection);
+      if (borders.has(_classPrivateFieldGet(this, _activeOverlaysWot))) {
+        return borders.get(_classPrivateFieldGet(this, _activeOverlaysWot));
+      }
+      const border = new _border.default(_classPrivateFieldGet(this, _activeOverlaysWot), selection.settings);
+      borders.set(_classPrivateFieldGet(this, _activeOverlaysWot), border);
+      return border;
+    }
+    const border = new _border.default(_classPrivateFieldGet(this, _activeOverlaysWot), selection.settings);
+    _classPrivateFieldGet(this, _selectionBorders).set(selection, new Map([[_classPrivateFieldGet(this, _activeOverlaysWot), border]]));
+    return border;
+  }
+
+  /**
+   * Gets all Border instances associated with Selection instance for all overlays.
+   *
+   * @param {Selection} selection The selection instance.
+   * @returns {Border[]}
+   */
+  getBorderInstances(selection) {
+    var _classPrivateFieldGet2, _classPrivateFieldGet3;
+    return Array.from((_classPrivateFieldGet2 = (_classPrivateFieldGet3 = _classPrivateFieldGet(this, _selectionBorders).get(selection)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.values()) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : []);
+  }
+
+  /**
+   * Destroys the Border instance associated with Selection instance.
+   *
+   * @param {Selection} selection The selection instance.
+   */
+  destroyBorders(selection) {
+    _classPrivateFieldGet(this, _selectionBorders).get(selection).forEach(border => border.destroy());
+    _classPrivateFieldGet(this, _selectionBorders).delete(selection);
+  }
+
+  /**
+   * Renders all the selections (add CSS classes to cells and draw borders).
+   *
+   * @param {boolean} fastDraw Indicates the render cycle type (fast/slow).
+   */
+  render(fastDraw) {
+    if (_classPrivateFieldGet(this, _selections) === null) {
+      return;
+    }
+    if (fastDraw) {
+      // there was no rerender, so we need to remove classNames by ourselves
+      _classPrivateMethodGet(this, _resetCells, _resetCells2).call(this);
+    }
+    const selections = Array.from(_classPrivateFieldGet(this, _selections));
+    const classNamesMap = new Map();
+    for (let i = 0; i < selections.length; i++) {
+      const selection = selections[i];
+      const {
+        className,
+        createLayers,
+        selectionType
+      } = selection.settings;
+      if (!_classPrivateFieldGet(this, _destroyListeners).has(selection)) {
+        _classPrivateFieldGet(this, _destroyListeners).add(selection);
+        selection.addLocalHook('destroy', () => this.destroyBorders(selection));
+      }
+      const borderInstance = this.getBorderInstance(selection);
+      if (selection.isEmpty()) {
+        borderInstance === null || borderInstance === void 0 || borderInstance.disappear();
+        continue; // eslint-disable-line no-continue
+      }
+
+      if (className) {
+        const elements = _classPrivateFieldGet(this, _scanner).setActiveSelection(selection).scan();
+        elements.forEach(element => {
+          if (classNamesMap.has(element)) {
+            const classNamesLayers = classNamesMap.get(element);
+            if (classNamesLayers.has(className) && createLayers === true) {
+              classNamesLayers.set(className, classNamesLayers.get(className) + 1);
+            } else {
+              classNamesLayers.set(className, 1);
+            }
+          } else {
+            classNamesMap.set(element, new Map([[className, 1]]));
+          }
+        });
+      }
+      const corners = selection.getCorners();
+      _classPrivateFieldGet(this, _activeOverlaysWot).getSetting('onBeforeDrawBorders', corners, selectionType);
+      borderInstance === null || borderInstance === void 0 || borderInstance.appear(corners);
+    }
+    classNamesMap.forEach((classNamesLayers, element) => {
+      var _classPrivateFieldGet4, _classPrivateFieldGet5;
+      const classNames = Array.from(classNamesLayers).map(_ref => {
+        let [className, occurrenceCount] = _ref;
+        if (occurrenceCount === 1) {
+          return className;
+        }
+        return [className, ...Array.from({
+          length: occurrenceCount - 1
+        }, (_, i) => `${className}-${i + 1}`)];
+      }).flat();
+      classNames.forEach(className => _classPrivateFieldGet(this, _appliedClasses).get(_classPrivateFieldGet(this, _activeOverlaysWot)).add(className));
+      (0, _element.addClass)(element, classNames);
+      if (element.nodeName === 'TD' && Array.isArray((_classPrivateFieldGet4 = _classPrivateFieldGet(this, _selections).options) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.cellAttributes)) {
+        (0, _element.setAttribute)(element, _classPrivateFieldGet(this, _selections).options.cellAttributes);
+      } else if (element.nodeName === 'TH' && Array.isArray((_classPrivateFieldGet5 = _classPrivateFieldGet(this, _selections).options) === null || _classPrivateFieldGet5 === void 0 ? void 0 : _classPrivateFieldGet5.headerAttributes)) {
+        (0, _element.setAttribute)(element, _classPrivateFieldGet(this, _selections).options.headerAttributes);
+      }
+    });
+  }
+}
+exports.SelectionManager = SelectionManager;
+function _resetCells2() {
+  const appliedOverlaysClasses = _classPrivateFieldGet(this, _appliedClasses).get(_classPrivateFieldGet(this, _activeOverlaysWot));
+  const classesToRemove = _classPrivateFieldGet(this, _activeOverlaysWot).wtSettings.getSetting('onBeforeRemoveCellClassNames');
+  if (Array.isArray(classesToRemove)) {
+    for (let i = 0; i < classesToRemove.length; i++) {
+      appliedOverlaysClasses.add(classesToRemove[i]);
+    }
+  }
+  appliedOverlaysClasses.forEach(className => {
+    var _classPrivateFieldGet6, _classPrivateFieldGet7;
+    const nodes = _classPrivateFieldGet(this, _activeOverlaysWot).wtTable.TABLE.querySelectorAll(`.${className}`);
+    let cellAttributes = [];
+    if (Array.isArray((_classPrivateFieldGet6 = _classPrivateFieldGet(this, _selections).options) === null || _classPrivateFieldGet6 === void 0 ? void 0 : _classPrivateFieldGet6.cellAttributes)) {
+      cellAttributes = _classPrivateFieldGet(this, _selections).options.cellAttributes.map(el => el[0]);
+    }
+    if (Array.isArray((_classPrivateFieldGet7 = _classPrivateFieldGet(this, _selections).options) === null || _classPrivateFieldGet7 === void 0 ? void 0 : _classPrivateFieldGet7.headerAttributes)) {
+      cellAttributes = [...cellAttributes, ..._classPrivateFieldGet(this, _selections).options.headerAttributes.map(el => el[0])];
+    }
+    for (let i = 0, len = nodes.length; i < len; i++) {
+      (0, _element.removeClass)(nodes[i], className);
+      (0, _element.removeAttribute)(nodes[i], cellAttributes);
+    }
+  });
+  appliedOverlaysClasses.clear();
+}