handsontable 0.0.0-next-221e46b-20240307 → 0.0.0-next-200799f-20240311

package/plugins/mergeCells/cellsCollection.js

@@ -3,6 +3,7 @@
 exports.__esModule = true;
 require("core-js/modules/es.array.push.js");
 require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.array.unscopables.flat-map.js");
 var _cellCoords = _interopRequireDefault(require("./cellCoords"));
 var _number = require("../../helpers/number");
 var _console = require("../../helpers/console");
@@ -10,17 +11,30 @@ var _array = require("../../helpers/array");
 var _utils = require("./utils");
 var _templateLiteralTag = require("../../helpers/templateLiteralTag");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 /**
  * Defines a container object for the merged cells.
  *
  * @private
  * @class MergedCellsCollection
  */
+var _getNonIntersectingIndexes = /*#__PURE__*/new WeakSet();
 class MergedCellsCollection {
   constructor(mergeCellsPlugin) {
+    /**
+     * Gets the list of the indexes that do not intersect with other merged cells within the provided range.
+     *
+     * @param {CellRange} range The range to search within.
+     * @param {'row' | 'col'} axis The axis to search within.
+     * @param {number} scanDirection  The direction to scan the range. `1` for forward, `-1` for backward.
+     * @returns {number[]}
+     */
+    _classPrivateMethodInitSpec(this, _getNonIntersectingIndexes);
     /**
      * Reference to the Merge Cells plugin.
      *
@@ -259,6 +273,81 @@ class MergedCellsCollection {
     return this.hot._createCellCoords(firstRenderableRow, firstRenderableColumn);
   }
 
+  /**
+   * Gets the start-most visual column index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualColumnIndex The visual column index to start the search from.
+   * @returns {number}
+   */
+  getStartMostColumnIndex(range, visualColumnIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'col', -1);
+    let startMostIndex = visualColumnIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] <= visualColumnIndex) {
+        startMostIndex = indexes[i];
+        break;
+      }
+    }
+    return startMostIndex;
+  }
+
+  /**
+   * Gets the end-most visual column index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualColumnIndex The visual column index to start the search from.
+   * @returns {number}
+   */
+  getEndMostColumnIndex(range, visualColumnIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'col', 1);
+    let endMostIndex = visualColumnIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] >= visualColumnIndex) {
+        endMostIndex = indexes[i];
+        break;
+      }
+    }
+    return endMostIndex;
+  }
+
+  /**
+   * Gets the top-most visual row index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualRowIndex The visual row index to start the search from.
+   * @returns {number}
+   */
+  getTopMostRowIndex(range, visualRowIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'row', -1);
+    let topMostIndex = visualRowIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] <= visualRowIndex) {
+        topMostIndex = indexes[i];
+        break;
+      }
+    }
+    return topMostIndex;
+  }
+
+  /**
+   * Gets the bottom-most visual row index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualRowIndex The visual row index to start the search from.
+   * @returns {number}
+   */
+  getBottomMostRowIndex(range, visualRowIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'row', 1);
+    let bottomMostIndex = visualRowIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] >= visualRowIndex) {
+        bottomMostIndex = indexes[i];
+        break;
+      }
+    }
+    return bottomMostIndex;
+  }
   /**
    * Shift the merged cell in the direction and by an offset defined in the arguments.
    *
@@ -294,4 +383,31 @@ class MergedCellsCollection {
     });
   }
 }
+function _getNonIntersectingIndexes2(range, axis) {
+  let scanDirection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  const indexes = new Map();
+  const from = scanDirection === 1 ? range.getTopStartCorner() : range.getBottomEndCorner();
+  const to = scanDirection === 1 ? range.getBottomEndCorner() : range.getTopStartCorner();
+  for (let row = from.row; scanDirection === 1 ? row <= to.row : row >= to.row; row += scanDirection) {
+    for (let column = from.col; scanDirection === 1 ? column <= to.col : column >= to.col; column += scanDirection) {
+      const index = axis === 'row' ? row : column;
+      const mergedCell = this.get(row, column);
+      let lastIndex = index;
+      if (mergedCell) {
+        lastIndex = scanDirection === 1 ? mergedCell[axis] + mergedCell[`${axis}span`] - 1 : mergedCell[axis];
+      }
+      if (!indexes.has(index)) {
+        indexes.set(index, new Set());
+      }
+      indexes.get(index).add(lastIndex);
+    }
+  }
+  return Array.from(new Set(Array.from(indexes.entries()).filter(_ref => {
+    let [, set] = _ref;
+    return set.size === 1;
+  }).flatMap(_ref2 => {
+    let [, set] = _ref2;
+    return Array.from(set);
+  })));
+}
 var _default = exports.default = MergedCellsCollection;

package/plugins/mergeCells/cellsCollection.mjs

@@ -1,8 +1,12 @@
 import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.array.unscopables.flat-map.js";
 import "core-js/modules/es.error.cause.js";
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 import MergedCellCoords from "./cellCoords.mjs";
 import { rangeEach, rangeEachReverse } from "../../helpers/number.mjs";
 import { warn } from "../../helpers/console.mjs";
@@ -15,8 +19,18 @@ import { toSingleLine } from "../../helpers/templateLiteralTag.mjs";
  * @private
  * @class MergedCellsCollection
  */
