handsontable 11.0.0 → 12.0.0

package/3rdparty/walkontable/src/cell/range.mjs

@@ -1,51 +1,92 @@
 import "core-js/modules/es.array.includes.js";
 import "core-js/modules/es.string.includes.js";
 import "core-js/modules/es.array.index-of.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.weak-map.js";
+import "core-js/modules/web.dom-collections.iterator.js";
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+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) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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; } }
 
 import CellCoords from "./../cell/coords.mjs";
 /**
  * CellRange holds cell coordinates as {@link CellCoords} instances. This object represent unit of the selection layer which
- * can contains multiple contiquous cells or single cell.
+ * can contains multiple contiguous cells or single cell.
  *
  * @util
  */
 
+var _isRtl = /*#__PURE__*/new WeakMap();
+
 var CellRange = /*#__PURE__*/function () {
+  /**
+   * Used to draw bold border around a cell where selection was started and to edit the cell
+   * when you press Enter. The highlight cannot point to headers (negative values) so its
+   * coordinates object is normalized while assigning.
+   *
+   * @type {CellCoords}
+   */
+
+  /**
+   * Usually the same as highlight, but in Excel there is distinction - one can change
+   * highlight within a selection.
+   *
+   * @type {CellCoords}
+   */
+
+  /**
+   * End selection.
+   *
+   * @type {CellCoords}
+   */
+
+  /**
+   * @type {boolean}
+   */
   function CellRange(highlight) {
     var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : highlight;
     var to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : highlight;
+    var isRtl = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
     _classCallCheck(this, CellRange);
 
-    /**
-     * Used to draw bold border around a cell where selection was started and to edit the cell
-     * when you press Enter. The highlight cannot point to headers (negative values) so its
-     * coordinates object is normalized while assigning.
-     *
-     * @type {CellCoords}
-     */
-    this.highlight = highlight.clone().normalize();
-    /**
-     * Usually the same as highlight, but in Excel there is distinction - one can change
-     * highlight within a selection.
-     *
-     * @type {CellCoords}
-     */
+    _defineProperty(this, "highlight", null);
 
-    this.from = from.clone();
-    /**
-     * End selection.
-     *
-     * @type {CellCoords}
-     */
+    _defineProperty(this, "from", null);
+
+    _defineProperty(this, "to", null);
+
+    _classPrivateFieldInitSpec(this, _isRtl, {
+      writable: true,
+      value: false
+    });
 
+    this.highlight = highlight.clone().normalize();
+    this.from = from.clone();
     this.to = to.clone();
+
+    _classPrivateFieldSet(this, _isRtl, isRtl);
   }
   /**
    * Set the new coordinates for highlighting selection.
@@ -158,6 +199,17 @@ var CellRange = /*#__PURE__*/function () {
       var toCol = Math.max(this.to.col, 0);
       return Math.max(fromCol, toCol) - Math.min(fromCol, toCol) + 1;
     }
+    /**
+     * Returns the number of cells within the range (excluding the column and row headers, if selected).
+     *
+     * @returns {number}
+     */
+
+  }, {
+    key: "getCellsCount",
+    value: function getCellsCount() {
+      return this.getWidth() * this.getHeight();
+    }
     /**
      * Checks if given cell coordinates are within `from` and `to` cell coordinates of this range.
      *
@@ -170,9 +222,9 @@ var CellRange = /*#__PURE__*/function () {
     value: function includes(cellCoords) {
       var row = cellCoords.row,
           col = cellCoords.col;
-      var topLeft = this.getOuterTopLeftCorner();
-      var bottomRight = this.getOuterBottomRightCorner();
-      return topLeft.row <= row && bottomRight.row >= row && topLeft.col <= col && bottomRight.col >= col;
+      var topStart = this.getOuterTopStartCorner();
+      var bottomEnd = this.getOuterBottomEndCorner();
+      return topStart.row <= row && bottomEnd.row >= row && topStart.col <= col && bottomEnd.col >= col;
     }
     /**
      * Checks if given range is within of this range.
@@ -184,7 +236,7 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "includesRange",
     value: function includesRange(cellRange) {
-      return this.includes(cellRange.getOuterTopLeftCorner()) && this.includes(cellRange.getOuterBottomRightCorner());
+      return this.includes(cellRange.getOuterTopStartCorner()) && this.includes(cellRange.getOuterBottomEndCorner());
     }
     /**
      * Checks if given range is equal to this range.
@@ -271,12 +323,12 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "expand",
     value: function expand(cellCoords) {
-      var topLeft = this.getOuterTopLeftCorner();
-      var bottomRight = this.getOuterBottomRightCorner();
+      var topStart = this.getOuterTopStartCorner();
+      var bottomEnd = this.getOuterBottomEndCorner();
 
-      if (cellCoords.row < topLeft.row || cellCoords.col < topLeft.col || cellCoords.row > bottomRight.row || cellCoords.col > bottomRight.col) {
-        this.from = new CellCoords(Math.min(topLeft.row, cellCoords.row), Math.min(topLeft.col, cellCoords.col));
-        this.to = new CellCoords(Math.max(bottomRight.row, cellCoords.row), Math.max(bottomRight.col, cellCoords.col));
+      if (cellCoords.row < topStart.row || cellCoords.col < topStart.col || cellCoords.row > bottomEnd.row || cellCoords.col > bottomEnd.col) {
+        this.from = this._createCellCoords(Math.min(topStart.row, cellCoords.row), Math.min(topStart.col, cellCoords.col));
+        this.to = this._createCellCoords(Math.max(bottomEnd.row, cellCoords.row), Math.max(bottomEnd.col, cellCoords.col));
         return true;
       }
 
@@ -296,17 +348,20 @@ var CellRange = /*#__PURE__*/function () {
         return false;
       }
 
-      var topLeft = this.getOuterTopLeftCorner();
-      var bottomRight = this.getOuterBottomRightCorner();
+      var topStart = this.getOuterTopStartCorner();
+      var bottomEnd = this.getOuterBottomEndCorner();
       var initialDirection = this.getDirection();
-      var expandingTopLeft = expandingRange.getOuterTopLeftCorner();
-      var expandingBottomRight = expandingRange.getOuterBottomRightCorner();
-      var resultTopRow = Math.min(topLeft.row, expandingTopLeft.row);
-      var resultTopCol = Math.min(topLeft.col, expandingTopLeft.col);
-      var resultBottomRow = Math.max(bottomRight.row, expandingBottomRight.row);
-      var resultBottomCol = Math.max(bottomRight.col, expandingBottomRight.col);
-      var finalFrom = new CellCoords(resultTopRow, resultTopCol);
-      var finalTo = new CellCoords(resultBottomRow, resultBottomCol);
+      var expandingTopStart = expandingRange.getOuterTopStartCorner();
+      var expandingBottomEnd = expandingRange.getOuterBottomEndCorner();
+      var resultTopRow = Math.min(topStart.row, expandingTopStart.row);
+      var resultTopCol = Math.min(topStart.col, expandingTopStart.col);
+      var resultBottomRow = Math.max(bottomEnd.row, expandingBottomEnd.row);
+      var resultBottomCol = Math.max(bottomEnd.col, expandingBottomEnd.col);
+
+      var finalFrom = this._createCellCoords(resultTopRow, resultTopCol);
+
+      var finalTo = this._createCellCoords(resultBottomRow, resultBottomCol);
+
       this.from = finalFrom;
       this.to = finalTo;
       this.setDirection(initialDirection);
@@ -465,8 +520,20 @@ var CellRange = /*#__PURE__*/function () {
       }
     }
     /**
-     * Gets the top left corner of this range. If the corner contains header coordinates
-     * (negative values), the corner coordinates will be normalized to 0.
+     * Gets the top left (in LTR) or top right (in RTL) corner coordinates of this range. If the corner contains
+     * header coordinates (negative values), the corner coordinates will be normalized to 0.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getTopStartCorner",
+    value: function getTopStartCorner() {
+      return this._createCellCoords(Math.min(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)).normalize();
+    }
+    /**
+     * Gets the top left corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), the corner coordinates will be normalized to 0.
      *
      * @returns {CellCoords}
      */
@@ -474,11 +541,23 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getTopLeftCorner",
     value: function getTopLeftCorner() {
-      return new CellCoords(Math.min(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)).normalize();
+      return _classPrivateFieldGet(this, _isRtl) ? this.getTopEndCorner() : this.getTopStartCorner();
     }
     /**
-     * Gets the bottom right corner of this range. If the corner contains header coordinates
-     * (negative values), the corner coordinates will be normalized to 0.
+     * Gets the bottom right (in LTR) or bottom left (in RTL) corner coordinates of this range. If the corner contains
+     * header coordinates (negative values), the corner coordinates will be normalized to 0.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getBottomEndCorner",
+    value: function getBottomEndCorner() {
+      return this._createCellCoords(Math.max(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)).normalize();
+    }
+    /**
+     * Gets the bottom right corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), the corner coordinates will be normalized to 0.
      *
      * @returns {CellCoords}
      */
@@ -486,11 +565,23 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getBottomRightCorner",
     value: function getBottomRightCorner() {
-      return new CellCoords(Math.max(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)).normalize();
+      return _classPrivateFieldGet(this, _isRtl) ? this.getBottomStartCorner() : this.getBottomEndCorner();
+    }
+    /**
+     * Gets the top right (in LTR) or top left (in RTL) corner coordinates of this range. If the corner contains
+     * header coordinates (negative values), the corner coordinates will be normalized to 0.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getTopEndCorner",
+    value: function getTopEndCorner() {
+      return this._createCellCoords(Math.min(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)).normalize();
     }
     /**
-     * Gets the top right corner of this range. If the corner contains header coordinates
-     * (negative values), the corner coordinates will be normalized to 0.
+     * Gets the top right corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), the corner coordinates will be normalized to 0.
      *
      * @returns {CellCoords}
      */
@@ -498,11 +589,23 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getTopRightCorner",
     value: function getTopRightCorner() {
-      return new CellCoords(Math.min(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)).normalize();
+      return _classPrivateFieldGet(this, _isRtl) ? this.getTopStartCorner() : this.getTopEndCorner();
+    }
+    /**
+     * Gets the bottom left (in LTR) or bottom right (in RTL) corner coordinates of this range. If the corner
+     * contains header coordinates (negative values), the corner coordinates will be normalized to 0.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getBottomStartCorner",
+    value: function getBottomStartCorner() {
+      return this._createCellCoords(Math.max(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)).normalize();
     }
     /**
-     * Gets the bottom left corner of this range. If the corner contains header coordinates
-     * (negative values), the corner coordinates will be normalized to 0.
+     * Gets the bottom left corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), the corner coordinates will be normalized to 0.
      *
      * @returns {CellCoords}
      */
@@ -510,11 +613,24 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getBottomLeftCorner",
     value: function getBottomLeftCorner() {
-      return new CellCoords(Math.max(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)).normalize();
+      return _classPrivateFieldGet(this, _isRtl) ? this.getBottomEndCorner() : this.getBottomStartCorner();
+    }
+    /**
+     * Gets the top left (in LTR) or top right (in RTL) corner coordinates of this range. If the corner
+     * contains header coordinates (negative values), then the top and start coordinates will be pointed to that header.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getOuterTopStartCorner",
+    value: function getOuterTopStartCorner() {
+      return this._createCellCoords(Math.min(this.from.row, this.to.row), Math.min(this.from.col, this.to.col));
     }
     /**
-     * Gets the top left corner of this range. If the corner contains header coordinates
-     * (negative values), then the top and left coordinates will be pointed to that header.
+     * Gets the top left corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), then the top and left coordinates will be
+     * pointed to that header.
      *
      * @returns {CellCoords}
      */
@@ -522,10 +638,24 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getOuterTopLeftCorner",
     value: function getOuterTopLeftCorner() {
-      return new CellCoords(Math.min(this.from.row, this.to.row), Math.min(this.from.col, this.to.col));
+      return _classPrivateFieldGet(this, _isRtl) ? this.getOuterTopEndCorner() : this.getOuterTopStartCorner();
+    }
+    /**
+     * Gets the bottom right (in LTR) or bottom left (in RTL) corner coordinates of this range. If the corner
+     * contains header coordinates (negative values), then the top and start coordinates will be pointed to that header.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getOuterBottomEndCorner",
+    value: function getOuterBottomEndCorner() {
+      return this._createCellCoords(Math.max(this.from.row, this.to.row), Math.max(this.from.col, this.to.col));
     }
     /**
-     * Gets the bottom right corner of this range.
+     * Gets the bottom right corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), then the top and left coordinates will be
+     * pointed to that header.
      *
      * @returns {CellCoords}
      */
@@ -533,11 +663,24 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getOuterBottomRightCorner",
     value: function getOuterBottomRightCorner() {
-      return new CellCoords(Math.max(this.from.row, this.to.row), Math.max(this.from.col, this.to.col));
+      return _classPrivateFieldGet(this, _isRtl) ? this.getOuterBottomStartCorner() : this.getOuterBottomEndCorner();
+    }
+    /**
+     * Gets the top right (in LTR) or top left (in RTL) corner coordinates of this range. If the corner
+     * contains header coordinates (negative values), then the top and start coordinates will be pointed to that header.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getOuterTopEndCorner",
+    value: function getOuterTopEndCorner() {
+      return this._createCellCoords(Math.min(this.from.row, this.to.row), Math.max(this.from.col, this.to.col));
     }
     /**
-     * Gets the top right corner of this range. If the corner contains header coordinates
-     * (negative values), then the top coordinate will be pointed to that header.
+     * Gets the top right corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), then the top and left coordinates will be
+     * pointed to that header.
      *
      * @returns {CellCoords}
      */
@@ -545,11 +688,24 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getOuterTopRightCorner",
     value: function getOuterTopRightCorner() {
-      return new CellCoords(Math.min(this.from.row, this.to.row), Math.max(this.from.col, this.to.col));
+      return _classPrivateFieldGet(this, _isRtl) ? this.getOuterTopStartCorner() : this.getOuterTopEndCorner();
+    }
+    /**
+     * Gets the bottom left (in LTR) or bottom right (in RTL) corner coordinates of this range. If the corner
+     * contains header coordinates (negative values), then the top and start coordinates will be pointed to that header.
+     *
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "getOuterBottomStartCorner",
+    value: function getOuterBottomStartCorner() {
+      return this._createCellCoords(Math.max(this.from.row, this.to.row), Math.min(this.from.col, this.to.col));
     }
     /**
-     * Gets the bottom left corner of this range. If the corner contains header coordinates
-     * (negative values), then the left coordinate will be pointed to that header.
+     * Gets the bottom left corner coordinates of this range, no matter if the code runs in LTR or RTL document mode.
+     * If the corner contains header coordinates (negative values), then the top and left coordinates will be
+     * pointed to that header.
      *
      * @returns {CellCoords}
      */
@@ -557,7 +713,7 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getOuterBottomLeftCorner",
     value: function getOuterBottomLeftCorner() {
-      return new CellCoords(Math.max(this.from.row, this.to.row), Math.min(this.from.col, this.to.col));
+      return _classPrivateFieldGet(this, _isRtl) ? this.getOuterBottomEndCorner() : this.getOuterBottomStartCorner();
     }
     /**
      * Checks if coordinates match to one of the 4th corners of this range.
@@ -570,7 +726,7 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "isCorner",
     value: function isCorner(coords, expandedRange) {
-      if (expandedRange && expandedRange.includes(coords) && (this.getOuterTopLeftCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.from.col)) || this.getOuterTopRightCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.to.col)) || this.getOuterBottomLeftCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.from.col)) || this.getOuterBottomRightCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.to.col)))) {
+      if (expandedRange && expandedRange.includes(coords) && (this.getOuterTopLeftCorner().isEqual(this._createCellCoords(expandedRange.from.row, expandedRange.from.col)) || this.getOuterTopRightCorner().isEqual(this._createCellCoords(expandedRange.from.row, expandedRange.to.col)) || this.getOuterBottomLeftCorner().isEqual(this._createCellCoords(expandedRange.to.row, expandedRange.from.col)) || this.getOuterBottomRightCorner().isEqual(this._createCellCoords(expandedRange.to.row, expandedRange.to.col)))) {
         return true;
       }
 
@@ -593,33 +749,36 @@ var CellRange = /*#__PURE__*/function () {
       }
 
       if (expandedRange) {
+        var from = expandedRange.from,
+            to = expandedRange.to;
+
         if (expandedRange.includes(coords)) {
-          if (this.getOuterTopLeftCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.from.col))) {
-            return this.getOuterBottomRightCorner();
+          if (this.getOuterTopStartCorner().isEqual(this._createCellCoords(from.row, from.col))) {
+            return this.getOuterBottomEndCorner();
           }
 
-          if (this.getOuterTopRightCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.to.col))) {
-            return this.getOuterBottomLeftCorner();
+          if (this.getOuterTopEndCorner().isEqual(this._createCellCoords(from.row, to.col))) {
+            return this.getOuterBottomStartCorner();
           }
 
-          if (this.getOuterBottomLeftCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.from.col))) {
-            return this.getOuterTopRightCorner();
+          if (this.getOuterBottomStartCorner().isEqual(this._createCellCoords(to.row, from.col))) {
+            return this.getOuterTopEndCorner();
           }
 
-          if (this.getOuterBottomRightCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.to.col))) {
-            return this.getOuterTopLeftCorner();
+          if (this.getOuterBottomEndCorner().isEqual(this._createCellCoords(to.row, to.col))) {
+            return this.getOuterTopStartCorner();
           }
         }
       }
 
