handsontable 18.0.0 → 18.1.0-rc7

package/plugins/pagination/pagination.mjs

@@ -915,9 +915,9 @@ function registerFocusScope() {
             const focusableElements = _class_private_field_get(this, _ui)?.getFocusableElements();
             if (focusableElements && focusableElements.length > 0) {
                 if (focusSource === 'tab_from_above') {
-                    focusableElements.at(0)?.focus();
+                    focusableElements[0]?.focus();
                 } else if (focusSource === 'tab_from_below') {
-                    focusableElements.at(-1)?.focus();
+                    focusableElements[focusableElements.length - 1]?.focus();
                 }
             }
         }

package/plugins/search/search.js

@@ -77,7 +77,24 @@ const PLUGIN_KEY = 'search';
 const PLUGIN_PRIORITY = 190;
 const DEFAULT_SEARCH_RESULT_CLASS = 'htSearchResult';
 const DEFAULT_CALLBACK = function(instance, row, col, data, testResult) {
-    instance.getCellMeta(row, col).isSearchResult = testResult;
+    const cellMeta = instance.getCellMeta(row, col);
+    cellMeta.isSearchResult = testResult;
+    // `isSearchResult` is written directly here, not through `setMeta`, so on its own it would be dropped
+    // when the cell is evicted from the viewport (and the highlight lost after scrolling away and back).
+    // Record it in `_persistedMetaProps` for matches so the viewport meta eviction keeps the cell; it
+    // then also shifts with the data on row/column insert/remove, exactly like the meta object itself.
+    // Non-matches are removed from the set so they stay evictable. It is intentionally NOT recorded as
+    // user-defined, so an `updateSettings` cache reset clears it - the next `query()` re-applies it.
+    let persistedMetaProps = cellMeta._persistedMetaProps;
+    if (testResult) {
+        if (persistedMetaProps === undefined) {
+            persistedMetaProps = new Set();
+            cellMeta._persistedMetaProps = persistedMetaProps;
+        }
+        persistedMetaProps.add('isSearchResult');
+    } else {
+        persistedMetaProps?.delete('isSearchResult');
+    }
 };
 const DEFAULT_QUERY_METHOD = function(query, value, cellProperties) {
     if ((0, _mixed.isUndefined)(query) || query === null || !query.toLocaleLowerCase || query.length === 0) {
@@ -278,7 +295,11 @@ class Search extends _base.BasePlugin {
             } else if (Array.isArray(className)) {
                 classArray.push(...className);
             }
-            if (this.isEnabled() && cellProperties.isSearchResult) {
+            // `isSearchResult` is recorded in `_persistedMetaProps` for matches (see the default callback), so
+            // it survives viewport meta eviction and shifts with the cell on row/column changes - reading it
+            // here is enough; no separate match-coordinate set is needed.
+            const isSearchResult = cellProperties.isSearchResult;
+            if (this.isEnabled() && isSearchResult) {
                 if (!classArray.includes(this.searchResultClass)) {
                     classArray.push(`${this.searchResultClass}`);
                 }

package/plugins/search/search.mjs

@@ -56,7 +56,24 @@ export const PLUGIN_KEY = 'search';
 export const PLUGIN_PRIORITY = 190;
 const DEFAULT_SEARCH_RESULT_CLASS = 'htSearchResult';
 const DEFAULT_CALLBACK = function(instance, row, col, data, testResult) {
-    instance.getCellMeta(row, col).isSearchResult = testResult;
+    const cellMeta = instance.getCellMeta(row, col);
+    cellMeta.isSearchResult = testResult;
+    // `isSearchResult` is written directly here, not through `setMeta`, so on its own it would be dropped
+    // when the cell is evicted from the viewport (and the highlight lost after scrolling away and back).
+    // Record it in `_persistedMetaProps` for matches so the viewport meta eviction keeps the cell; it
+    // then also shifts with the data on row/column insert/remove, exactly like the meta object itself.
+    // Non-matches are removed from the set so they stay evictable. It is intentionally NOT recorded as
+    // user-defined, so an `updateSettings` cache reset clears it - the next `query()` re-applies it.
+    let persistedMetaProps = cellMeta._persistedMetaProps;
+    if (testResult) {
+        if (persistedMetaProps === undefined) {
+            persistedMetaProps = new Set();
+            cellMeta._persistedMetaProps = persistedMetaProps;
+        }
+        persistedMetaProps.add('isSearchResult');
+    } else {
+        persistedMetaProps?.delete('isSearchResult');
+    }
 };
 const DEFAULT_QUERY_METHOD = function(query, value, cellProperties) {
     if (isUndefined(query) || query === null || !query.toLocaleLowerCase || query.length === 0) {
@@ -287,7 +304,11 @@ var /**
             } else if (Array.isArray(className)) {
                 classArray.push(...className);
             }
-            if (this.isEnabled() && cellProperties.isSearchResult) {
+            // `isSearchResult` is recorded in `_persistedMetaProps` for matches (see the default callback), so
+            // it survives viewport meta eviction and shifts with the cell on row/column changes - reading it
+            // here is enough; no separate match-coordinate set is needed.
+            const isSearchResult = cellProperties.isSearchResult;
+            if (this.isEnabled() && isSearchResult) {
                 if (!classArray.includes(this.searchResultClass)) {
                     classArray.push(`${this.searchResultClass}`);
                 }

package/plugins/selectionHandles/helpers.d.mts

@@ -0,0 +1 @@
+export * from './helpers.js';

package/plugins/selectionHandles/helpers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Represents the selection edge that the user drags.
+ */
+export type HandleEdge = 'top' | 'bottom' | 'start' | 'end';
+interface ClampEdgeOptions {
+    edge: HandleEdge;
+    target: number;
+    oppositeIndex: number;
+}
+/**
+ * Clamps a dragged edge without allowing it to cross its opposite edge.
+ *
+ * @param {ClampEdgeOptions} options The dragged edge, target index, and opposite index.
+ * @returns {number} The clamped index.
+ */
+export declare function clampEdge({ edge, target, oppositeIndex }: ClampEdgeOptions): number;
+export {};

package/plugins/selectionHandles/helpers.js

@@ -0,0 +1,16 @@
+/**
+ * Represents the selection edge that the user drags.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "clampEdge", {
+    enumerable: true,
+    get: function() {
+        return clampEdge;
+    }
+});
+function clampEdge({ edge, target, oppositeIndex }) {
+    const bounded = Math.max(0, target);
+    return edge === 'top' || edge === 'start' ? Math.min(bounded, oppositeIndex) : Math.max(bounded, oppositeIndex);
+}

package/plugins/selectionHandles/helpers.mjs

@@ -0,0 +1,11 @@
+/**
+ * Represents the selection edge that the user drags.
+ */ /**
+ * Clamps a dragged edge without allowing it to cross its opposite edge.
+ *
+ * @param {ClampEdgeOptions} options The dragged edge, target index, and opposite index.
+ * @returns {number} The clamped index.
+ */ export function clampEdge({ edge, target, oppositeIndex }) {
+    const bounded = Math.max(0, target);
+    return edge === 'top' || edge === 'start' ? Math.min(bounded, oppositeIndex) : Math.max(bounded, oppositeIndex);
+}

package/plugins/selectionHandles/index.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/plugins/selectionHandles/index.d.ts

@@ -0,0 +1 @@
+export { PLUGIN_KEY, PLUGIN_PRIORITY, SelectionHandles, } from './selectionHandles';

package/plugins/selectionHandles/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PLUGIN_KEY () {
+        return _selectionHandles.PLUGIN_KEY;
+    },
+    get PLUGIN_PRIORITY () {
+        return _selectionHandles.PLUGIN_PRIORITY;
+    },
+    get SelectionHandles () {
+        return _selectionHandles.SelectionHandles;
+    }
+});
+const _selectionHandles = require("./selectionHandles");

package/plugins/selectionHandles/index.mjs

@@ -0,0 +1 @@
+export { PLUGIN_KEY, PLUGIN_PRIORITY, SelectionHandles } from './selectionHandles.mjs';

package/plugins/selectionHandles/selectionHandles.d.mts

@@ -0,0 +1 @@
+export * from './selectionHandles.js';

package/plugins/selectionHandles/selectionHandles.d.ts

@@ -0,0 +1,52 @@
+import { BasePlugin } from '../base';
+export declare const PLUGIN_KEY = "selectionHandles";
+export declare const PLUGIN_PRIORITY = 24;
+/**
+ * Enables desktop selection edge handles and their resize interaction.
+ */
+export declare class SelectionHandles extends BasePlugin {
+    #private;
+    /**
+     * Returns the plugin key.
+     */
+    static get PLUGIN_KEY(): string;
+    /**
+     * Returns the plugin priority.
+     */
+    static get PLUGIN_PRIORITY(): number;
+    /**
+     * Returns the settings that trigger a plugin update.
+     */
+    static get SETTING_KEYS(): string[];
+    /**
+     * Checks whether the plugin is enabled in the Handsontable settings.
+     *
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Checks whether a resize drag is currently in progress. Reachable through `getPlugin` because
+     * DragToScroll needs it — it must not start auto-scrolling for a press this plugin rejected — but
+     * internal, not part of the public API.
+     *
+     * @private
+     * @returns {boolean}
+     */
+    isDragActive(): boolean;
+    /**
+     * Enables handle hover and resize interactions.
+     */
+    enablePlugin(): void;
+    /**
+     * Updates the plugin after its setting changes.
+     */
+    updatePlugin(): void;
+    /**
+     * Disables the plugin and clears transient resize state.
+     */
+    disablePlugin(): void;
+    /**
+     * Destroys the plugin and clears an active resize interaction.
+     */
+    destroy(): void;
+}

package/plugins/selectionHandles/selectionHandles.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PLUGIN_KEY () {
+        return PLUGIN_KEY;
+    },
+    get PLUGIN_PRIORITY () {
+        return PLUGIN_PRIORITY;
+    },
+    get SelectionHandles () {
+        return SelectionHandles;
+    }
+});
+const _base = require("../base");
+const _element = require("../../helpers/dom/element");
+const _cellCoords = require("../../helpers/dom/cellCoords");
+const _event = require("../../helpers/dom/event");
+const _helpers = require("./helpers");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(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 _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+const PLUGIN_KEY = 'selectionHandles';
+const PLUGIN_PRIORITY = 24;
+var /**
+   * Stores the active selection resize session.
+   *
+   * @type {object|null}
+   */ _drag = /*#__PURE__*/ new WeakMap(), /**
+   * Stores the last visual cell coordinate under the pointer.
+   */ _lastCoords = /*#__PURE__*/ new WeakMap(), /**
+   * Saves the host cursor while a resize is active.
+   */ _bodyCursor = /*#__PURE__*/ new WeakMap(), /**
+   * Stores the latest pointer position so scrolling can continue the resize.
+   */ _pointerPosition = /*#__PURE__*/ new WeakMap(), /**
+   * Records the topmost range under the pointer.
+   */ _onCellMouseOver = /*#__PURE__*/ new WeakMap(), /**
+   * Starts a selection resize session.
+   */ _onHandleMouseDown = /*#__PURE__*/ new WeakMap(), /**
+   * Applies a resize to the captured selection layer.
+   */ _onMouseMove = /*#__PURE__*/ new WeakMap(), /**
+   * Continues the resize after DragToScroll changes the rendered viewport.
+   */ _onAfterScroll = /*#__PURE__*/ new WeakMap(), /**
+   * Resizes the selected range toward the current pointer coordinates.
+   *
+   * @param {number} clientX The pointer's viewport X coordinate.
+   * @param {number} clientY The pointer's viewport Y coordinate.
+   */ _resizeSelection = /*#__PURE__*/ new WeakSet(), /**
+   * Clears hover state after the pointer leaves the grid.
+   */ _onRootMouseLeave = /*#__PURE__*/ new WeakMap(), /**
+   * Restores handle hover after ordinary selection drags.
+   */ _onDocumentMouseUp = /*#__PURE__*/ new WeakMap(), /**
+   * Ends the active resize session.
+   */ _endDrag = /*#__PURE__*/ new WeakMap();
+class SelectionHandles extends _base.BasePlugin {
+    /**
+   * Returns the plugin key.
+   */ static get PLUGIN_KEY() {
+        return PLUGIN_KEY;
+    }
+    /**
+   * Returns the plugin priority.
+   */ static get PLUGIN_PRIORITY() {
+        return PLUGIN_PRIORITY;
+    }
+    /**
+   * Returns the settings that trigger a plugin update.
+   */ static get SETTING_KEYS() {
+        return [
+            PLUGIN_KEY
+        ];
+    }
+    /**
+   * Checks whether the plugin is enabled in the Handsontable settings.
+   *
+   * @returns {boolean}
+   */ isEnabled() {
+        return this.hot.getSettings()[PLUGIN_KEY] === true;
+    }
+    /**
+   * Checks whether a resize drag is currently in progress. Reachable through `getPlugin` because
+   * DragToScroll needs it — it must not start auto-scrolling for a press this plugin rejected — but
+   * internal, not part of the public API.
+   *
+   * @private
+   * @returns {boolean}
+   */ isDragActive() {
+        return _class_private_field_get(this, _drag) !== null;
+    }
+    /**
+   * Enables handle hover and resize interactions.
+   */ enablePlugin() {
+        if (this.enabled) {
+            return;
+        }
+        this.addHook('afterOnSelectionHandleMouseDown', _class_private_field_get(this, _onHandleMouseDown));
+        this.addHook('beforeOnCellMouseOver', _class_private_field_get(this, _onCellMouseOver));
+        this.addHook('afterScroll', _class_private_field_get(this, _onAfterScroll));
+        this.eventManager.addEventListener(this.hot.rootElement, 'mouseleave', _class_private_field_get(this, _onRootMouseLeave));
+        this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'mouseup', _class_private_field_get(this, _onDocumentMouseUp));
+        super.enablePlugin();
+    }
+    /**
+   * Updates the plugin after its setting changes.
+   */ updatePlugin() {
+        this.disablePlugin();
+        this.enablePlugin();
+        super.updatePlugin();
+    }
+    /**
+   * Disables the plugin and clears transient resize state.
+   */ disablePlugin() {
+        super.disablePlugin();
+        _class_private_field_get(this, _endDrag).call(this);
+        this.hot.selection.setHandlesHoveredLayer(null);
+    }
+    /**
+   * Destroys the plugin and clears an active resize interaction.
+   */ destroy() {
+        _class_private_field_get(this, _endDrag).call(this);
+        super.destroy();
+    }
+    constructor(...args){
+        super(...args), _class_private_method_init(this, _resizeSelection), _class_private_field_init(this, _drag, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _lastCoords, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _bodyCursor, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _pointerPosition, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onCellMouseOver, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onHandleMouseDown, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onMouseMove, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterScroll, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onRootMouseLeave, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onDocumentMouseUp, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _endDrag, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_set(this, _drag, null), _class_private_field_set(this, _lastCoords, null), _class_private_field_set(this, _bodyCursor, ''), _class_private_field_set(this, _pointerPosition, null), _class_private_field_set(this, _onCellMouseOver, (_event, coords)=>{
+            _class_private_field_set(this, _lastCoords, coords);
+            if (!_class_private_field_get(this, _drag)) {
+                this.hot.selection.setHandlesHoveredLayer(this.hot.selection.getLayerContaining(coords));
+            }
+        }), _class_private_field_set(this, _onHandleMouseDown, (event, edge)=>{
+            // A right-press opens the context menu; it must not also start (and on release, commit) a resize.
+            if ((0, _event.isRightClick)(event)) {
+                return;
+            }
+            const selection = this.hot.selection;
+            const layer = selection.getHandlesHoveredLayer() ?? selection.getLayerLevel();
+            const range = selection.getSelectedRange().peekByIndex(layer);
+            if (!range) {
+                return;
+            }
+            const start = range.getTopStartCorner();
+            const end = range.getBottomEndCorner();
+            const focus = range.highlight;
+            const fromRow = start.row;
+            const fromCol = start.col;
+            const toRow = end.row;
+            const toCol = end.col;
+            _class_private_field_set(this, _drag, {
+                edge,
+                layer,
+                fromRow,
+                fromCol,
+                toRow,
+                toCol,
+                focusRow: focus.row ?? fromRow,
+                focusCol: focus.col ?? fromCol
+            });
+            _class_private_field_set(this, _pointerPosition, {
+                clientX: event.clientX,
+                clientY: event.clientY
+            });
+            _class_private_field_set(this, _bodyCursor, this.hot.rootDocument.body.style.cursor);
+            this.hot.rootDocument.body.style.cursor = edge === 'top' || edge === 'bottom' ? 'ns-resize' : 'ew-resize';
+            (0, _element.addClass)(this.hot.rootElement, `ht__resizing-selection--${edge}`);
+            this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'mousemove', _class_private_field_get(this, _onMouseMove));
+            this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'mouseup', _class_private_field_get(this, _endDrag));
+        }), _class_private_field_set(this, _onMouseMove, (event)=>{
+            if (!(event instanceof this.hot.rootWindow.MouseEvent)) {
+                return;
+            }
+            if (!_class_private_field_get(this, _drag)) {
+                return;
+            }
+            _class_private_field_set(this, _pointerPosition, {
+                clientX: event.clientX,
+                clientY: event.clientY
+            });
+            _class_private_method_get(this, _resizeSelection, resizeSelection).call(this, event.clientX, event.clientY);
+        }), _class_private_field_set(this, _onAfterScroll, ()=>{
+            if (_class_private_field_get(this, _drag) && _class_private_field_get(this, _pointerPosition)) {
+                _class_private_method_get(this, _resizeSelection, resizeSelection).call(this, _class_private_field_get(this, _pointerPosition).clientX, _class_private_field_get(this, _pointerPosition).clientY);
+            }
+        }), _class_private_field_set(this, _onRootMouseLeave, ()=>{
+            if (!_class_private_field_get(this, _drag)) {
+                this.hot.selection.setHandlesHoveredLayer(null);
+            }
+        }), _class_private_field_set(this, _onDocumentMouseUp, ()=>{
+            if (!_class_private_field_get(this, _drag) && _class_private_field_get(this, _lastCoords)) {
+                this.hot.selection.setHandlesHoveredLayer(this.hot.selection.getLayerContaining(_class_private_field_get(this, _lastCoords)));
+            }
+        }), _class_private_field_set(this, _endDrag, ()=>{
+            if (!_class_private_field_get(this, _drag)) {
+                return;
+            }
+            _class_private_field_set(this, _drag, null);
+            _class_private_field_set(this, _pointerPosition, null);
+            this.eventManager.removeEventListener(this.hot.rootDocument.documentElement, 'mousemove', _class_private_field_get(this, _onMouseMove));
+            this.eventManager.removeEventListener(this.hot.rootDocument.documentElement, 'mouseup', _class_private_field_get(this, _endDrag));
+            (0, _element.removeClass)(this.hot.rootElement, [
+                'ht__resizing-selection--top',
+                'ht__resizing-selection--bottom',
+                'ht__resizing-selection--start',
+                'ht__resizing-selection--end'
+            ]);
+            this.hot.rootDocument.body.style.cursor = _class_private_field_get(this, _bodyCursor);
+        });
+    }
+}
+function resizeSelection(clientX, clientY) {
+    if (!_class_private_field_get(this, _drag)) {
+        return;
+    }
+    const { edge, layer, fromRow, toRow, fromCol, toCol, focusRow, focusCol } = _class_private_field_get(this, _drag);
+    const pointer = (0, _cellCoords.getCellCoordsFromMousePosition)(this.hot, clientX, clientY);
+    let anchor;
+    let end;
+    if (edge === 'top') {
+        anchor = this.hot._createCellCoords(toRow, toCol);
+        end = this.hot._createCellCoords((0, _helpers.clampEdge)({
+            edge,
+            target: pointer.row,
+            oppositeIndex: toRow
+        }), fromCol);
+    } else if (edge === 'bottom') {
+        anchor = this.hot._createCellCoords(fromRow, fromCol);
+        end = this.hot._createCellCoords((0, _helpers.clampEdge)({
+            edge,
+            target: pointer.row,
+            oppositeIndex: fromRow
+        }), toCol);
+    } else if (edge === 'start') {
+        anchor = this.hot._createCellCoords(toRow, toCol);
+        end = this.hot._createCellCoords(fromRow, (0, _helpers.clampEdge)({
+            edge,
+            target: pointer.col,
+            oppositeIndex: toCol
+        }));
+    } else {
+        anchor = this.hot._createCellCoords(fromRow, fromCol);
+        end = this.hot._createCellCoords(toRow, (0, _helpers.clampEdge)({
+            edge,
+            target: pointer.col,
+            oppositeIndex: fromCol
+        }));
+    }
+    const range = this.hot.selection.getSelectedRange().peekByIndex(layer);
+    if (!range) {
+        return;
+    }
+    const row = Math.min(Math.max(focusRow, Math.min(anchor.row, end.row)), Math.max(anchor.row, end.row));
+    const col = Math.min(Math.max(focusCol, Math.min(anchor.col, end.col)), Math.max(anchor.col, end.col));
+    range.setFrom(anchor);
+    range.setTo(anchor);
+    range.setHighlight(this.hot._createCellCoords(row, col));
+    this.hot.selection.setRangeEnd(end, layer);
+}