+var _getNonIntersectingIndexes = /*#__PURE__*/new WeakSet();
 class MergedCellsCollection {
   constructor(mergeCellsPlugin) {
+    /**
+     * Gets the list of the indexes that do not intersect with other merged cells within the provided range.
+     *
+     * @param {CellRange} range The range to search within.
+     * @param {'row' | 'col'} axis The axis to search within.
+     * @param {number} scanDirection  The direction to scan the range. `1` for forward, `-1` for backward.
+     * @returns {number[]}
+     */
+    _classPrivateMethodInitSpec(this, _getNonIntersectingIndexes);
     /**
      * Reference to the Merge Cells plugin.
      *
@@ -255,6 +269,81 @@ class MergedCellsCollection {
     return this.hot._createCellCoords(firstRenderableRow, firstRenderableColumn);
   }
 
+  /**
+   * Gets the start-most visual column index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualColumnIndex The visual column index to start the search from.
+   * @returns {number}
+   */
+  getStartMostColumnIndex(range, visualColumnIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'col', -1);
+    let startMostIndex = visualColumnIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] <= visualColumnIndex) {
+        startMostIndex = indexes[i];
+        break;
+      }
+    }
+    return startMostIndex;
+  }
+
+  /**
+   * Gets the end-most visual column index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualColumnIndex The visual column index to start the search from.
+   * @returns {number}
+   */
+  getEndMostColumnIndex(range, visualColumnIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'col', 1);
+    let endMostIndex = visualColumnIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] >= visualColumnIndex) {
+        endMostIndex = indexes[i];
+        break;
+      }
+    }
+    return endMostIndex;
+  }
+
+  /**
+   * Gets the top-most visual row index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualRowIndex The visual row index to start the search from.
+   * @returns {number}
+   */
+  getTopMostRowIndex(range, visualRowIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'row', -1);
+    let topMostIndex = visualRowIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] <= visualRowIndex) {
+        topMostIndex = indexes[i];
+        break;
+      }
+    }
+    return topMostIndex;
+  }
+
+  /**
+   * Gets the bottom-most visual row index that do not intersect with other merged cells within the provided range.
+   *
+   * @param {CellRange} range The range to search within.
+   * @param {number} visualRowIndex The visual row index to start the search from.
+   * @returns {number}
+   */
+  getBottomMostRowIndex(range, visualRowIndex) {
+    const indexes = _classPrivateMethodGet(this, _getNonIntersectingIndexes, _getNonIntersectingIndexes2).call(this, range, 'row', 1);
+    let bottomMostIndex = visualRowIndex;
+    for (let i = 0; i < indexes.length; i++) {
+      if (indexes[i] >= visualRowIndex) {
+        bottomMostIndex = indexes[i];
+        break;
+      }
+    }
+    return bottomMostIndex;
+  }
   /**
    * Shift the merged cell in the direction and by an offset defined in the arguments.
    *
@@ -290,4 +379,31 @@ class MergedCellsCollection {
     });
   }
 }
+function _getNonIntersectingIndexes2(range, axis) {
+  let scanDirection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  const indexes = new Map();
+  const from = scanDirection === 1 ? range.getTopStartCorner() : range.getBottomEndCorner();
+  const to = scanDirection === 1 ? range.getBottomEndCorner() : range.getTopStartCorner();
+  for (let row = from.row; scanDirection === 1 ? row <= to.row : row >= to.row; row += scanDirection) {
+    for (let column = from.col; scanDirection === 1 ? column <= to.col : column >= to.col; column += scanDirection) {
+      const index = axis === 'row' ? row : column;
+      const mergedCell = this.get(row, column);
+      let lastIndex = index;
+      if (mergedCell) {
+        lastIndex = scanDirection === 1 ? mergedCell[axis] + mergedCell[`${axis}span`] - 1 : mergedCell[axis];
+      }
+      if (!indexes.has(index)) {
+        indexes.set(index, new Set());
+      }
+      indexes.get(index).add(lastIndex);
+    }
+  }
+  return Array.from(new Set(Array.from(indexes.entries()).filter(_ref => {
+    let [, set] = _ref;
+    return set.size === 1;
+  }).flatMap(_ref2 => {
+    let [, set] = _ref2;
+    return Array.from(set);
+  })));
+}
 export default MergedCellsCollection;

package/plugins/mergeCells/contextMenuItem/toggleMerge.js

@@ -25,7 +25,17 @@ function toggleMergeItem(plugin) {
       return this.getTranslatedPhrase(C.CONTEXTMENU_ITEMS_MERGE_CELLS);
     },
     callback() {
-      plugin.toggleMergeOnSelection();
+      const currentRange = this.getSelectedRangeLast();
+      if (!currentRange) {
+        return;
+      }
+      currentRange.setDirection(this.isRtl() ? 'NE-SW' : 'NW-SE');
+      const {
+        from,
+        to
+      } = currentRange;
+      plugin.toggleMerge(currentRange);
+      this.selectCell(from.row, from.col, to.row, to.col, false);
     },
     disabled() {
       const sel = this.getSelectedLast();

package/plugins/mergeCells/contextMenuItem/toggleMerge.mjs

@@ -18,7 +18,17 @@ export default function toggleMergeItem(plugin) {
       return this.getTranslatedPhrase(C.CONTEXTMENU_ITEMS_MERGE_CELLS);
     },
     callback() {
-      plugin.toggleMergeOnSelection();
+      const currentRange = this.getSelectedRangeLast();
+      if (!currentRange) {
+        return;
+      }
+      currentRange.setDirection(this.isRtl() ? 'NE-SW' : 'NW-SE');
+      const {
+        from,
+        to
+      } = currentRange;
+      plugin.toggleMerge(currentRange);
+      this.selectCell(from.row, from.col, to.row, to.col, false);
     },
     disabled() {
       const sel = this.getSelectedLast();

package/plugins/mergeCells/focusOrder.js

@@ -0,0 +1,258 @@
+"use strict";
+
+exports.__esModule = true;
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.array.push.js");
+var _linkedList = _interopRequireDefault(require("../../utils/dataStructures/linkedList"));
+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; } }
+/**
+ * Class responsible for providing the correct focus order (vertical and horizontal) within a selection that
+ * contains merged cells.
+ */
+var _cellsHorizontalOrder = /*#__PURE__*/new WeakMap();
+var _cellsVerticalOrder = /*#__PURE__*/new WeakMap();
+var _currentHorizontalLinkedNode = /*#__PURE__*/new WeakMap();
+var _currentVerticalLinkedNode = /*#__PURE__*/new WeakMap();
+var _mergedCellsGetter = /*#__PURE__*/new WeakMap();
+var _pushOrderNode = /*#__PURE__*/new WeakSet();
+class FocusOrder {
+  constructor(mergedCellsGetter) {
+    /**
+     * Pushes a new node to the provided list order.
+     *
+     * @param {CellRange} selectedRange The selected range to build the focus order for.
+     * @param {LinkedList} listOrder The list order to push the node to.
+     * @param {WeakSet} mergeCellsVisitor The set of visited cells.
+     * @param {number} row The visual row index.
+     * @param {number} column The visual column index.
+     * @returns {NodeStructure | null}
+     */
+    _classPrivateMethodInitSpec(this, _pushOrderNode);
+    /**
+     * The linked list of the all cells within the current selection in horizontal order. The list is
+     * recreated every time the selection is changed.
+     *
+     * @type {LinkedList}
+     */
+    _classPrivateFieldInitSpec(this, _cellsHorizontalOrder, {
+      writable: true,
+      value: new _linkedList.default()
+    });
+    /**
+     * The linked list of the all cells within the current selection in horizontal order. The list is
+     * recreated every time the selection is changed.
+     *
+     * @type {LinkedList}
+     */
+    _classPrivateFieldInitSpec(this, _cellsVerticalOrder, {
+      writable: true,
+      value: new _linkedList.default()
+    });
+    /**
+     * The currently highlighted cell within the horizontal linked list.
+     *
+     * @type {NodeStructure | null}
+     */
+    _classPrivateFieldInitSpec(this, _currentHorizontalLinkedNode, {
+      writable: true,
+      value: null
+    });
+    /**
+     * The currently highlighted cell within the vertical linked list.
+     *
+     * @type {NodeStructure | null}
+     */
+    _classPrivateFieldInitSpec(this, _currentVerticalLinkedNode, {
+      writable: true,
+      value: null
+    });
+    /**
+     * The merged cells getter function.
+     *
+     * @type {function(): {row: number, col: number, rowspan: number, colspan: number} | null}}
+     */
+    _classPrivateFieldInitSpec(this, _mergedCellsGetter, {
+      writable: true,
+      value: null
+    });
+    _classPrivateFieldSet(this, _mergedCellsGetter, mergedCellsGetter);
+  }
+
+  /**
+   * Gets the currently selected node data from the vertical focus order list.
+   *
+   * @returns {NodeStructure}
+   */
+  getCurrentVerticalNode() {
+    return _classPrivateFieldGet(this, _currentVerticalLinkedNode).data;
+  }
+
+  /**
+   * Gets the next selected node data from the vertical focus order list.
+   *
+   * @returns {NodeStructure}
+   */
+  getNextVerticalNode() {
+    return _classPrivateFieldGet(this, _currentVerticalLinkedNode).next.data;
+  }
+
+  /**
+   * Gets the previous selected node data from the vertical focus order list.
+   *
+   * @returns {NodeStructure}
+   */
+  getPrevVerticalNode() {
+    return _classPrivateFieldGet(this, _currentVerticalLinkedNode).prev.data;
+  }
+
+  /**
+   * Gets the currently selected node data from the horizontal focus order list.
+   *
+   * @returns {NodeStructure}
+   */
+  getCurrentHorizontalNode() {
+    return _classPrivateFieldGet(this, _currentHorizontalLinkedNode).data;
+  }
+
+  /**
+   * Gets the next selected node data from the horizontal focus order list.
+   *
+   * @returns {NodeStructure}
+   */
+  getNextHorizontalNode() {
+    return _classPrivateFieldGet(this, _currentHorizontalLinkedNode).next.data;
+  }
+
+  /**
+   * Gets the previous selected node data from the horizontal focus order list.
+   *
+   * @returns {NodeStructure}
+   */
+  getPrevHorizontalNode() {
+    return _classPrivateFieldGet(this, _currentHorizontalLinkedNode).prev.data;
+  }
+
+  /**
+   * Rebuilds the focus order list based on the provided selection.
+   *
+   * @param {CellRange} selectedRange The selected range to build the focus order for.
+   */
+  buildFocusOrder(selectedRange) {
+    const topStart = selectedRange.getTopStartCorner();
+    const bottomEnd = selectedRange.getBottomEndCorner();
+    const visitedHorizontalCells = new WeakSet();
+    _classPrivateFieldSet(this, _cellsHorizontalOrder, new _linkedList.default());
+    for (let r = topStart.row; r <= bottomEnd.row; r++) {
+      for (let c = topStart.col; c <= bottomEnd.col; c++) {
+        const mergeParent = _classPrivateFieldGet(this, _mergedCellsGetter).call(this, r, c);
+        const node = _classPrivateMethodGet(this, _pushOrderNode, _pushOrderNode2).call(this, selectedRange, _classPrivateFieldGet(this, _cellsHorizontalOrder), visitedHorizontalCells, r, c);
+        if (node) {
+          _classPrivateFieldSet(this, _currentHorizontalLinkedNode, node);
+        }
+        if (mergeParent) {
+          c += mergeParent.colspan - 1;
+          if (mergeParent.col < topStart.col) {
+            c += mergeParent.col - topStart.col;
+          }
+        }
+      }
+    }
+
+    // create circular linked list
+    _classPrivateFieldGet(this, _cellsHorizontalOrder).first.prev = _classPrivateFieldGet(this, _cellsHorizontalOrder).last;
+    _classPrivateFieldGet(this, _cellsHorizontalOrder).last.next = _classPrivateFieldGet(this, _cellsHorizontalOrder).first;
+    const visitedVerticalCells = new WeakSet();
+    _classPrivateFieldSet(this, _cellsVerticalOrder, new _linkedList.default());
+    for (let c = topStart.col; c <= bottomEnd.col; c++) {
+      for (let r = topStart.row; r <= bottomEnd.row; r++) {
+        const mergeParent = _classPrivateFieldGet(this, _mergedCellsGetter).call(this, r, c);
+        const node = _classPrivateMethodGet(this, _pushOrderNode, _pushOrderNode2).call(this, selectedRange, _classPrivateFieldGet(this, _cellsVerticalOrder), visitedVerticalCells, r, c);
+        if (node) {
+          _classPrivateFieldSet(this, _currentVerticalLinkedNode, node);
+        }
+        if (mergeParent) {
+          r += mergeParent.rowspan - 1;
+          if (mergeParent.row < topStart.row) {
+            r += mergeParent.row - topStart.row;
+          }
+        }
+      }
+    }
+
+    // create circular linked list
+    _classPrivateFieldGet(this, _cellsVerticalOrder).first.prev = _classPrivateFieldGet(this, _cellsVerticalOrder).last;
+    _classPrivateFieldGet(this, _cellsVerticalOrder).last.next = _classPrivateFieldGet(this, _cellsVerticalOrder).first;
+  }
+  /**
+   * Sets the active node based on the provided row and column.
+   *
+   * @param {number} row The visual row index.
+   * @param {number} column The visual column index.
+   */
+  setActiveNode(row, column) {
+    _classPrivateFieldGet(this, _cellsHorizontalOrder).inorder(node => {
+      const {
+        rowStart,
+        rowEnd,
+        colStart,
+        colEnd
+      } = node.data;
+      if (row >= rowStart && row <= rowEnd && column >= colStart && column <= colEnd) {
+        _classPrivateFieldSet(this, _currentHorizontalLinkedNode, node);
+        return false;
+      }
+    });
+    _classPrivateFieldGet(this, _cellsVerticalOrder).inorder(node => {
+      const {
+        rowStart,
+        rowEnd,
+        colStart,
+        colEnd
+      } = node.data;
+      if (row >= rowStart && row <= rowEnd && column >= colStart && column <= colEnd) {
+        _classPrivateFieldSet(this, _currentVerticalLinkedNode, node);
+        return false;
+      }
+    });
+  }
+}
+exports.FocusOrder = FocusOrder;
+function _pushOrderNode2(selectedRange, listOrder, mergeCellsVisitor, row, column) {
+  const topStart = selectedRange.getTopStartCorner();
+  const bottomEnd = selectedRange.getBottomEndCorner();
+  const highlight = selectedRange.highlight.clone().normalize();
+  const mergeParent = _classPrivateFieldGet(this, _mergedCellsGetter).call(this, row, column);
+  if (mergeParent && mergeCellsVisitor.has(mergeParent)) {
+    return null;
+  }
+  const node = {
+    colStart: column,
+    colEnd: column,
+    rowStart: row,
+    rowEnd: row
+  };
+  if (mergeParent) {
+    mergeCellsVisitor.add(mergeParent);
+    if (mergeParent.row < topStart.row || mergeParent.row + mergeParent.rowspan - 1 > bottomEnd.row || mergeParent.col < topStart.col || mergeParent.col + mergeParent.colspan - 1 > bottomEnd.col) {
+      return null;
+    }
+    node.colStart = mergeParent.col;
+    node.colEnd = mergeParent.col + mergeParent.colspan - 1;
+    node.rowStart = mergeParent.row;
+    node.rowEnd = mergeParent.row + mergeParent.rowspan - 1;
+  }
+  const linkedNode = listOrder.push(node);
+  if (row === highlight.row && column === highlight.col || mergeParent && highlight.row >= mergeParent.row && highlight.row <= mergeParent.row + mergeParent.rowspan - 1 && highlight.col >= mergeParent.col && highlight.col <= mergeParent.col + mergeParent.colspan - 1) {
+    return linkedNode;
+  }
+  return null;
+}