@deephaven/grid 0.4.1-modules.0 → 0.5.2-beta.0

package/dist/GridRange.js

@@ -1,694 +1,752 @@
-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 _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
 
-class GridRange {
-  static normalize(startColumn, startRow, endColumn, endRow) {
-    var left = startColumn;
-    var top = startRow;
-    var right = endColumn;
-    var bottom = endRow;
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-    if (left != null && right != null && right < left) {
-      left = right;
-      right = startColumn;
-    }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-    if (top != null && bottom != null && bottom < top) {
-      top = bottom;
-      bottom = startRow;
-    }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
-    return [left, top, right, bottom];
-  }
-  /** Make a GridRange, but ensure startColumn <= endColumn, startRow <= endRow */
-
-
-  static makeNormalized() {
-    return new GridRange(...GridRange.normalize(...arguments));
-  }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-  static makeCell(column, row) {
-    return new GridRange(column, row, column, row);
-  }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-  static makeColumn(column) {
-    return new GridRange(column, null, column, null);
-  }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
 
-  static makeRow(row) {
-    return new GridRange(null, row, null, row);
-  }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
-  static minOrNull(value1, value2) {
-    if (value1 == null || value2 == null) {
-      return null;
-    }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-    return Math.min(value1, value2);
-  }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  static maxOrNull(value1, value2) {
-    if (value1 == null || value2 == null) {
-      return null;
-    }
+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); } }
 
