diff --git a/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurer.js b/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurer.js
index d9716a0..e7a9f9f 100644
--- a/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurer.js
+++ b/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurer.js
@@ -166,13 +166,19 @@ var CellMeasurer = function (_React$PureComponent) {
             height = _getCellMeasurements2.height,
             width = _getCellMeasurements2.width;
 
+
         cache.set(rowIndex, columnIndex, width, height);
 
         // If size has changed, let Grid know to re-render.
         if (parent && typeof parent.invalidateCellSizeAfterRender === 'function') {
+          const heightChange = height - cache.defaultHeight;
+          const widthChange = width - cache.defaultWidth;
+
           parent.invalidateCellSizeAfterRender({
             columnIndex: columnIndex,
-            rowIndex: rowIndex
+            rowIndex: rowIndex,
+            heightChange: heightChange,
+            widthChange: widthChange,
           });
         }
       }
diff --git a/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurerCache.js b/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurerCache.js
index 262776b..156cf0f 100644
--- a/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurerCache.js
+++ b/node_modules/react-virtualized/dist/commonjs/CellMeasurer/CellMeasurerCache.js
@@ -65,6 +65,7 @@ var CellMeasurerCache = function () {
         minWidth = params.minWidth;
 
 
+    this._highWaterMark = 0;
     this._hasFixedHeight = fixedHeight === true;
     this._hasFixedWidth = fixedWidth === true;
     this._minHeight = minHeight || 0;
@@ -101,6 +102,24 @@ var CellMeasurerCache = function () {
 
       this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
     }
+  }, {
+    key: 'clearPlus',
+    value: function clearPlus(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+      if (this._highWaterMark <= rowIndex) {
+        this.clear(rowIndex, columnIndex);
+        return;
+      }
+
+      for (let i = rowIndex, max = this._highWaterMark; i <= max; i += 1) {
+        var key = this._keyMapper(i, columnIndex);
+        delete this._cellHeightCache[key];
+        delete this._cellWidthCache[key];
+      }
+
+      this._highWaterMark = Math.max(0, rowIndex - 1);
+    }
   }, {
     key: 'clearAll',
     value: function clearAll() {
@@ -168,6 +187,8 @@ var CellMeasurerCache = function () {
         this._rowCount = rowIndex + 1;
       }
 
+      this._highWaterMark = Math.max(this._highWaterMark, rowIndex);
+
       // Size is cached per cell so we don't have to re-measure if cells are re-ordered.
       this._cellHeightCache[key] = height;
       this._cellWidthCache[key] = width;
diff --git a/node_modules/react-virtualized/dist/commonjs/Grid/Grid.js b/node_modules/react-virtualized/dist/commonjs/Grid/Grid.js
index e1b959a..7410c0a 100644
--- a/node_modules/react-virtualized/dist/commonjs/Grid/Grid.js
+++ b/node_modules/react-virtualized/dist/commonjs/Grid/Grid.js
@@ -132,6 +132,9 @@ var Grid = function (_React$PureComponent) {
     _this._renderedRowStopIndex = 0;
     _this._styleCache = {};
     _this._cellCache = {};
+    _this._cellUpdates = [];
+    this._hasScrolledToColumnTarget = false;
+    this._hasScrolledToRowTarget = false;
 
     _this._debounceScrollEndedCallback = function () {
       _this._disablePointerEventsTimeoutId = null;
@@ -345,7 +348,11 @@ var Grid = function (_React$PureComponent) {
         scrollLeft: scrollLeft,
         scrollTop: scrollTop,
         totalColumnsWidth: totalColumnsWidth,
-        totalRowsHeight: totalRowsHeight
+        totalRowsHeight: totalRowsHeight,
+        scrollToColumn: this.props.scrollToColumn,
+        _hasScrolledToColumnTarget: this._hasScrolledToColumnTarget,
+        scrollToRow: this.props.scrollToRow,
+        _hasScrolledToRowTarget: this._hasScrolledToRowTarget,
       });
     }
 
@@ -363,6 +370,13 @@ var Grid = function (_React$PureComponent) {
       var columnIndex = _ref3.columnIndex,
           rowIndex = _ref3.rowIndex;
 
+      if (columnIndex < this._lastColumnStartIndex) {
+        this._cellUpdates.push({ columnIndex, widthChange: _ref3.widthChange });
+      }
+      if (rowIndex < this._lastRowStartIndex) {
+        this._cellUpdates.push({ rowIndex, heightChange: _ref3.heightChange });
+      }
+
       this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;
       this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;
     }
@@ -381,8 +395,12 @@ var Grid = function (_React$PureComponent) {
           rowCount = _props2.rowCount;
       var instanceProps = this.state.instanceProps;
 
-      instanceProps.columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1);
-      instanceProps.rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1);
+      if (columnCount > 0) {
+        instanceProps.columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1);
+      }
+      if (rowCount > 0) {
+        instanceProps.rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1);
+      }
     }
 
     /**
@@ -415,6 +433,16 @@ var Grid = function (_React$PureComponent) {
       this._recomputeScrollLeftFlag = scrollToColumn >= 0 && (this.state.scrollDirectionHorizontal === _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD ? columnIndex <= scrollToColumn : columnIndex >= scrollToColumn);
       this._recomputeScrollTopFlag = scrollToRow >= 0 && (this.state.scrollDirectionVertical === _defaultOverscanIndicesGetter.SCROLL_DIRECTION_FORWARD ? rowIndex <= scrollToRow : rowIndex >= scrollToRow);
 
+      // Important to ensure that when we, say, change the width of the viewport,
+      //   we don't re-render, capture deltas, and move the scroll location around.
+      if (rowIndex === 0 && columnIndex === 0) {
+        this._disableCellUpdates = true;
+      }
+
+      // Global notification that we should retry our scroll to props-requested indices
+      this._hasScrolledToColumnTarget = false;
+      this._hasScrolledToRowTarget = false;
+
       // Clear cell cache in case we are scrolling;
       // Invalid row heights likely mean invalid cached content as well.
       this._styleCache = {};
@@ -526,7 +554,11 @@ var Grid = function (_React$PureComponent) {
         scrollLeft: scrollLeft || 0,
         scrollTop: scrollTop || 0,
         totalColumnsWidth: instanceProps.columnSizeAndPositionManager.getTotalSize(),
-        totalRowsHeight: instanceProps.rowSizeAndPositionManager.getTotalSize()
+        totalRowsHeight: instanceProps.rowSizeAndPositionManager.getTotalSize(),
+        scrollToColumn: scrollToColumn,
+        _hasScrolledToColumnTarget: this._hasScrolledToColumnTarget,
+        scrollToRow: scrollToRow,
+        _hasScrolledToRowTarget: this._hasScrolledToRowTarget,
       });
 
       this._maybeCallOnScrollbarPresenceChange();
@@ -584,6 +616,65 @@ var Grid = function (_React$PureComponent) {
         }
       }
 
+      var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();
+      var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();
+
+      // We reset our hasScrolled flags if our target has changed, or if target is not longer set
+      if (scrollToColumn !== prevProps.scrollToColumn || scrollToColumn == null || scrollToColumn < 0) {
+        this._hasScrolledToColumnTarget = false;
+      }
+      if (scrollToRow !== prevProps.scrollToRow || scrollToRow == null || scrollToRow < 0) {
+        this._hasScrolledToRowTarget = false;
+      }
+
+      // We deactivate our forced scrolling if the user scrolls
+      if (scrollLeft !== prevState.scrollLeft && scrollToColumn >= 0 && scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.OBSERVED) {
+        this._hasScrolledToColumnTarget = true;
+      }
+      if (scrollTop !== prevState.scrollTop && scrollToRow >= 0 && scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.OBSERVED) {
+        this._hasScrolledToRowTarget = true;
+      }
+
+      if (scrollToColumn >= 0 && !this._hasScrolledToColumnTarget && scrollLeft + width <= totalColumnsWidth) {
+        const scrollRight = scrollLeft + width;
+        const targetColumn = instanceProps.columnSizeAndPositionManager.getSizeAndPositionOfCell(scrollToColumn);
+
+        let isVisible = false;
+        if (targetColumn.size <= width) {
+          const targetColumnRight = targetColumn.offset + targetColumn.size;
+          isVisible = (targetColumn.offset >= scrollLeft && targetColumnRight <= scrollRight);
+        } else {
+          isVisible = (targetColumn.offset >= scrollLeft && targetColumn.offset <= scrollRight);
+        }
+
+        if (isVisible) {
+          const maxScroll = totalColumnsWidth - width;
+          this._hasScrolledToColumnTarget = (scrollLeft >= maxScroll || targetColumn.offset === scrollLeft);
+        }
+      }
+      if (scrollToRow >= 0 && !this._hasScrolledToRowTarget && scrollTop + height <= totalRowsHeight) {
+        const scrollBottom = scrollTop + height;
+        const targetRow = instanceProps.rowSizeAndPositionManager.getSizeAndPositionOfCell(scrollToRow);
+        const maxScroll = totalRowsHeight - height;
+
+        // When scrolling to bottom row, we want to go all the way to the bottom
+        if (scrollToRow === rowCount - 1) {
+          this._hasScrolledToRowTarget = scrollTop >= maxScroll;
+        } else {
+          let isVisible = false;
+          if (targetRow.size <= height) {
+            const targetRowBottom = targetRow.offset + targetRow.size;
+            isVisible = (targetRow.offset >= scrollTop && targetRowBottom <= scrollBottom);
+          } else {
+            isVisible = (targetRow.offset >= scrollTop && targetRow.offset <= scrollBottom);
+          }
+
+          if (isVisible) {
+            this._hasScrolledToRowTarget = (scrollTop >= maxScroll || targetRow.offset === scrollTop);
+          }
+        }
+      }
+
       // Special case where the previous size was 0:
       // In this case we don't show any windowed cells at all.
       // So we should always recalculate offset afterwards.
@@ -594,6 +685,8 @@ var Grid = function (_React$PureComponent) {
       if (this._recomputeScrollLeftFlag) {
         this._recomputeScrollLeftFlag = false;
         this._updateScrollLeftForScrollToColumn(this.props);
+      } else if (this.props.scrollToColumn >= 0 && !this._hasScrolledToColumnTarget) {
+        this._updateScrollLeftForScrollToColumn(this.props);
       } else {
         (0, _updateScrollIndexHelper2.default)({
           cellSizeAndPositionManager: instanceProps.columnSizeAndPositionManager,
@@ -616,6 +709,8 @@ var Grid = function (_React$PureComponent) {
       if (this._recomputeScrollTopFlag) {
         this._recomputeScrollTopFlag = false;
         this._updateScrollTopForScrollToRow(this.props);
+      } else if (this.props.scrollToRow >= 0 && !this._hasScrolledToRowTarget) {
+        this._updateScrollTopForScrollToRow(this.props);
       } else {
         (0, _updateScrollIndexHelper2.default)({
           cellSizeAndPositionManager: instanceProps.rowSizeAndPositionManager,
@@ -635,19 +730,50 @@ var Grid = function (_React$PureComponent) {
         });
       }
 
+
+      if (this._disableCellUpdates) {
+        this._cellUpdates = [];
+      }
+      this._disableCellUpdates = false;
+      if (this.props.scrollToRow >= 0 && !this._hasScrolledToRowTarget) {
+        this._cellUpdates = [];
+      }
+      if (this.props.scrollToColumn >= 0 && !this._hasScrolledToColumnTarget) {
+        this._cellUpdates = [];
+      }
+      if (this._cellUpdates.length && scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.OBSERVED) {
+        let item;
+        let verticalDelta = 0;
+        let horizontalDelta = 0;
+
+        while (item = this._cellUpdates.shift()) {
+          verticalDelta += item.heightChange || 0;
+          horizontalDelta += item.widthChange || 0;
+        }
+
+        if (verticalDelta !== 0 || horizontalDelta !== 0) {
+          this.setState(Grid._getScrollToPositionStateUpdate({
+            prevState: this.state,
+            scrollTop: scrollTop + verticalDelta,
+            scrollLeft: scrollLeft + horizontalDelta,
+          }));
+        }
+      }
+
       // Update onRowsRendered callback if start/stop indices have changed
       this._invokeOnGridRenderedHelper();
 
       // Changes to :scrollLeft or :scrollTop should also notify :onScroll listeners
       if (scrollLeft !== prevState.scrollLeft || scrollTop !== prevState.scrollTop) {
-        var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();
-        var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();
-
         this._invokeOnScrollMemoizer({
           scrollLeft: scrollLeft,
           scrollTop: scrollTop,
           totalColumnsWidth: totalColumnsWidth,
-          totalRowsHeight: totalRowsHeight
+          totalRowsHeight: totalRowsHeight,
+          scrollToColumn: scrollToColumn,
+          _hasScrolledToColumnTarget: this._hasScrolledToColumnTarget,
+          scrollToRow: scrollToRow,
+          _hasScrolledToRowTarget: this._hasScrolledToRowTarget,
         });
       }
 
@@ -909,6 +1035,11 @@ var Grid = function (_React$PureComponent) {
           visibleRowIndices: visibleRowIndices
         });
 
+        this._lastColumnStartIndex = this._columnStartIndex;
+        this._lastColumnStopIndex = this._columnStopIndex;
+        this._lastRowStartIndex = this._rowStartIndex;
+        this._lastRowStopIndex = this._rowStopIndex;
+
         // update the indices
         this._columnStartIndex = columnStartIndex;
         this._columnStopIndex = columnStopIndex;
@@ -962,7 +1093,11 @@ var Grid = function (_React$PureComponent) {
       var scrollLeft = _ref6.scrollLeft,
           scrollTop = _ref6.scrollTop,
           totalColumnsWidth = _ref6.totalColumnsWidth,
-          totalRowsHeight = _ref6.totalRowsHeight;
+          totalRowsHeight = _ref6.totalRowsHeight,
+          scrollToColumn = _ref6.scrollToColumn,
+          _hasScrolledToColumnTarget = _ref6._hasScrolledToColumnTarget,
+          scrollToRow = _ref6.scrollToRow,
+          _hasScrolledToRowTarget = _ref6._hasScrolledToRowTarget;
 
       this._onScrollMemoizer({
         callback: function callback(_ref7) {
@@ -973,19 +1108,26 @@ var Grid = function (_React$PureComponent) {
               onScroll = _props7.onScroll,
               width = _props7.width;
 
-
           onScroll({
             clientHeight: height,
             clientWidth: width,
             scrollHeight: totalRowsHeight,
             scrollLeft: scrollLeft,
             scrollTop: scrollTop,
-            scrollWidth: totalColumnsWidth
+            scrollWidth: totalColumnsWidth,
+            scrollToColumn: scrollToColumn,
+            _hasScrolledToColumnTarget: _hasScrolledToColumnTarget,
+            scrollToRow: scrollToRow,
+            _hasScrolledToRowTarget: _hasScrolledToRowTarget,
           });
         },
         indices: {
           scrollLeft: scrollLeft,
-          scrollTop: scrollTop
+          scrollTop: scrollTop,
+          scrollToColumn: scrollToColumn,
+          _hasScrolledToColumnTarget: _hasScrolledToColumnTarget,
+          scrollToRow: scrollToRow,
+          _hasScrolledToRowTarget: _hasScrolledToRowTarget,
         }
       });
     }
@@ -1325,6 +1467,15 @@ var Grid = function (_React$PureComponent) {
         var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();
         var scrollBarSize = instanceProps.scrollbarSizeMeasured && totalColumnsWidth > width ? instanceProps.scrollbarSize : 0;
 
+        // If we're scrolling to the last row, then we scroll as far as we can,
+        //   even if we can't see the entire row. We need to be at the bottom.
+        if (targetIndex === finalRow) {
+          const totalHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();
+          const maxScroll = totalHeight - height;
+
+          return maxScroll;
+        }
+
         return instanceProps.rowSizeAndPositionManager.getUpdatedOffsetForIndex({
           align: scrollToAlignment,
           containerSize: height - scrollBarSize,
diff --git a/node_modules/react-virtualized/dist/commonjs/Grid/accessibilityOverscanIndicesGetter.js b/node_modules/react-virtualized/dist/commonjs/Grid/accessibilityOverscanIndicesGetter.js
index 70b0abe..8e12ffc 100644
--- a/node_modules/react-virtualized/dist/commonjs/Grid/accessibilityOverscanIndicesGetter.js
+++ b/node_modules/react-virtualized/dist/commonjs/Grid/accessibilityOverscanIndicesGetter.js
@@ -32,15 +32,8 @@ function defaultOverscanIndicesGetter(_ref) {
   // For more info see issues #625
   overscanCellsCount = Math.max(1, overscanCellsCount);
 
-  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {
-    return {
-      overscanStartIndex: Math.max(0, startIndex - 1),
-      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)
-    };
-  } else {
-    return {
-      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),
-      overscanStopIndex: Math.min(cellCount - 1, stopIndex + 1)
-    };
-  }
+  return {
+    overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),
+    overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount),
+  };
 }
\ No newline at end of file
diff --git a/node_modules/react-virtualized/dist/commonjs/Grid/defaultOverscanIndicesGetter.js b/node_modules/react-virtualized/dist/commonjs/Grid/defaultOverscanIndicesGetter.js
index d5f6d04..c4b3d84 100644
--- a/node_modules/react-virtualized/dist/commonjs/Grid/defaultOverscanIndicesGetter.js
+++ b/node_modules/react-virtualized/dist/commonjs/Grid/defaultOverscanIndicesGetter.js
@@ -27,15 +27,8 @@ function defaultOverscanIndicesGetter(_ref) {
       startIndex = _ref.startIndex,
       stopIndex = _ref.stopIndex;
 
-  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {
-    return {
-      overscanStartIndex: Math.max(0, startIndex),
-      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)
-    };
-  } else {
-    return {
-      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),
-      overscanStopIndex: Math.min(cellCount - 1, stopIndex)
-    };
-  }
+  return {
+    overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),
+    overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount),
+  };
 }
\ No newline at end of file
diff --git a/node_modules/react-virtualized/dist/commonjs/List/List.js b/node_modules/react-virtualized/dist/commonjs/List/List.js
index b5ad0eb..efb2cd7 100644
--- a/node_modules/react-virtualized/dist/commonjs/List/List.js
+++ b/node_modules/react-virtualized/dist/commonjs/List/List.js
@@ -112,13 +112,8 @@ var List = function (_React$PureComponent) {
     }, _this._setRef = function (ref) {
       _this.Grid = ref;
     }, _this._onScroll = function (_ref3) {
-      var clientHeight = _ref3.clientHeight,
-          scrollHeight = _ref3.scrollHeight,
-          scrollTop = _ref3.scrollTop;
       var onScroll = _this.props.onScroll;
-
-
-      onScroll({ clientHeight: clientHeight, scrollHeight: scrollHeight, scrollTop: scrollTop });
+      onScroll(_ref3);
     }, _this._onSectionRendered = function (_ref4) {
       var rowOverscanStartIndex = _ref4.rowOverscanStartIndex,
           rowOverscanStopIndex = _ref4.rowOverscanStopIndex,