-      if (coords.isEqual(this.getOuterBottomRightCorner())) {
-        return this.getOuterTopLeftCorner();
-      } else if (coords.isEqual(this.getOuterTopLeftCorner())) {
-        return this.getOuterBottomRightCorner();
-      } else if (coords.isEqual(this.getOuterTopRightCorner())) {
-        return this.getOuterBottomLeftCorner();
-      } else if (coords.isEqual(this.getOuterBottomLeftCorner())) {
-        return this.getOuterTopRightCorner();
+      if (coords.isEqual(this.getOuterBottomEndCorner())) {
+        return this.getOuterTopStartCorner();
+      } else if (coords.isEqual(this.getOuterTopStartCorner())) {
+        return this.getOuterBottomEndCorner();
+      } else if (coords.isEqual(this.getOuterTopEndCorner())) {
+        return this.getOuterBottomStartCorner();
+      } else if (coords.isEqual(this.getOuterBottomStartCorner())) {
+        return this.getOuterTopEndCorner();
       }
     }
     /**
@@ -675,14 +834,14 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getInner",
     value: function getInner() {
-      var topLeft = this.getOuterTopLeftCorner();
-      var bottomRight = this.getOuterBottomRightCorner();
+      var topStart = this.getOuterTopStartCorner();
+      var bottomEnd = this.getOuterBottomEndCorner();
       var out = [];
 
-      for (var r = topLeft.row; r <= bottomRight.row; r++) {
-        for (var c = topLeft.col; c <= bottomRight.col; c++) {
+      for (var r = topStart.row; r <= bottomEnd.row; r++) {
+        for (var c = topStart.col; c <= bottomEnd.col; c++) {
           if (!(this.from.row === r && this.from.col === c) && !(this.to.row === r && this.to.col === c)) {
-            out.push(new CellCoords(r, c));
+            out.push(this._createCellCoords(r, c));
           }
         }
       }
@@ -698,18 +857,18 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "getAll",
     value: function getAll() {
-      var topLeft = this.getOuterTopLeftCorner();
-      var bottomRight = this.getOuterBottomRightCorner();
+      var topStart = this.getOuterTopStartCorner();
+      var bottomEnd = this.getOuterBottomEndCorner();
       var out = [];
 
-      for (var r = topLeft.row; r <= bottomRight.row; r++) {
-        for (var c = topLeft.col; c <= bottomRight.col; c++) {
-          if (topLeft.row === r && topLeft.col === c) {
-            out.push(topLeft);
-          } else if (bottomRight.row === r && bottomRight.col === c) {
-            out.push(bottomRight);
+      for (var r = topStart.row; r <= bottomEnd.row; r++) {
+        for (var c = topStart.col; c <= bottomEnd.col; c++) {
+          if (topStart.row === r && topStart.col === c) {
+            out.push(topStart);
+          } else if (bottomEnd.row === r && bottomEnd.col === c) {
+            out.push(bottomEnd);
           } else {
-            out.push(new CellCoords(r, c));
+            out.push(this._createCellCoords(r, c));
           }
         }
       }
@@ -726,11 +885,11 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "forAll",
     value: function forAll(callback) {
-      var topLeft = this.getOuterTopLeftCorner();
-      var bottomRight = this.getOuterBottomRightCorner();
+      var topStart = this.getOuterTopStartCorner();
+      var bottomEnd = this.getOuterBottomEndCorner();
 
-      for (var r = topLeft.row; r <= bottomRight.row; r++) {
-        for (var c = topLeft.col; c <= bottomRight.col; c++) {
+      for (var r = topStart.row; r <= bottomEnd.row; r++) {
+        for (var c = topStart.col; c <= bottomEnd.col; c++) {
           var breakIteration = callback(r, c);
 
           if (breakIteration === false) {
@@ -748,7 +907,7 @@ var CellRange = /*#__PURE__*/function () {
   }, {
     key: "clone",
     value: function clone() {
-      return new CellRange(this.highlight, this.from, this.to);
+      return new CellRange(this.highlight, this.from, this.to, _classPrivateFieldGet(this, _isRtl));
     }
     /**
      * Convert CellRange to literal object.
@@ -765,6 +924,21 @@ var CellRange = /*#__PURE__*/function () {
         to: this.to.toObject()
       };
     }
+    /**
+     * Creates and returns a new instance of the CellCoords object. The object automatically inherits
+     * the LTR/RTL flag from this CellRange instance.
+     *
+     * @private
+     * @param {number} row The row index.
+     * @param {number} column The column index.
+     * @returns {CellCoords}
+     */
+
+  }, {
+    key: "_createCellCoords",
+    value: function _createCellCoords(row, column) {
+      return new CellCoords(row, column, _classPrivateFieldGet(this, _isRtl));
+    }
   }]);
 
   return CellRange;