-    return Math.max(value1, value2);
-  }
-  /**
-   * Consolidate the passed in ranges to the minimum set, merging overlapping ranges.
-   * @param {[GridRange]} ranges The ranges to consolidate
-   */
-
-
-  static consolidate(ranges) {
-    var result = ranges.slice();
-    var wasModified = true;
-
-    while (wasModified) {
-      wasModified = false;
-
-      for (var i = 0; i < result.length && !wasModified; i += 1) {
-        var range = result[i];
-
-        for (var j = result.length - 1; j > i; j -= 1) {
-          var other = result[j]; // If one contains the other, we can just keep the bigger one
-
-          if (range.contains(other)) {
-            result.splice(j, 1);
-          } else if (other.contains(range)) {
-            wasModified = true;
-            result[i] = other;
-            result.splice(j, 1);
-            break;
-          } else if (range.startRow === other.startRow && range.endRow === other.endRow) {
-            if (range.touches(other)) {
-              // If the start/end rows match, and columns touch, consolidate
-              var {
-                startRow,
-                endRow
-              } = range;
-              var startColumn = GridRange.minOrNull(range.startColumn, other.startColumn);
-              var endColumn = GridRange.maxOrNull(range.endColumn, other.endColumn);
-              wasModified = true;
-              result[i] = new GridRange(startColumn, startRow, endColumn, endRow);
-              result.splice(j, 1);
-              break;
-            }
-          } else if (range.startColumn === other.startColumn && range.endColumn === other.endColumn) {
-            if (range.touches(other)) {
-              // If the start/end rows match, and columns touch, consolidate
-              var {
-                startColumn: _startColumn,
-                endColumn: _endColumn
-              } = range;
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-              var _startRow = GridRange.minOrNull(range.startRow, other.startRow);
+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; }
 
-              var _endRow = GridRange.maxOrNull(range.endRow, other.endRow);
+var GridRange = /*#__PURE__*/function () {
+  function GridRange(startColumn, startRow, endColumn, endRow) {
+    _classCallCheck(this, GridRange);
 
-              wasModified = true;
-              result[i] = new GridRange(_startColumn, _startRow, _endColumn, _endRow);
-              result.splice(j, 1);
-              break;
-            }
-          }
-        }
-      }
-    }
-
-    return result;
+    this.startColumn = startColumn;
+    this.startRow = startRow;
+    this.endColumn = endColumn;
+    this.endRow = endRow;
   }
 
-  static isAxisRangeTouching(start, end, otherStart, otherEnd) {
-    if (start == null) {
-      if (end == null) {
-        return true;
-      }
-
-      if (otherStart == null) {
-        return true;
-      }
-
-      return otherStart <= end + 1;
+  _createClass(GridRange, [{
+    key: "equals",
+    value: function equals(other) {
+      return this.startColumn === other.startColumn && this.startRow === other.startRow && this.endColumn === other.endColumn && this.endRow === other.endRow;
     }
+    /** @returns {boolean} true if this GridRange completely contains `other` */
 
-    if (end == null) {
-      if (otherEnd == null) {
-        return true;
-      }
-
-      return otherEnd >= start - 1;
+  }, {
+    key: "contains",
+    value: function contains(other) {
+      return (this.startColumn == null || other.startColumn != null && this.startColumn <= other.startColumn) && (this.startRow == null || other.startRow != null && this.startRow <= other.startRow) && (this.endColumn == null || other.endColumn != null && this.endColumn >= other.endColumn) && (this.endRow == null || other.endRow != null && this.endRow >= other.endRow);
     }
-
-    if (otherStart == null) {
-      if (otherEnd == null) {
-        return true;
+    /**
+     * Check if the provided cell is in this range
+     * @param {number} column The column to check
+     * @param {number} row The row to check
+     * @returns {boolean} True if this cell is within this range
+     */
+
+  }, {
+    key: "containsCell",
+    value: function containsCell(column, row) {
+      if (column == null || row == null) {
+        return false;
       }
 
-      return start <= otherEnd + 1;
+      return (this.startColumn == null || this.startColumn <= column) && (this.endColumn == null || this.endColumn >= column) && (this.startRow == null || this.startRow <= row) && (this.endRow == null || this.endRow >= row);
     }
+    /** @returns {boolean} true if this GridRange touches `other` */
 
-    if (otherEnd == null) {
-      return end >= otherStart - 1;
+  }, {
+    key: "touches",
+    value: function touches(other) {
+      return GridRange.isAxisRangeTouching(this.startRow, this.endRow, other.startRow, other.endRow) && GridRange.isAxisRangeTouching(this.startColumn, this.endColumn, other.startColumn, other.endColumn);
     }
-
-    if (otherStart >= start - 1) {
-      return otherStart <= end + 1;
+    /**
+     * @param {GridRange} other The range to deselect from within this range
+     * @returns {[GridRange]} The ranges needed to represent the remaining
+     */
+
+  }, {
+    key: "subtract",
+    value: function subtract(other) {
+      return GridRange.subtractFromRange(this, other);
     }
-
-    return otherEnd >= start - 1;
-  }
-
-  static rangeArraysEqual(ranges1, ranges2) {
-    if (ranges1 === ranges2) {
-      return true;
-    }
-
-    if (ranges1 == null || ranges2 == null || ranges1.length !== ranges2.length) {
-      return false;
-    }
-
-    for (var i = 0; i < ranges1.length; i += 1) {
-      if (!ranges1[i].equals(ranges2[i])) {
-        return false;
+    /**
+     * Get the first cell in this range. Throws if this range is unbounded.
+     *
+     * @param {GridRange.SELECTION_DIRECTION?} direction The direction to get the starting cell in. Defaults to DOWN
+     * @returns {{column: number, row: number}} The first cell in this range in the direction specified
+     */
+
+  }, {
+    key: "startCell",
+    value: function startCell() {
+      var direction = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : GridRange.SELECTION_DIRECTION.DOWN;
+
+      if (!GridRange.isBounded(this)) {
+        throw new Error('Cannot get the startCell of an unbounded range');
       }
-    }
-
-    return true;
-  }
-  /**
-   * Get the intersection (overlapping area) of two ranges
-   * @param {GridRange} range One range to check for the intersection
-   * @param {GridRange} otherRange The other range to check for the intersection
-   * @returns {GridRange|null} Intersection of the two ranges. If they do not intersect, returns `null`.
-   */
 
+      switch (direction) {
+        case GridRange.SELECTION_DIRECTION.DOWN:
+        case GridRange.SELECTION_DIRECTION.RIGHT:
+          return {
+            column: this.startColumn,
+            row: this.startRow
+          };
 
-  static intersection(range, otherRange) {
-    var _startColumn2, _endColumn2, _startRow2, _endRow2;
+        case GridRange.SELECTION_DIRECTION.LEFT:
+        case GridRange.SELECTION_DIRECTION.UP:
+          {
+            return {
+              column: this.endColumn,
+              row: this.endRow
+            };
+          }
 
-    if (range.equals(otherRange)) {
-      return range;
+        default:
+          throw new Error("Invalid direction: ".concat(direction));
+      }
     }
+    /**
+     * Get the next cell in the direction specified. Throws if this range is unbounded.
+     * If already at the bounds of the range in that direction, wrap to the next column or row
+     * If at the end of the entire range, return null
+     * If outside of the range, returns the next cell closest within this range.
+     *
+     * @param {number} column The cursor column
+     * @param {number} row The cursor row
+     * @param {SELECTION_DIRECTION} direction The direction to go in
+     * @returns {GridCell|null} The next cell in the direction specified, or `null` if at the end of the range
+     */
+
+  }, {
+    key: "nextCell",
+    value: function nextCell(column, row, direction) {
+      if (!GridRange.isBounded(this)) {
+        throw new Error('Bounded range required');
+      }
 
-    var {
-      startColumn,
-      startRow,
-      endColumn,
-      endRow
-    } = range;
-    startColumn = startColumn != null && otherRange.startColumn != null ? Math.max(startColumn, otherRange.startColumn) : (_startColumn2 = startColumn) !== null && _startColumn2 !== void 0 ? _startColumn2 : otherRange.startColumn;
-    endColumn = endColumn != null && otherRange.endColumn != null ? Math.min(endColumn, otherRange.endColumn) : (_endColumn2 = endColumn) !== null && _endColumn2 !== void 0 ? _endColumn2 : otherRange.endColumn;
-    startRow = startRow != null && otherRange.startRow != null ? Math.max(startRow, otherRange.startRow) : (_startRow2 = startRow) !== null && _startRow2 !== void 0 ? _startRow2 : otherRange.startRow;
-    endRow = endRow != null && otherRange.endRow != null ? Math.min(endRow, otherRange.endRow) : (_endRow2 = endRow) !== null && _endRow2 !== void 0 ? _endRow2 : otherRange.endRow;
+      if (column == null || row == null) {
+        throw new Error('Require a non-null cursor');
+      }
 
-    if (startColumn != null && startColumn > endColumn || startRow != null && startRow > endRow) {
-      return null;
-    }
+      var startColumn = this.startColumn,
+          endColumn = this.endColumn,
+          startRow = this.startRow,
+          endRow = this.endRow;
+
+      switch (direction) {
+        case GridRange.SELECTION_DIRECTION.DOWN:
+          if (row < endRow) {
+            return {
+              column: column,
+              row: Math.max(row + 1, startRow)
+            };
+          }
 
-    return new GridRange(startColumn, startRow, endColumn, endRow);
-  }
-  /**
-   * @param {GridRange} range The range to be subtracted from
-   * @param {GridRange} subtractRange The range to subtract from within this range
-   * @returns {GridRange[]} The ranges needed to represent the remaining
-   */
+          if (column < endColumn) {
+            return {
+              column: Math.max(column + 1, startColumn),
+              row: startRow
+            };
+          }
 
+          break;
 
-  static subtractFromRange(range, subtractRange) {
-    var result = []; // Make it a little easier by finding only the part the subtraction range intersects
+        case GridRange.SELECTION_DIRECTION.UP:
+          if (row > startRow) {
+            return {
+              column: column,
+              row: Math.min(row - 1, endRow)
+            };
+          }
 
-    var subtract = GridRange.intersection(range, subtractRange);
+          if (column > startColumn) {
+            return {
+              column: Math.min(column - 1, endColumn),
+              row: endRow
+            };
+          }
 
-    if (subtract == null) {
-      return [range];
-    } // Go through each of the quadrants for deselection, there can be up to 4
-    // Top quadrant (above the subtracted area)
+          break;
 
+        case GridRange.SELECTION_DIRECTION.RIGHT:
+          if (column < endColumn) {
+            return {
+              column: Math.max(column + 1, startColumn),
+              row: row
+            };
+          }
 
-    if (subtract.startRow != null && (range.startRow == null || range.startRow < subtract.startRow)) {
-      result.push(new GridRange(range.startColumn, range.startRow, range.endColumn, subtract.startRow - 1));
-    } // middle left
+          if (row < endRow) {
+            return {
+              column: startColumn,
+              row: Math.max(row + 1, startRow)
+            };
+          }
 
+          break;
 
-    if (subtract.startColumn != null && (range.startColumn == null || range.startColumn < subtract.startColumn)) {
-      result.push(new GridRange(range.startColumn, subtract.startRow, subtract.startColumn - 1, subtract.endRow));
-    } // middle right
+        case GridRange.SELECTION_DIRECTION.LEFT:
+          if (column > startColumn) {
+            return {
+              column: Math.min(column - 1, endColumn),
+              row: row
+            };
+          }
 
+          if (row > startRow) {
+            return {
+              column: endColumn,
+              row: Math.min(row - 1, endRow)
+            };
+          }
 
-    if (subtract.endColumn != null && (range.endColumn == null || range.endColumn > subtract.endColumn)) {
-      result.push(new GridRange(subtract.endColumn + 1, subtract.startRow, range.endColumn, subtract.endRow));
-    } // Bottom quadrant
+          break;
 
+        default:
+          throw new Error("Invalid direction: ".concat(direction));
+      }
 
-    if (subtract.endRow != null && (range.endRow == null || range.endRow > subtract.endRow)) {
-      result.push(new GridRange(range.startColumn, subtract.endRow + 1, range.endColumn, range.endRow));
+      return null;
     }
+    /**
+     * Iterate through each cell in the range
+     * @param {(column:number, row:number, index:number) => void} callback Callback to execute. `index` is the index within this range
+     * @param {GridRange.SELECTION_DIRECTION} direction The direction to iterate in
+     */
 
-    return result;
-  }
-  /**
-   * Subtract a range from multiple ranges
-   * @param {GridRange[]} ranges The ranges to be subtracted from
-   * @param {GridRange} subtractRange The range to subtract from within these ranges
-   * @returns {GridRange[]} The ranges needed to represent the remaining
-   */
+  }, {
+    key: "forEach",
+    value: function forEach(callback) {
+      var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : GridRange.SELECTION_DIRECTION.RIGHT;
+      var i = 0;
 
+      var _this$startCell = this.startCell(direction),
+          c = _this$startCell.column,
+          r = _this$startCell.row;
 
-  static subtractFromRanges(ranges, subtractRange) {
-    var result = [];
+      while (c != null && r != null) {
+        var _this$nextCell;
 
-    for (var i = 0; i < ranges.length; i += 1) {
-      result.push(...GridRange.subtractFromRange(ranges[i], subtractRange));
-    }
-
-    return result;
-  }
-  /**
-   * Subtract multiple ranges from multiple ranges
-   * @param {GridRange[]} ranges The ranges to be subtracted from
-   * @param {GridRange[]} subtractRanges The ranges to subtract from within these ranges
-   * @returns {GridRange[]} The ranges needed to represent the remaining
-   */
+        callback(c, r, i);
+        i += 1;
 
+        var _ref = (_this$nextCell = this.nextCell(c, r, direction)) !== null && _this$nextCell !== void 0 ? _this$nextCell : {};
 
-  static subtractRangesFromRanges(ranges, subtractRanges) {
-    if (!subtractRanges || subtractRanges.length === 0) {
-      return ranges;
+        c = _ref.column;
+        r = _ref.row;
+      }
     }
+  }], [{
+    key: "normalize",
+    value: function normalize(startColumn, startRow, endColumn, endRow) {
+      var left = startColumn;
+      var top = startRow;
+      var right = endColumn;
+      var bottom = endRow;
+
+      if (left != null && right != null && right < left) {
+        left = right;
+        right = startColumn;
+      }
 
-    var result = [...ranges];
+      if (top != null && bottom != null && bottom < top) {
+        top = bottom;
+        bottom = startRow;
+      }
 
-    for (var i = 0; i < subtractRanges.length; i += 1) {
-      result = GridRange.subtractFromRanges(result, subtractRanges[i]);
+      return [left, top, right, bottom];
     }
+    /** Make a GridRange, but ensure startColumn <= endColumn, startRow <= endRow */
 
-    return result;
-  }
-  /**
-   * Test if a given range is bounded (all values are non-null)
-   * @param {GridRange} range The range to test
-   * @returns {boolean} True if this range is bounded, false otherwise
-   */
-
-
-  static isBounded(range) {
-    return range.startRow != null && range.startColumn != null && range.endRow != null && range.endColumn != null;
-  }
-  /**
-   * Converts any GridRange passed in that is a full row or column selection to be bound
-   * to the `columnCount` and `rowCount` passed in
-   *
-   * @param {GridRange} range The range to get the bounded range of
-   * @param {number} columnCount The number of columns
-   * @param {number} rowCount The number of rows
-   * @returns {GridRange} The passed in GridRange with any null values filled in
-   */
-
-
-  static boundedRange(range, columnCount, rowCount) {
-    var _range$startColumn, _range$startRow, _range$endColumn, _range$endRow;
+  }, {
+    key: "makeNormalized",
+    value: function makeNormalized() {
+      return _construct(GridRange, _toConsumableArray(GridRange.normalize.apply(GridRange, arguments)));
+    }
+  }, {
+    key: "makeCell",
+    value: function makeCell(column, row) {
+      return new GridRange(column, row, column, row);
+    }
+  }, {
+    key: "makeColumn",
+    value: function makeColumn(column) {
+      return new GridRange(column, null, column, null);
+    }
+  }, {
+    key: "makeRow",
+    value: function makeRow(row) {
+      return new GridRange(null, row, null, row);
+    }
+  }, {
+    key: "minOrNull",
+    value: function minOrNull(value1, value2) {
+      if (value1 == null || value2 == null) {
+        return null;
+      }
 
-    if (GridRange.isBounded(range)) {
-      return range;
+      return Math.min(value1, value2);
     }
+  }, {
+    key: "maxOrNull",
+    value: function maxOrNull(value1, value2) {
+      if (value1 == null || value2 == null) {
+        return null;
+      }
 
-    return new GridRange((_range$startColumn = range.startColumn) !== null && _range$startColumn !== void 0 ? _range$startColumn : 0, (_range$startRow = range.startRow) !== null && _range$startRow !== void 0 ? _range$startRow : 0, (_range$endColumn = range.endColumn) !== null && _range$endColumn !== void 0 ? _range$endColumn : columnCount - 1, (_range$endRow = range.endRow) !== null && _range$endRow !== void 0 ? _range$endRow : rowCount - 1);
-  }
-  /**
-   * Converts the GridRanges passed in to be bound to the `columnCount` and `rowCount` passed in
-   *
-   * @param {GridRange[]} ranges The ranges to get the bounded ranges of
-   * @param {number} columnCount The number of columns
-   * @param {number} rowCount The number of rows
-   * @returns {GridRange} The passed in GridRange with any null values filled in
-   */
-
-
-  static boundedRanges(ranges, columnCount, rowCount) {
-    return ranges.map(r => GridRange.boundedRange(r, columnCount, rowCount));
-  }
-  /**
-   * Offsets a GridRange by the specified amount in the x and y directions
-   *
-   * @param {GridRange} range The range to offset
-   * @param {number} columnOffset The number of columns to offset
-   * @param {number} rowOffset The number of rows to offset
-   * @returns {GridRange} The new grid range offset from the original
-   */
-
-
-  static offset(range, columnOffset, rowOffset) {
-    return new GridRange(range.startColumn != null ? range.startColumn + columnOffset : null, range.startRow != null ? range.startRow + rowOffset : null, range.endColumn != null ? range.endColumn + columnOffset : null, range.endRow != null ? range.endRow + rowOffset : null);
-  }
-  /**
-   * Get the next cell given the selected ranges and the current cell
-   * @param {GridRange[]} ranges The selected bounded ranges within the grid
-   * @param {number|null} column The cursor column, or null if none focused
-   * @param {number|null} row The cursor row, or null if none focused
-   * @param {SELECTION_DIRECTION} direction The direction in which to select next
-   * @returns {Cell} The next cell to focus, or null if there should be no more focus
-   */
-
-
-  static nextCell(ranges) {
-    var column = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    var row = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-    var direction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : GridRange.SELECTION_DIRECTION.DOWN;
-
-    if (ranges.length === 0) {
-      return null;
+      return Math.max(value1, value2);
     }
+    /**
+     * Consolidate the passed in ranges to the minimum set, merging overlapping ranges.
+     * @param {[GridRange]} ranges The ranges to consolidate
+     */
+
+  }, {
+    key: "consolidate",
+    value: function consolidate(ranges) {
+      var result = ranges.slice();
+      var wasModified = true;
 
-    var rangeIndex = -1;
+      while (wasModified) {
+        wasModified = false;
 
-    if (column != null && row != null) {
-      rangeIndex = ranges.findIndex(r => r.containsCell(column, row));
+        for (var i = 0; i < result.length && !wasModified; i += 1) {
+          var range = result[i];
 
-      if (rangeIndex >= 0) {
-        var range = ranges[rangeIndex];
-        var nextCell = range.nextCell(column, row, direction);
+          for (var j = result.length - 1; j > i; j -= 1) {
+            var other = result[j]; // If one contains the other, we can just keep the bigger one
 
-        if (nextCell != null) {
-          return nextCell;
+            if (range.contains(other)) {
+              result.splice(j, 1);
+            } else if (other.contains(range)) {
+              wasModified = true;
+              result[i] = other;
+              result.splice(j, 1);
+              break;
+            } else if (range.startRow === other.startRow && range.endRow === other.endRow) {
+              if (range.touches(other)) {
+                // If the start/end rows match, and columns touch, consolidate
+                var startRow = range.startRow,
+                    endRow = range.endRow;
+                var startColumn = GridRange.minOrNull(range.startColumn, other.startColumn);
+                var endColumn = GridRange.maxOrNull(range.endColumn, other.endColumn);
+                wasModified = true;
+                result[i] = new GridRange(startColumn, startRow, endColumn, endRow);
+                result.splice(j, 1);
+                break;
+              }
+            } else if (range.startColumn === other.startColumn && range.endColumn === other.endColumn) {
+              if (range.touches(other)) {
+                // If the start/end rows match, and columns touch, consolidate
+                var _startColumn = range.startColumn,
+                    _endColumn = range.endColumn;
+
+                var _startRow = GridRange.minOrNull(range.startRow, other.startRow);
+
+                var _endRow = GridRange.maxOrNull(range.endRow, other.endRow);
+
+                wasModified = true;
+                result[i] = new GridRange(_startColumn, _startRow, _endColumn, _endRow);
+                result.splice(j, 1);
+                break;
+              }
+            }
+          }
         }
       }
-    } // Otherwise go to the start of the next range (could be same range if only one range)
-
 
-    switch (direction) {
-      case GridRange.SELECTION_DIRECTION.DOWN:
-      case GridRange.SELECTION_DIRECTION.RIGHT:
-        {
-          var nextRangeIndex = rangeIndex < ranges.length - 1 ? rangeIndex + 1 : 0;
-          var nextRange = ranges[nextRangeIndex];
-          return nextRange.startCell(direction);
+      return result;
+    }
+  }, {
+    key: "isAxisRangeTouching",
+    value: function isAxisRangeTouching(start, end, otherStart, otherEnd) {
+      if (start == null) {
+        if (end == null) {
+          return true;
         }
 
-      case GridRange.SELECTION_DIRECTION.LEFT:
-      case GridRange.SELECTION_DIRECTION.UP:
-        {
-          var _nextRangeIndex = rangeIndex > 0 ? rangeIndex - 1 : ranges.length - 1;
-
-          var _nextRange = ranges[_nextRangeIndex];
-          return _nextRange.startCell(direction);
+        if (otherStart == null) {
+          return true;
         }
 
-      default:
-        throw new Error("Invalid direction: ".concat(direction));
-    }
-  }
-  /**
-   * Count the number of cells in the provided grid ranges
-   * @param {GridRange[]} ranges The ranges to count the rows of
-   * @returns {number|NaN} The number of cells in the ranges, or `NaN` if any of the ranges were unbounded
-   */
-
-
-  static cellCount(ranges) {
-    return ranges.reduce((cellCount, range) => {
-      var _range$endRow2, _range$startRow2, _range$endColumn2, _range$startColumn2;
-
-      return cellCount + (((_range$endRow2 = range.endRow) !== null && _range$endRow2 !== void 0 ? _range$endRow2 : NaN) - ((_range$startRow2 = range.startRow) !== null && _range$startRow2 !== void 0 ? _range$startRow2 : NaN) + 1) * (((_range$endColumn2 = range.endColumn) !== null && _range$endColumn2 !== void 0 ? _range$endColumn2 : NaN) - ((_range$startColumn2 = range.startColumn) !== null && _range$startColumn2 !== void 0 ? _range$startColumn2 : NaN) + 1);
-    }, 0);
-  }
-  /**
-   * Count the number of rows in the provided grid ranges
-   * @param {GridRange[]} ranges The ranges to count the rows of
-   * @returns {number|NaN} The number of rows in the ranges, or `NaN` if any of the ranges were unbounded
-   */
-
-
-  static rowCount(ranges) {
-    return ranges.reduce((rowCount, range) => {
-      var _range$endRow3, _range$startRow3;
+        return otherStart <= end + 1;
+      }
 
-      return rowCount + ((_range$endRow3 = range.endRow) !== null && _range$endRow3 !== void 0 ? _range$endRow3 : NaN) - ((_range$startRow3 = range.startRow) !== null && _range$startRow3 !== void 0 ? _range$startRow3 : NaN) + 1;
-    }, 0);
-  }
-  /**
-   * Count the number of columns in the provided grid ranges
-   * @param {GridRange[]} ranges The ranges to count the columns of
-   * @returns {number|NaN} The number of columns in the ranges, or `NaN` if any of the ranges were unbounded
-   */
+      if (end == null) {
+        if (otherEnd == null) {
+          return true;
+        }
 
+        return otherEnd >= start - 1;
+      }
 
-  static columnCount(ranges) {
-    return ranges.reduce((columnCount, range) => {
-      var _range$endColumn3, _range$startColumn3;
+      if (otherStart == null) {
+        if (otherEnd == null) {
+          return true;
+        }
 
-      return columnCount + ((_range$endColumn3 = range.endColumn) !== null && _range$endColumn3 !== void 0 ? _range$endColumn3 : NaN) - ((_range$startColumn3 = range.startColumn) !== null && _range$startColumn3 !== void 0 ? _range$startColumn3 : NaN) + 1;
-    }, 0);
-  }
-  /**
-   * Check if the provided ranges contain the provided cell
-   * @param {GridRange[]} ranges The ranges to check
-   * @param {number} column The column index
-   * @param {number} row The row index
-   * @returns {boolean} True if the cell is within the provided ranges, false otherwise.
-   */
+        return start <= otherEnd + 1;
+      }
 
+      if (otherEnd == null) {
+        return end >= otherStart - 1;
+      }
 
-  static containsCell(ranges, column, row) {
-    for (var i = 0; i < ranges.length; i += 1) {
-      var range = ranges[i];
+      if (otherStart >= start - 1) {
+        return otherStart <= end + 1;
+      }
 
-      if (range.containsCell(column, row)) {
+      return otherEnd >= start - 1;
+    }
+  }, {
+    key: "rangeArraysEqual",
+    value: function rangeArraysEqual(ranges1, ranges2) {
+      if (ranges1 === ranges2) {
         return true;
       }
-    }
-
-    return false;
-  }
-  /**
-   * Iterate through each cell in the provided ranges
-   * @param {GridRange[]} ranges The ranges to iterate through
-   * @param {(column: number, row: number, index: number) => void} callback The callback to execute. `index` is the index within that range
-   * @param {GridRange.SELECTION_DIRECTION} direction The direction to iterate in
-   */
 
+      if (ranges1 == null || ranges2 == null || ranges1.length !== ranges2.length) {
+        return false;
+      }
 
-  static forEachCell(ranges, callback) {
-    var direction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : GridRange.SELECTION_DIRECTION.RIGHT;
+      for (var i = 0; i < ranges1.length; i += 1) {
+        if (!ranges1[i].equals(ranges2[i])) {
+          return false;
+        }
+      }
 
-    for (var i = 0; i < ranges.length; i += 1) {
-      ranges[i].forEach(callback, direction);
+      return true;
     }
-  }
+    /**
+     * Get the intersection (overlapping area) of two ranges
+     * @param {GridRange} range One range to check for the intersection
+     * @param {GridRange} otherRange The other range to check for the intersection
+     * @returns {GridRange|null} Intersection of the two ranges. If they do not intersect, returns `null`.
+     */
+
+  }, {
+    key: "intersection",
+    value: function intersection(range, otherRange) {
+      var _startColumn2, _endColumn2, _startRow2, _endRow2;
+
+      if (range.equals(otherRange)) {
+        return range;
+      }
 
-  constructor(startColumn, startRow, endColumn, endRow) {
-    this.startColumn = startColumn;
-    this.startRow = startRow;
-    this.endColumn = endColumn;
-    this.endRow = endRow;
-  }
+      var startColumn = range.startColumn,
+          startRow = range.startRow,
+          endColumn = range.endColumn,
+          endRow = range.endRow;
+      startColumn = startColumn != null && otherRange.startColumn != null ? Math.max(startColumn, otherRange.startColumn) : (_startColumn2 = startColumn) !== null && _startColumn2 !== void 0 ? _startColumn2 : otherRange.startColumn;
+      endColumn = endColumn != null && otherRange.endColumn != null ? Math.min(endColumn, otherRange.endColumn) : (_endColumn2 = endColumn) !== null && _endColumn2 !== void 0 ? _endColumn2 : otherRange.endColumn;
+      startRow = startRow != null && otherRange.startRow != null ? Math.max(startRow, otherRange.startRow) : (_startRow2 = startRow) !== null && _startRow2 !== void 0 ? _startRow2 : otherRange.startRow;
+      endRow = endRow != null && otherRange.endRow != null ? Math.min(endRow, otherRange.endRow) : (_endRow2 = endRow) !== null && _endRow2 !== void 0 ? _endRow2 : otherRange.endRow;
+
+      if (startColumn != null && startColumn > endColumn || startRow != null && startRow > endRow) {
+        return null;
+      }
 
-  equals(other) {
-    return this.startColumn === other.startColumn && this.startRow === other.startRow && this.endColumn === other.endColumn && this.endRow === other.endRow;
-  }
-  /** @returns {boolean} true if this GridRange completely contains `other` */
+      return new GridRange(startColumn, startRow, endColumn, endRow);
+    }
+    /**
+     * @param {GridRange} range The range to be subtracted from
+     * @param {GridRange} subtractRange The range to subtract from within this range
+     * @returns {GridRange[]} The ranges needed to represent the remaining
+     */
 
+  }, {
+    key: "subtractFromRange",
+    value: function subtractFromRange(range, subtractRange) {
+      var result = []; // Make it a little easier by finding only the part the subtraction range intersects
 
-  contains(other) {
-    return (this.startColumn == null || other.startColumn != null && this.startColumn <= other.startColumn) && (this.startRow == null || other.startRow != null && this.startRow <= other.startRow) && (this.endColumn == null || other.endColumn != null && this.endColumn >= other.endColumn) && (this.endRow == null || other.endRow != null && this.endRow >= other.endRow);
-  }
-  /**
-   * Check if the provided cell is in this range
-   * @param {number} column The column to check
-   * @param {number} row The row to check
-   * @returns {boolean} True if this cell is within this range
-   */
+      var subtract = GridRange.intersection(range, subtractRange);
 
+      if (subtract == null) {
+        return [range];
+      } // Go through each of the quadrants for deselection, there can be up to 4
+      // Top quadrant (above the subtracted area)
 
-  containsCell(column, row) {
-    if (column == null || row == null) {
-      return false;
-    }
 
-    return (this.startColumn == null || this.startColumn <= column) && (this.endColumn == null || this.endColumn >= column) && (this.startRow == null || this.startRow <= row) && (this.endRow == null || this.endRow >= row);
-  }
-  /** @returns {boolean} true if this GridRange touches `other` */
+      if (subtract.startRow != null && (range.startRow == null || range.startRow < subtract.startRow)) {
+        result.push(new GridRange(range.startColumn, range.startRow, range.endColumn, subtract.startRow - 1));
+      } // middle left
 
 
-  touches(other) {
-    return GridRange.isAxisRangeTouching(this.startRow, this.endRow, other.startRow, other.endRow) && GridRange.isAxisRangeTouching(this.startColumn, this.endColumn, other.startColumn, other.endColumn);
-  }
-  /**
-   * @param {GridRange} other The range to deselect from within this range
-   * @returns {[GridRange]} The ranges needed to represent the remaining
-   */
+      if (subtract.startColumn != null && (range.startColumn == null || range.startColumn < subtract.startColumn)) {
+        result.push(new GridRange(range.startColumn, subtract.startRow, subtract.startColumn - 1, subtract.endRow));
+      } // middle right
 
 
-  subtract(other) {
-    return GridRange.subtractFromRange(this, other);
-  }
-  /**
-   * Get the first cell in this range. Throws if this range is unbounded.
-   *
-   * @param {GridRange.SELECTION_DIRECTION?} direction The direction to get the starting cell in. Defaults to DOWN
-   * @returns {{column: number, row: number}} The first cell in this range in the direction specified
-   */
+      if (subtract.endColumn != null && (range.endColumn == null || range.endColumn > subtract.endColumn)) {
+        result.push(new GridRange(subtract.endColumn + 1, subtract.startRow, range.endColumn, subtract.endRow));
+      } // Bottom quadrant
 
 
-  startCell() {
-    var direction = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : GridRange.SELECTION_DIRECTION.DOWN;
+      if (subtract.endRow != null && (range.endRow == null || range.endRow > subtract.endRow)) {
+        result.push(new GridRange(range.startColumn, subtract.endRow + 1, range.endColumn, range.endRow));
+      }
 
-    if (!GridRange.isBounded(this)) {
-      throw new Error('Cannot get the startCell of an unbounded range');
+      return result;
     }
+    /**
+     * Subtract a range from multiple ranges
+     * @param {GridRange[]} ranges The ranges to be subtracted from
+     * @param {GridRange} subtractRange The range to subtract from within these ranges
+     * @returns {GridRange[]} The ranges needed to represent the remaining
+     */
+
+  }, {
+    key: "subtractFromRanges",
+    value: function subtractFromRanges(ranges, subtractRange) {
+      var result = [];
+
+      for (var i = 0; i < ranges.length; i += 1) {
+        result.push.apply(result, _toConsumableArray(GridRange.subtractFromRange(ranges[i], subtractRange)));
+      }
 
-    switch (direction) {
-      case GridRange.SELECTION_DIRECTION.DOWN:
-      case GridRange.SELECTION_DIRECTION.RIGHT:
-        return {
-          column: this.startColumn,
-          row: this.startRow
-        };
-
-      case GridRange.SELECTION_DIRECTION.LEFT:
-      case GridRange.SELECTION_DIRECTION.UP:
-        {
-          return {
-            column: this.endColumn,
-            row: this.endRow
-          };
-        }
-
-      default:
-        throw new Error("Invalid direction: ".concat(direction));
+      return result;
     }
-  }
-  /**
-   * Get the next cell in the direction specified. Throws if this range is unbounded.
-   * If already at the bounds of the range in that direction, wrap to the next column or row
-   * If at the end of the entire range, return null
-   * If outside of the range, returns the next cell closest within this range.
-   *
-   * @param {number} column The cursor column
-   * @param {number} row The cursor row
-   * @param {SELECTION_DIRECTION} direction The direction to go in
-   * @returns {GridCell|null} The next cell in the direction specified, or `null` if at the end of the range
-   */
-
-
-  nextCell(column, row, direction) {
-    if (!GridRange.isBounded(this)) {
-      throw new Error('Bounded range required');
-    }
-
-    if (column == null || row == null) {
-      throw new Error('Require a non-null cursor');
-    }
-
-    var {
-      startColumn,
-      endColumn,
-      startRow,
-      endRow
-    } = this;
-
-    switch (direction) {
-      case GridRange.SELECTION_DIRECTION.DOWN:
-        if (row < endRow) {
-          return {
-            column,
-            row: Math.max(row + 1, startRow)
-          };
-        }
+    /**
+     * Subtract multiple ranges from multiple ranges
+     * @param {GridRange[]} ranges The ranges to be subtracted from
+     * @param {GridRange[]} subtractRanges The ranges to subtract from within these ranges
+     * @returns {GridRange[]} The ranges needed to represent the remaining
+     */
+
+  }, {
+    key: "subtractRangesFromRanges",
+    value: function subtractRangesFromRanges(ranges, subtractRanges) {
+      if (!subtractRanges || subtractRanges.length === 0) {
+        return ranges;
+      }
 
-        if (column < endColumn) {
-          return {
-            column: Math.max(column + 1, startColumn),
-            row: startRow
-          };
-        }
+      var result = _toConsumableArray(ranges);
 
-        break;
+      for (var i = 0; i < subtractRanges.length; i += 1) {
+        result = GridRange.subtractFromRanges(result, subtractRanges[i]);
+      }
 
-      case GridRange.SELECTION_DIRECTION.UP:
-        if (row > startRow) {
-          return {
-            column,
-            row: Math.min(row - 1, endRow)
-          };
-        }
+      return result;
+    }
+    /**
+     * Test if a given range is bounded (all values are non-null)
+     * @param {GridRange} range The range to test
+     * @returns {boolean} True if this range is bounded, false otherwise
+     */
+
+  }, {
+    key: "isBounded",
+    value: function isBounded(range) {
+      return range.startRow != null && range.startColumn != null && range.endRow != null && range.endColumn != null;
+    }
+    /**
+     * Converts any GridRange passed in that is a full row or column selection to be bound
+     * to the `columnCount` and `rowCount` passed in
+     *
+     * @param {GridRange} range The range to get the bounded range of
+     * @param {number} columnCount The number of columns
+     * @param {number} rowCount The number of rows
+     * @returns {GridRange} The passed in GridRange with any null values filled in
+     */
+
+  }, {
+    key: "boundedRange",
+    value: function boundedRange(range, columnCount, rowCount) {
+      var _range$startColumn, _range$startRow, _range$endColumn, _range$endRow;
+
+      if (GridRange.isBounded(range)) {
+        return range;
+      }
 
-        if (column > startColumn) {
-          return {
-            column: Math.min(column - 1, endColumn),
-            row: endRow
-          };
-        }
+      return new GridRange((_range$startColumn = range.startColumn) !== null && _range$startColumn !== void 0 ? _range$startColumn : 0, (_range$startRow = range.startRow) !== null && _range$startRow !== void 0 ? _range$startRow : 0, (_range$endColumn = range.endColumn) !== null && _range$endColumn !== void 0 ? _range$endColumn : columnCount - 1, (_range$endRow = range.endRow) !== null && _range$endRow !== void 0 ? _range$endRow : rowCount - 1);
+    }
+    /**
+     * Converts the GridRanges passed in to be bound to the `columnCount` and `rowCount` passed in
+     *
+     * @param {GridRange[]} ranges The ranges to get the bounded ranges of
+     * @param {number} columnCount The number of columns
+     * @param {number} rowCount The number of rows
+     * @returns {GridRange} The passed in GridRange with any null values filled in
+     */
+
+  }, {
+    key: "boundedRanges",
+    value: function boundedRanges(ranges, columnCount, rowCount) {
+      return ranges.map(function (r) {
+        return GridRange.boundedRange(r, columnCount, rowCount);
+      });
+    }
+    /**
+     * Offsets a GridRange by the specified amount in the x and y directions
+     *
+     * @param {GridRange} range The range to offset
+     * @param {number} columnOffset The number of columns to offset
+     * @param {number} rowOffset The number of rows to offset
+     * @returns {GridRange} The new grid range offset from the original
+     */
+
+  }, {
+    key: "offset",
+    value: function offset(range, columnOffset, rowOffset) {
+      return new GridRange(range.startColumn != null ? range.startColumn + columnOffset : null, range.startRow != null ? range.startRow + rowOffset : null, range.endColumn != null ? range.endColumn + columnOffset : null, range.endRow != null ? range.endRow + rowOffset : null);
+    }
+    /**
+     * Get the next cell given the selected ranges and the current cell
+     * @param {GridRange[]} ranges The selected bounded ranges within the grid
+     * @param {number|null} column The cursor column, or null if none focused
+     * @param {number|null} row The cursor row, or null if none focused
+     * @param {SELECTION_DIRECTION} direction The direction in which to select next
+     * @returns {Cell} The next cell to focus, or null if there should be no more focus
+     */
+
+  }, {
+    key: "nextCell",
+    value: function nextCell(ranges) {
+      var column = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      var row = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var direction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : GridRange.SELECTION_DIRECTION.DOWN;
+
+      if (ranges.length === 0) {
+        return null;
+      }
 
-        break;
+      var rangeIndex = -1;
 
-      case GridRange.SELECTION_DIRECTION.RIGHT:
-        if (column < endColumn) {
-          return {
-            column: Math.max(column + 1, startColumn),
-            row
-          };
-        }
+      if (column != null && row != null) {
+        rangeIndex = ranges.findIndex(function (r) {
+          return r.containsCell(column, row);
+        });
 
-        if (row < endRow) {
-          return {
-            column: startColumn,
-            row: Math.max(row + 1, startRow)
-          };
+        if (rangeIndex >= 0) {
+          var range = ranges[rangeIndex];
+          var nextCell = range.nextCell(column, row, direction);
+
+          if (nextCell != null) {
+            return nextCell;
+          }
         }
+      } // Otherwise go to the start of the next range (could be same range if only one range)
 
-        break;
 
-      case GridRange.SELECTION_DIRECTION.LEFT:
-        if (column > startColumn) {
-          return {
-            column: Math.min(column - 1, endColumn),
-            row
-          };
-        }
+      switch (direction) {
+        case GridRange.SELECTION_DIRECTION.DOWN:
+        case GridRange.SELECTION_DIRECTION.RIGHT:
+          {
+            var nextRangeIndex = rangeIndex < ranges.length - 1 ? rangeIndex + 1 : 0;
+            var nextRange = ranges[nextRangeIndex];
+            return nextRange.startCell(direction);
+          }
 
-        if (row > startRow) {
-          return {
-            column: endColumn,
-            row: Math.min(row - 1, endRow)
-          };
-        }
+        case GridRange.SELECTION_DIRECTION.LEFT:
+        case GridRange.SELECTION_DIRECTION.UP:
+          {
+            var _nextRangeIndex = rangeIndex > 0 ? rangeIndex - 1 : ranges.length - 1;
 
-        break;
+            var _nextRange = ranges[_nextRangeIndex];
+            return _nextRange.startCell(direction);
+          }
 
-      default:
-        throw new Error("Invalid direction: ".concat(direction));
+        default:
+          throw new Error("Invalid direction: ".concat(direction));
+      }
+    }
+    /**
+     * Count the number of cells in the provided grid ranges
+     * @param {GridRange[]} ranges The ranges to count the rows of
+     * @returns {number|NaN} The number of cells in the ranges, or `NaN` if any of the ranges were unbounded
+     */
+
+  }, {
+    key: "cellCount",
+    value: function cellCount(ranges) {
+      return ranges.reduce(function (cellCount, range) {
+        var _range$endRow2, _range$startRow2, _range$endColumn2, _range$startColumn2;
+
+        return cellCount + (((_range$endRow2 = range.endRow) !== null && _range$endRow2 !== void 0 ? _range$endRow2 : NaN) - ((_range$startRow2 = range.startRow) !== null && _range$startRow2 !== void 0 ? _range$startRow2 : NaN) + 1) * (((_range$endColumn2 = range.endColumn) !== null && _range$endColumn2 !== void 0 ? _range$endColumn2 : NaN) - ((_range$startColumn2 = range.startColumn) !== null && _range$startColumn2 !== void 0 ? _range$startColumn2 : NaN) + 1);
+      }, 0);
     }
+    /**
+     * Count the number of rows in the provided grid ranges
+     * @param {GridRange[]} ranges The ranges to count the rows of
+     * @returns {number|NaN} The number of rows in the ranges, or `NaN` if any of the ranges were unbounded
+     */
+
+  }, {
+    key: "rowCount",
+    value: function rowCount(ranges) {
+      return ranges.reduce(function (rowCount, range) {
+        var _range$endRow3, _range$startRow3;
+
+        return rowCount + ((_range$endRow3 = range.endRow) !== null && _range$endRow3 !== void 0 ? _range$endRow3 : NaN) - ((_range$startRow3 = range.startRow) !== null && _range$startRow3 !== void 0 ? _range$startRow3 : NaN) + 1;
+      }, 0);
+    }
+    /**
+     * Count the number of columns in the provided grid ranges
+     * @param {GridRange[]} ranges The ranges to count the columns of
+     * @returns {number|NaN} The number of columns in the ranges, or `NaN` if any of the ranges were unbounded
+     */
+
+  }, {
+    key: "columnCount",
+    value: function columnCount(ranges) {
+      return ranges.reduce(function (columnCount, range) {
+        var _range$endColumn3, _range$startColumn3;
+
+        return columnCount + ((_range$endColumn3 = range.endColumn) !== null && _range$endColumn3 !== void 0 ? _range$endColumn3 : NaN) - ((_range$startColumn3 = range.startColumn) !== null && _range$startColumn3 !== void 0 ? _range$startColumn3 : NaN) + 1;
+      }, 0);
+    }
+    /**
+     * Check if the provided ranges contain the provided cell
+     * @param {GridRange[]} ranges The ranges to check
+     * @param {number} column The column index
+     * @param {number} row The row index
+     * @returns {boolean} True if the cell is within the provided ranges, false otherwise.
+     */
+
+  }, {
+    key: "containsCell",
+    value: function containsCell(ranges, column, row) {
+      for (var i = 0; i < ranges.length; i += 1) {
+        var range = ranges[i];
+
+        if (range.containsCell(column, row)) {
+          return true;
+        }
+      }
 
-    return null;
-  }
-  /**
-   * Iterate through each cell in the range
-   * @param {(column:number, row:number, index:number) => void} callback Callback to execute. `index` is the index within this range
-   * @param {GridRange.SELECTION_DIRECTION} direction The direction to iterate in
-   */
-
-
-  forEach(callback) {
-    var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : GridRange.SELECTION_DIRECTION.RIGHT;
-    var i = 0;
-    var {
-      column: c,
-      row: r
-    } = this.startCell(direction);
-
-    while (c != null && r != null) {
-      var _this$nextCell;
-
-      callback(c, r, i);
-      i += 1;
-      ({
-        column: c,
-        row: r
-      } = (_this$nextCell = this.nextCell(c, r, direction)) !== null && _this$nextCell !== void 0 ? _this$nextCell : {});
+      return false;
     }
-  }
+    /**
+     * Iterate through each cell in the provided ranges
+     * @param {GridRange[]} ranges The ranges to iterate through
+     * @param {(column: number, row: number, index: number) => void} callback The callback to execute. `index` is the index within that range
+     * @param {GridRange.SELECTION_DIRECTION} direction The direction to iterate in
+     */
+
+  }, {
+    key: "forEachCell",
+    value: function forEachCell(ranges, callback) {
+      var direction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : GridRange.SELECTION_DIRECTION.RIGHT;
+
+      for (var i = 0; i < ranges.length; i += 1) {
+        ranges[i].forEach(callback, direction);
+      }
+    }
+  }]);
 
-}
+  return GridRange;
+}();
 
 _defineProperty(GridRange, "SELECTION_DIRECTION", Object.freeze({
   DOWN: 'DOWN',