box-ui-elements 20.1.0-beta.3 → 21.0.0

package/dist/explorer.js

@@ -118934,11 +118934,10 @@ const makeDroppable = ({
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Table/defaultHeaderRowRenderer.js
 
 /*:: import type {HeaderRowRendererParams} from './types';*/
-
-function defaultHeaderRowRenderer(_ref) {
-  var className = _ref.className,
-    columns = _ref.columns,
-    style = _ref.style;
+function defaultHeaderRowRenderer(_ref /*:: */) {
+  var className = _ref /*:: */.className,
+    columns = _ref /*:: */.columns,
+    style = _ref /*:: */.style;
   return /*#__PURE__*/react.createElement("div", {
     role: "rowgroup",
     className: "ReactVirtualized__Table__headerRowGroup"
@@ -118980,10 +118979,10 @@ var SortDirection = {
 
 
 
+
 /**
  * Displayed beside a header to indicate that a Table is currently sorted by this column.
  */
-
 function SortIndicator(_ref) {
   var sortDirection = _ref.sortDirection;
   var classNames = clsx_m('ReactVirtualized__Table__sortableHeaderIcon', {
@@ -119009,15 +119008,14 @@ SortIndicator.propTypes =  false ? 0 : {};
 
 
 /*:: import type {HeaderRendererParams} from './types';*/
-
 /**
  * Default table header renderer.
  */
-function defaultHeaderRenderer(_ref) {
-  var dataKey = _ref.dataKey,
-    label = _ref.label,
-    sortBy = _ref.sortBy,
-    sortDirection = _ref.sortDirection;
+function defaultHeaderRenderer(_ref /*:: */) {
+  var dataKey = _ref /*:: */.dataKey,
+    label = _ref /*:: */.label,
+    sortBy = _ref /*:: */.sortBy,
+    sortDirection = _ref /*:: */.sortDirection;
   var showSortIndicator = sortBy === dataKey;
   var children = [/*#__PURE__*/react.createElement("span", {
     className: "ReactVirtualized__Table__headerTruncatedText",
@@ -119036,22 +119034,21 @@ function defaultHeaderRenderer(_ref) {
 
 
 /*:: import type {RowRendererParams} from './types';*/
-
 /**
  * Default row renderer for Table.
  */
-function defaultRowRenderer(_ref) {
-  var className = _ref.className,
-    columns = _ref.columns,
-    index = _ref.index,
-    key = _ref.key,
-    onRowClick = _ref.onRowClick,
-    onRowDoubleClick = _ref.onRowDoubleClick,
-    onRowMouseOut = _ref.onRowMouseOut,
-    onRowMouseOver = _ref.onRowMouseOver,
-    onRowRightClick = _ref.onRowRightClick,
-    rowData = _ref.rowData,
-    style = _ref.style;
+function defaultRowRenderer(_ref /*:: */) {
+  var className = _ref /*:: */.className,
+    columns = _ref /*:: */.columns,
+    index = _ref /*:: */.index,
+    key = _ref /*:: */.key,
+    onRowClick = _ref /*:: */.onRowClick,
+    onRowDoubleClick = _ref /*:: */.onRowDoubleClick,
+    onRowMouseOut = _ref /*:: */.onRowMouseOut,
+    onRowMouseOver = _ref /*:: */.onRowMouseOver,
+    onRowRightClick = _ref /*:: */.onRowRightClick,
+    rowData = _ref /*:: */.rowData,
+    style = _ref /*:: */.style;
   var a11yProps = {
     'aria-rowindex': index + 1
   };
@@ -119110,6 +119107,22 @@ function defaultRowRenderer(_ref) {
     style: style
   }), columns);
 }
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+var toPropertyKey = __webpack_require__(91313);
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
+
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, (0,toPropertyKey/* default */.A)(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+
 ;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
 function _classCallCheck(a, n) {
   if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
@@ -119156,14 +119169,12 @@ function _inherits(t, e) {
 var defineProperty = __webpack_require__(34774);
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Table/defaultCellRenderer.js
 /*:: import type {CellRendererParams} from './types';*/
-
 /**
  * Default cell renderer that displays an attribute as a simple string
  * You should override the column's cellRenderer if your data is some other type of object.
  */
-function defaultCellRenderer(_ref) /*: string*/
-{
-  var cellData = _ref.cellData;
+function defaultCellRenderer(_ref /*:: */) /*: string*/{
+  var cellData = _ref /*:: */.cellData;
   if (cellData == null) {
     return '';
   } else {
@@ -119172,15 +119183,14 @@ function defaultCellRenderer(_ref) /*: string*/
 }
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Table/defaultCellDataGetter.js
 /*:: import type {CellDataGetterParams} from './types';*/
-
 /**
  * Default accessor for returning a cell value for a given attribute.
  * This function expects to operate on either a vanilla Object or an Immutable Map.
  * You should override the column's cellDataGetter if your data is some other type of object.
  */
-function defaultCellDataGetter(_ref) {
-  var dataKey = _ref.dataKey,
-    rowData = _ref.rowData;
+function defaultCellDataGetter(_ref /*:: */) {
+  var dataKey = _ref /*:: */.dataKey,
+    rowData = _ref /*:: */.rowData;
   if (typeof rowData.get === 'function') {
     return rowData.get(dataKey);
   } else {
@@ -119194,6 +119204,19 @@ function defaultCellDataGetter(_ref) {
 
 
 
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
+}
+
+
 
 
 
@@ -119202,15 +119225,13 @@ function defaultCellDataGetter(_ref) {
 /**
  * Describes the header and cell contents of a table column.
  */
-
-var Column = /*#__PURE__*/
-function (_React$Component) {
-  _inherits(Column, _React$Component);
+var Column = /*#__PURE__*/function (_React$Component) {
   function Column() {
     _classCallCheck(this, Column);
-    return _possibleConstructorReturn(this, _getPrototypeOf(Column).apply(this, arguments));
+    return _callSuper(this, Column, arguments);
   }
-  return Column;
+  _inherits(Column, _React$Component);
+  return _createClass(Column);
 }(react.Component);
 (0,defineProperty/* default */.A)(Column, "defaultProps", {
   cellDataGetter: defaultCellDataGetter,
@@ -119225,27 +119246,10 @@ function (_React$Component) {
 });
 
 Column.propTypes =  false ? 0 : {};
-// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-var toPropertyKey = __webpack_require__(91313);
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
-
-function _defineProperties(e, r) {
-  for (var t = 0; t < r.length; t++) {
-    var o = r[t];
-    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, (0,toPropertyKey/* default */.A)(o.key), o);
-  }
-}
-function _createClass(e, r, t) {
-  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
-    writable: !1
-  }), e;
-}
-
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.js
 /**
  * Helper method that determines when to recalculate row or column metadata.
  */
-
 /*:: type Params<T> = {
   // Number of rows or columns in the current axis
   cellCount: number,
@@ -119274,23 +119278,23 @@ function _createClass(e, r, t) {
   // Callback to invoke if the scroll position should be recalculated
   updateScrollOffsetForScrollToIndex: () => void,
 };*/
-function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref) {
-  var cellCount = _ref.cellCount,
-    cellSize = _ref.cellSize,
-    computeMetadataCallback = _ref.computeMetadataCallback,
-    computeMetadataCallbackProps = _ref.computeMetadataCallbackProps,
-    nextCellsCount = _ref.nextCellsCount,
-    nextCellSize = _ref.nextCellSize,
-    nextScrollToIndex = _ref.nextScrollToIndex,
-    scrollToIndex = _ref.scrollToIndex,
-    updateScrollOffsetForScrollToIndex = _ref.updateScrollOffsetForScrollToIndex;
-
+function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref /*:: */) {
+  var cellCount = _ref /*:: */.cellCount,
+    cellSize = _ref /*:: */.cellSize,
+    computeMetadataCallback = _ref /*:: */.computeMetadataCallback,
+    computeMetadataCallbackProps = _ref /*:: */.computeMetadataCallbackProps,
+    nextCellsCount = _ref /*:: */.nextCellsCount,
+    nextCellSize = _ref /*:: */.nextCellSize,
+    nextScrollToIndex = _ref /*:: */.nextScrollToIndex,
+    scrollToIndex = _ref /*:: */.scrollToIndex,
+    updateScrollOffsetForScrollToIndex = _ref /*:: */.updateScrollOffsetForScrollToIndex;
   // Don't compare cell sizes if they are functions because inline functions would cause infinite loops.
   // In that event users should use the manual recompute methods to inform of changes.
   if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) {
-    computeMetadataCallback(computeMetadataCallbackProps); // Updated cell metadata may have hidden the previous scrolled-to item.
-    // In this case we should also update the scrollTop to ensure it stays visible.
+    computeMetadataCallback(computeMetadataCallbackProps);
 
+    // Updated cell metadata may have hidden the previous scrolled-to item.
+    // In this case we should also update the scrollTop to ensure it stays visible.
     if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) {
       updateScrollOffsetForScrollToIndex();
     }
@@ -119314,54 +119318,46 @@ function objectWithoutProperties_objectWithoutProperties(e, t) {
 
 
 
-
 /*:: import type {Alignment, CellSizeGetter, VisibleCellRange} from '../types';*/
-
 /*:: type CellSizeAndPositionManagerParams = {
   cellCount: number,
   cellSizeGetter: CellSizeGetter,
   estimatedCellSize: number,
 };*/
-
 /*:: type ConfigureParams = {
   cellCount: number,
   estimatedCellSize: number,
   cellSizeGetter: CellSizeGetter,
 };*/
-
 /*:: type GetUpdatedOffsetForIndex = {
   align: Alignment,
   containerSize: number,
   currentOffset: number,
   targetIndex: number,
 };*/
-
 /*:: type GetVisibleCellRangeParams = {
   containerSize: number,
   offset: number,
 };*/
-
 /*:: type SizeAndPositionData = {
   offset: number,
   size: number,
 };*/
-
 /**
  * Just-in-time calculates and caches size and position information for a collection of cells.
  */
-var CellSizeAndPositionManager = /*#__PURE__*/
-function () {
-  // Cache of size and position data for cells, mapped by cell index.
-  // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex
-  // Measurements for cells up to this index can be trusted; cells afterward should be estimated.
-  // Used in deferred mode to track which cells have been queued for measurement.
-  function CellSizeAndPositionManager(_ref) {
-    var cellCount = _ref.cellCount,
-      cellSizeGetter = _ref.cellSizeGetter,
-      estimatedCellSize = _ref.estimatedCellSize;
+var CellSizeAndPositionManager = /*#__PURE__*/function () {
+  function CellSizeAndPositionManager(_ref /*:: */) {
+    var cellCount = _ref /*:: */.cellCount,
+      cellSizeGetter = _ref /*:: */.cellSizeGetter,
+      estimatedCellSize = _ref /*:: */.estimatedCellSize;
     _classCallCheck(this, CellSizeAndPositionManager);
+    // Cache of size and position data for cells, mapped by cell index.
+    // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex
     (0,defineProperty/* default */.A)(this, "_cellSizeAndPositionData", {});
+    // Measurements for cells up to this index can be trusted; cells afterward should be estimated.
     (0,defineProperty/* default */.A)(this, "_lastMeasuredIndex", -1);
+    // Used in deferred mode to track which cells have been queued for measurement.
     (0,defineProperty/* default */.A)(this, "_lastBatchedIndex", -1);
     (0,defineProperty/* default */.A)(this, "_cellCount", void 0);
     (0,defineProperty/* default */.A)(this, "_cellSizeGetter", void 0);
@@ -119370,37 +119366,34 @@ function () {
     this._cellCount = cellCount;
     this._estimatedCellSize = estimatedCellSize;
   }
-  _createClass(CellSizeAndPositionManager, [{
+  return _createClass(CellSizeAndPositionManager, [{
     key: "areOffsetsAdjusted",
     value: function areOffsetsAdjusted() {
       return false;
     }
   }, {
     key: "configure",
-    value: function configure(_ref2) {
-      var cellCount = _ref2.cellCount,
-        estimatedCellSize = _ref2.estimatedCellSize,
-        cellSizeGetter = _ref2.cellSizeGetter;
+    value: function configure(_ref2 /*:: */) {
+      var cellCount = _ref2 /*:: */.cellCount,
+        estimatedCellSize = _ref2 /*:: */.estimatedCellSize,
+        cellSizeGetter = _ref2 /*:: */.cellSizeGetter;
       this._cellCount = cellCount;
       this._estimatedCellSize = estimatedCellSize;
       this._cellSizeGetter = cellSizeGetter;
     }
   }, {
     key: "getCellCount",
-    value: function getCellCount() /*: number*/
-    {
+    value: function getCellCount() /*: number*/{
       return this._cellCount;
     }
   }, {
     key: "getEstimatedCellSize",
-    value: function getEstimatedCellSize() /*: number*/
-    {
+    value: function getEstimatedCellSize() /*: number*/{
       return this._estimatedCellSize;
     }
   }, {
     key: "getLastMeasuredIndex",
-    value: function getLastMeasuredIndex() /*: number*/
-    {
+    value: function getLastMeasuredIndex() /*: number*/{
       return this._lastMeasuredIndex;
     }
   }, {
@@ -119408,15 +119401,14 @@ function () {
     value: function getOffsetAdjustment() {
       return 0;
     }
+
     /**
      * This method returns the size and position for the cell at the specified index.
      * It just-in-time calculates (or used cached values) for cells leading up to the index.
      */
   }, {
     key: "getSizeAndPositionOfCell",
-    value: function getSizeAndPositionOfCell(index
-    /*: number*/) /*: SizeAndPositionData*/
-    {
+    value: function getSizeAndPositionOfCell(index /*: number*/) /*: SizeAndPositionData*/{
       if (index < 0 || index >= this._cellCount) {
         throw Error("Requested index ".concat(index, " is outside of range 0..").concat(this._cellCount));
       }
@@ -119426,9 +119418,10 @@ function () {
         for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {
           var size = this._cellSizeGetter({
             index: i
-          }); // undefined or NaN probably means a logic error in the size getter.
-          // null means we're using CellMeasurer and haven't yet measured a given index.
+          });
 
+          // undefined or NaN probably means a logic error in the size getter.
+          // null means we're using CellMeasurer and haven't yet measured a given index.
           if (size === undefined || isNaN(size)) {
             throw Error("Invalid size returned for cell ".concat(i, " of value ").concat(size));
           } else if (size === null) {
@@ -119451,13 +119444,13 @@ function () {
     }
   }, {
     key: "getSizeAndPositionOfLastMeasuredCell",
-    value: function getSizeAndPositionOfLastMeasuredCell() /*: SizeAndPositionData*/
-    {
+    value: function getSizeAndPositionOfLastMeasuredCell() /*: SizeAndPositionData*/{
       return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : {
         offset: 0,
         size: 0
       };
     }
+
     /**
      * Total size of all cells being measured.
      * This value will be completely estimated initially.
@@ -119465,14 +119458,14 @@ function () {
      */
   }, {
     key: "getTotalSize",
-    value: function getTotalSize() /*: number*/
-    {
+    value: function getTotalSize() /*: number*/{
       var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
       var totalSizeOfMeasuredCells = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;
       var numUnmeasuredCells = this._cellCount - this._lastMeasuredIndex - 1;
       var totalSizeOfUnmeasuredCells = numUnmeasuredCells * this._estimatedCellSize;
       return totalSizeOfMeasuredCells + totalSizeOfUnmeasuredCells;
     }
+
     /**
      * Determines a new offset that ensures a certain cell is visible, given the current offset.
      * If the cell is already visible then the current offset will be returned.
@@ -119486,13 +119479,12 @@ function () {
      */
   }, {
     key: "getUpdatedOffsetForIndex",
-    value: function getUpdatedOffsetForIndex(_ref3) /*: number*/
-    {
-      var _ref3$align = _ref3.align,
+    value: function getUpdatedOffsetForIndex(_ref3 /*:: */) /*: number*/{
+      var _ref3$align = _ref3 /*:: */.align,
         align = _ref3$align === void 0 ? 'auto' : _ref3$align,
-        containerSize = _ref3.containerSize,
-        currentOffset = _ref3.currentOffset,
-        targetIndex = _ref3.targetIndex;
+        containerSize = _ref3 /*:: */.containerSize,
+        currentOffset = _ref3 /*:: */.currentOffset,
+        targetIndex = _ref3 /*:: */.targetIndex;
       if (containerSize <= 0) {
         return 0;
       }
@@ -119519,9 +119511,7 @@ function () {
     }
   }, {
     key: "getVisibleCellRange",
-    value: function getVisibleCellRange(params
-    /*: GetVisibleCellRangeParams*/) /*: VisibleCellRange*/
-    {
+    value: function getVisibleCellRange(params /*: GetVisibleCellRangeParams*/) /*: VisibleCellRange*/{
       var containerSize = params.containerSize,
         offset = params.offset;
       var totalSize = this.getTotalSize();
@@ -119542,6 +119532,7 @@ function () {
         stop: stop
       };
     }
+
     /**
      * Clear all cached values for cells after the specified index.
      * This method should be called for any cell that has changed its size.
@@ -119549,18 +119540,12 @@ function () {
      */
   }, {
     key: "resetCell",
-    value: function resetCell(index
-    /*: number*/) /*: void*/
-    {
+    value: function resetCell(index /*: number*/) /*: void*/{
       this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);
     }
   }, {
     key: "_binarySearch",
-    value: function _binarySearch(high
-    /*: number*/, low
-    /*: number*/, offset
-    /*: number*/) /*: number*/
-    {
+    value: function _binarySearch(high /*: number*/, low /*: number*/, offset /*: number*/) /*: number*/{
       while (low <= high) {
         var middle = low + Math.floor((high - low) / 2);
         var currentOffset = this.getSizeAndPositionOfCell(middle).offset;
@@ -119580,10 +119565,7 @@ function () {
     }
   }, {
     key: "_exponentialSearch",
-    value: function _exponentialSearch(index
-    /*: number*/, offset
-    /*: number*/) /*: number*/
-    {
+    value: function _exponentialSearch(index /*: number*/, offset /*: number*/) /*: number*/{
       var interval = 1;
       while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {
         index += interval;
@@ -119591,6 +119573,7 @@ function () {
       }
       return this._binarySearch(Math.min(index, this._cellCount - 1), Math.floor(index / 2), offset);
     }
+
     /**
      * Searches for the cell (index) nearest the specified offset.
      *
@@ -119599,14 +119582,13 @@ function () {
      */
   }, {
     key: "_findNearestCell",
-    value: function _findNearestCell(offset
-    /*: number*/) /*: number*/
-    {
+    value: function _findNearestCell(offset /*: number*/) /*: number*/{
       if (isNaN(offset)) {
         throw Error("Invalid offset ".concat(offset, " specified"));
-      } // Our search algorithms find the nearest match at or below the specified offset.
-      // So make sure the offset is at least 0 or no match will be found.
+      }
 
+      // Our search algorithms find the nearest match at or below the specified offset.
+      // So make sure the offset is at least 0 or no match will be found.
       offset = Math.max(0, offset);
       var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
       var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);
@@ -119621,7 +119603,6 @@ function () {
       }
     }
   }]);
-  return CellSizeAndPositionManager;
 }();
 
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Grid/utils/maxElementSize.js
@@ -119633,8 +119614,7 @@ var maxElementSize_isBrowser = function isBrowser() {
 var isChrome = function isChrome() {
   return !!window.chrome;
 };
-var getMaxElementSize = function getMaxElementSize() /*: number*/
-{
+var getMaxElementSize = function getMaxElementSize() /*: number*/{
   if (maxElementSize_isBrowser()) {
     if (isChrome()) {
       return CHROME_MAX_ELEMENT_SIZE;
@@ -119647,7 +119627,7 @@ var getMaxElementSize = function getMaxElementSize() /*: number*/
 
 
 
-
+var ScalingCellSizeAndPositionManager_excluded = ["maxScrollSize"];
 /*:: import type {Alignment, CellSizeGetter, VisibleCellRange} from '../types';*/
 
 
@@ -119655,35 +119635,35 @@ var getMaxElementSize = function getMaxElementSize() /*: number*/
   containerSize: number,
   offset: number,
 };*/
-
 /*:: type Params = {
   maxScrollSize?: number,
   cellCount: number,
   cellSizeGetter: CellSizeGetter,
   estimatedCellSize: number,
 };*/
-
+/**
+ * Browsers have scroll offset limitations (eg Chrome stops scrolling at ~33.5M pixels where as Edge tops out at ~1.5M pixels).
+ * After a certain position, the browser won't allow the user to scroll further (even via JavaScript scroll offset adjustments).
+ * This util picks a lower ceiling for max size and artificially adjusts positions within to make it transparent for users.
+ */
 /**
  * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.
  */
-var ScalingCellSizeAndPositionManager = /*#__PURE__*/
-function () {
-  function ScalingCellSizeAndPositionManager(_ref) {
-    var _ref$maxScrollSize = _ref.maxScrollSize,
+var ScalingCellSizeAndPositionManager = /*#__PURE__*/function () {
+  function ScalingCellSizeAndPositionManager(_ref /*:: */) {
+    var _ref$maxScrollSize = _ref /*:: */.maxScrollSize,
       maxScrollSize = _ref$maxScrollSize === void 0 ? getMaxElementSize() : _ref$maxScrollSize,
-      params = objectWithoutProperties_objectWithoutProperties(_ref, ["maxScrollSize"]);
+      params = objectWithoutProperties_objectWithoutProperties(_ref /*:: */, ScalingCellSizeAndPositionManager_excluded);
     _classCallCheck(this, ScalingCellSizeAndPositionManager);
     (0,defineProperty/* default */.A)(this, "_cellSizeAndPositionManager", void 0);
     (0,defineProperty/* default */.A)(this, "_maxScrollSize", void 0);
-
     // Favor composition over inheritance to simplify IE10 support
     this._cellSizeAndPositionManager = new CellSizeAndPositionManager(params);
     this._maxScrollSize = maxScrollSize;
   }
-  _createClass(ScalingCellSizeAndPositionManager, [{
+  return _createClass(ScalingCellSizeAndPositionManager, [{
     key: "areOffsetsAdjusted",
-    value: function areOffsetsAdjusted() /*: boolean*/
-    {
+    value: function areOffsetsAdjusted() /*: boolean*/{
       return this._cellSizeAndPositionManager.getTotalSize() > this._maxScrollSize;
     }
   }, {
@@ -119698,32 +119678,29 @@ function () {
     }
   }, {
     key: "getCellCount",
-    value: function getCellCount() /*: number*/
-    {
+    value: function getCellCount() /*: number*/{
       return this._cellSizeAndPositionManager.getCellCount();
     }
   }, {
     key: "getEstimatedCellSize",
-    value: function getEstimatedCellSize() /*: number*/
-    {
+    value: function getEstimatedCellSize() /*: number*/{
       return this._cellSizeAndPositionManager.getEstimatedCellSize();
     }
   }, {
     key: "getLastMeasuredIndex",
-    value: function getLastMeasuredIndex() /*: number*/
-    {
+    value: function getLastMeasuredIndex() /*: number*/{
       return this._cellSizeAndPositionManager.getLastMeasuredIndex();
     }
+
     /**
      * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.
      * The offset passed to this function is scaled (safe) as well.
      */
   }, {
     key: "getOffsetAdjustment",
-    value: function getOffsetAdjustment(_ref2) /*: number*/
-    {
-      var containerSize = _ref2.containerSize,
-        offset = _ref2.offset;
+    value: function getOffsetAdjustment(_ref2 /*:: */) /*: number*/{
+      var containerSize = _ref2 /*:: */.containerSize,
+        offset = _ref2 /*:: */.offset;
       var totalSize = this._cellSizeAndPositionManager.getTotalSize();
       var safeTotalSize = this.getTotalSize();
       var offsetPercentage = this._getOffsetPercentage({
@@ -119735,8 +119712,7 @@ function () {
     }
   }, {
     key: "getSizeAndPositionOfCell",
-    value: function getSizeAndPositionOfCell(index
-    /*: number*/) {
+    value: function getSizeAndPositionOfCell(index /*: number*/) {
       return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);
     }
   }, {
@@ -119744,22 +119720,23 @@ function () {
     value: function getSizeAndPositionOfLastMeasuredCell() {
       return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();
     }
+
     /** See CellSizeAndPositionManager#getTotalSize */
   }, {
     key: "getTotalSize",
-    value: function getTotalSize() /*: number*/
-    {
+    value: function getTotalSize() /*: number*/{
       return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());
     }
+
     /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */
   }, {
     key: "getUpdatedOffsetForIndex",
-    value: function getUpdatedOffsetForIndex(_ref3) {
-      var _ref3$align = _ref3.align,
+    value: function getUpdatedOffsetForIndex(_ref3 /*:: */) {
+      var _ref3$align = _ref3 /*:: */.align,
         align = _ref3$align === void 0 ? 'auto' : _ref3$align,
-        containerSize = _ref3.containerSize,
-        currentOffset = _ref3.currentOffset,
-        targetIndex = _ref3.targetIndex;
+        containerSize = _ref3 /*:: */.containerSize,
+        currentOffset = _ref3 /*:: */.currentOffset,
+        targetIndex = _ref3 /*:: */.targetIndex;
       currentOffset = this._safeOffsetToOffset({
         containerSize: containerSize,
         offset: currentOffset
@@ -119775,13 +119752,13 @@ function () {
         offset: offset
       });
     }
+
     /** See CellSizeAndPositionManager#getVisibleCellRange */
   }, {
     key: "getVisibleCellRange",
-    value: function getVisibleCellRange(_ref4) /*: VisibleCellRange*/
-    {
-      var containerSize = _ref4.containerSize,
-        offset = _ref4.offset;
+    value: function getVisibleCellRange(_ref4 /*:: */) /*: VisibleCellRange*/{
+      var containerSize = _ref4 /*:: */.containerSize,
+        offset = _ref4 /*:: */.offset;
       offset = this._safeOffsetToOffset({
         containerSize: containerSize,
         offset: offset
@@ -119793,25 +119770,22 @@ function () {
     }
   }, {
     key: "resetCell",
-    value: function resetCell(index
-    /*: number*/) /*: void*/
-    {
+    value: function resetCell(index /*: number*/) /*: void*/{
       this._cellSizeAndPositionManager.resetCell(index);
     }
   }, {
     key: "_getOffsetPercentage",
-    value: function _getOffsetPercentage(_ref5) {
-      var containerSize = _ref5.containerSize,
-        offset = _ref5.offset,
-        totalSize = _ref5.totalSize;
+    value: function _getOffsetPercentage(_ref5 /*:: */) {
+      var containerSize = _ref5 /*:: */.containerSize,
+        offset = _ref5 /*:: */.offset,
+        totalSize = _ref5 /*:: */.totalSize;
       return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize);
     }
   }, {
     key: "_offsetToSafeOffset",
-    value: function _offsetToSafeOffset(_ref6) /*: number*/
-    {
-      var containerSize = _ref6.containerSize,
-        offset = _ref6.offset;
+    value: function _offsetToSafeOffset(_ref6 /*:: */) /*: number*/{
+      var containerSize = _ref6 /*:: */.containerSize,
+        offset = _ref6 /*:: */.offset;
       var totalSize = this._cellSizeAndPositionManager.getTotalSize();
       var safeTotalSize = this.getTotalSize();
       if (totalSize === safeTotalSize) {
@@ -119827,10 +119801,9 @@ function () {
     }
   }, {
     key: "_safeOffsetToOffset",
-    value: function _safeOffsetToOffset(_ref7) /*: number*/
-    {
-      var containerSize = _ref7.containerSize,
-        offset = _ref7.offset;
+    value: function _safeOffsetToOffset(_ref7 /*:: */) /*: number*/{
+      var containerSize = _ref7 /*:: */.containerSize,
+        offset = _ref7 /*:: */.offset;
       var totalSize = this._cellSizeAndPositionManager.getTotalSize();
       var safeTotalSize = this.getTotalSize();
       if (totalSize === safeTotalSize) {
@@ -119845,7 +119818,6 @@ function () {
       }
     }
   }]);
-  return ScalingCellSizeAndPositionManager;
 }();
 
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/utils/createCallbackMemoizer.js
@@ -119880,18 +119852,18 @@ var SCROLL_DIRECTION_BACKWARD = -1;
 var SCROLL_DIRECTION_FORWARD = 1;
 var SCROLL_DIRECTION_HORIZONTAL = 'horizontal';
 var SCROLL_DIRECTION_VERTICAL = 'vertical';
+
 /**
  * Calculates the number of cells to overscan before and after a specified range.
  * This function ensures that overscanning doesn't exceed the available cells.
  */
 
-function defaultOverscanIndicesGetter(_ref) /*: OverscanIndices*/
-{
-  var cellCount = _ref.cellCount,
-    overscanCellsCount = _ref.overscanCellsCount,
-    scrollDirection = _ref.scrollDirection,
-    startIndex = _ref.startIndex,
-    stopIndex = _ref.stopIndex;
+function defaultOverscanIndicesGetter(_ref /*:: */) /*: OverscanIndices*/{
+  var cellCount = _ref /*:: */.cellCount,
+    overscanCellsCount = _ref /*:: */.overscanCellsCount,
+    scrollDirection = _ref /*:: */.scrollDirection,
+    startIndex = _ref /*:: */.startIndex,
+    stopIndex = _ref /*:: */.stopIndex;
   if (scrollDirection === SCROLL_DIRECTION_FORWARD) {
     return {
       overscanStartIndex: Math.max(0, startIndex),
@@ -119907,11 +119879,11 @@ function defaultOverscanIndicesGetter(_ref) /*: OverscanIndices*/
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Grid/utils/updateScrollIndexHelper.js
 /*:: import type {Alignment, CellSize} from '../types';*/
 
+
 /**
  * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible.
  * This function also ensures that the scroll ofset isn't past the last column/row of cells.
  */
-
 /*:: type Params = {
   // Width or height of cells for the current axis
   cellSize?: CellSize,
@@ -119949,28 +119921,30 @@ function defaultOverscanIndicesGetter(_ref) /*: OverscanIndices*/
   // Callback to invoke with an scroll-to-index value
   updateScrollIndexCallback: (index: number) => void,
 };*/
-
-function updateScrollIndexHelper(_ref) {
-  var cellSize = _ref.cellSize,
-    cellSizeAndPositionManager = _ref.cellSizeAndPositionManager,
-    previousCellsCount = _ref.previousCellsCount,
-    previousCellSize = _ref.previousCellSize,
-    previousScrollToAlignment = _ref.previousScrollToAlignment,
-    previousScrollToIndex = _ref.previousScrollToIndex,
-    previousSize = _ref.previousSize,
-    scrollOffset = _ref.scrollOffset,
-    scrollToAlignment = _ref.scrollToAlignment,
-    scrollToIndex = _ref.scrollToIndex,
-    size = _ref.size,
-    sizeJustIncreasedFromZero = _ref.sizeJustIncreasedFromZero,
-    updateScrollIndexCallback = _ref.updateScrollIndexCallback;
+function updateScrollIndexHelper(_ref /*:: */) {
+  var cellSize = _ref /*:: */.cellSize,
+    cellSizeAndPositionManager = _ref /*:: */.cellSizeAndPositionManager,
+    previousCellsCount = _ref /*:: */.previousCellsCount,
+    previousCellSize = _ref /*:: */.previousCellSize,
+    previousScrollToAlignment = _ref /*:: */.previousScrollToAlignment,
+    previousScrollToIndex = _ref /*:: */.previousScrollToIndex,
+    previousSize = _ref /*:: */.previousSize,
+    scrollOffset = _ref /*:: */.scrollOffset,
+    scrollToAlignment = _ref /*:: */.scrollToAlignment,
+    scrollToIndex = _ref /*:: */.scrollToIndex,
+    size = _ref /*:: */.size,
+    sizeJustIncreasedFromZero = _ref /*:: */.sizeJustIncreasedFromZero,
+    updateScrollIndexCallback = _ref /*:: */.updateScrollIndexCallback;
   var cellCount = cellSizeAndPositionManager.getCellCount();
   var hasScrollToIndex = scrollToIndex >= 0 && scrollToIndex < cellCount;
-  var sizeHasChanged = size !== previousSize || sizeJustIncreasedFromZero || !previousCellSize || typeof cellSize === 'number' && cellSize !== previousCellSize; // If we have a new scroll target OR if height/row-height has changed,
-  // We should ensure that the scroll target is visible.
+  var sizeHasChanged = size !== previousSize || sizeJustIncreasedFromZero || !previousCellSize || typeof cellSize === 'number' && cellSize !== previousCellSize;
 
+  // If we have a new scroll target OR if height/row-height has changed,
+  // We should ensure that the scroll target is visible.
   if (hasScrollToIndex && (sizeHasChanged || scrollToAlignment !== previousScrollToAlignment || scrollToIndex !== previousScrollToIndex)) {
-    updateScrollIndexCallback(scrollToIndex); // If we don't have a selected item but list size or number of children have decreased,
+    updateScrollIndexCallback(scrollToIndex);
+
+    // If we don't have a selected item but list size or number of children have decreased,
     // Make sure we aren't scrolled too far past the current content.
   } else if (!hasScrollToIndex && cellCount > 0 && (size < previousSize || cellCount < previousCellsCount)) {
     // We need to ensure that the current scroll offset is still within the collection's range.
@@ -119985,35 +119959,37 @@ function updateScrollIndexHelper(_ref) {
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Grid/defaultCellRangeRenderer.js
 /*:: import type {CellRangeRendererParams} from './types';*/
 
+
 /**
  * Default implementation of cellRangeRenderer used by Grid.
  * This renderer supports cell-caching while the user is scrolling.
  */
 
-function defaultCellRangeRenderer(_ref) {
-  var cellCache = _ref.cellCache,
-    cellRenderer = _ref.cellRenderer,
-    columnSizeAndPositionManager = _ref.columnSizeAndPositionManager,
-    columnStartIndex = _ref.columnStartIndex,
-    columnStopIndex = _ref.columnStopIndex,
-    deferredMeasurementCache = _ref.deferredMeasurementCache,
-    horizontalOffsetAdjustment = _ref.horizontalOffsetAdjustment,
-    isScrolling = _ref.isScrolling,
-    isScrollingOptOut = _ref.isScrollingOptOut,
-    parent = _ref.parent,
-    rowSizeAndPositionManager = _ref.rowSizeAndPositionManager,
-    rowStartIndex = _ref.rowStartIndex,
-    rowStopIndex = _ref.rowStopIndex,
-    styleCache = _ref.styleCache,
-    verticalOffsetAdjustment = _ref.verticalOffsetAdjustment,
-    visibleColumnIndices = _ref.visibleColumnIndices,
-    visibleRowIndices = _ref.visibleRowIndices;
-  var renderedCells = []; // Browsers have native size limits for elements (eg Chrome 33M pixels, IE 1.5M pixes).
+function defaultCellRangeRenderer(_ref /*:: */) {
+  var cellCache = _ref /*:: */.cellCache,
+    cellRenderer = _ref /*:: */.cellRenderer,
+    columnSizeAndPositionManager = _ref /*:: */.columnSizeAndPositionManager,
+    columnStartIndex = _ref /*:: */.columnStartIndex,
+    columnStopIndex = _ref /*:: */.columnStopIndex,
+    deferredMeasurementCache = _ref /*:: */.deferredMeasurementCache,
+    horizontalOffsetAdjustment = _ref /*:: */.horizontalOffsetAdjustment,
+    isScrolling = _ref /*:: */.isScrolling,
+    isScrollingOptOut = _ref /*:: */.isScrollingOptOut,
+    parent = _ref /*:: */.parent,
+    rowSizeAndPositionManager = _ref /*:: */.rowSizeAndPositionManager,
+    rowStartIndex = _ref /*:: */.rowStartIndex,
+    rowStopIndex = _ref /*:: */.rowStopIndex,
+    styleCache = _ref /*:: */.styleCache,
+    verticalOffsetAdjustment = _ref /*:: */.verticalOffsetAdjustment,
+    visibleColumnIndices = _ref /*:: */.visibleColumnIndices,
+    visibleRowIndices = _ref /*:: */.visibleRowIndices;
+  var renderedCells = [];
+
+  // Browsers have native size limits for elements (eg Chrome 33M pixels, IE 1.5M pixes).
   // User cannot scroll beyond these size limitations.
   // In order to work around this, ScalingCellSizeAndPositionManager compresses offsets.
   // We should never cache styles for compressed offsets though as this can lead to bugs.
   // See issue #576 for more.
-
   var areOffsetsAdjusted = columnSizeAndPositionManager.areOffsetsAdjusted() || rowSizeAndPositionManager.areOffsetsAdjusted();
   var canCacheStyle = !isScrolling && !areOffsetsAdjusted;
   for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {
@@ -120022,8 +119998,9 @@ function defaultCellRangeRenderer(_ref) {
       var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex);
       var isVisible = columnIndex >= visibleColumnIndices.start && columnIndex <= visibleColumnIndices.stop && rowIndex >= visibleRowIndices.start && rowIndex <= visibleRowIndices.stop;
       var key = "".concat(rowIndex, "-").concat(columnIndex);
-      var style = void 0; // Cache style objects so shallow-compare doesn't re-render unnecessarily.
+      var style = void 0;
 
+      // Cache style objects so shallow-compare doesn't re-render unnecessarily.
       if (canCacheStyle && styleCache[key]) {
         style = styleCache[key];
       } else {
@@ -120060,7 +120037,9 @@ function defaultCellRangeRenderer(_ref) {
         rowIndex: rowIndex,
         style: style
       };
-      var renderedCell = void 0; // Avoid re-creating cells while scrolling.
+      var renderedCell = void 0;
+
+      // Avoid re-creating cells while scrolling.
       // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells.
       // If a scroll is in progress- cache and reuse cells.
       // This cache will be thrown away once scrolling completes.
@@ -120070,12 +120049,13 @@ function defaultCellRangeRenderer(_ref) {
       //
       // If isScrollingOptOut is specified, we always cache cells.
       // For more info refer to issue #1028
-
       if ((isScrollingOptOut || isScrolling) && !horizontalOffsetAdjustment && !verticalOffsetAdjustment) {
         if (!cellCache[key]) {
           cellCache[key] = cellRenderer(cellRendererParams);
         }
-        renderedCell = cellCache[key]; // If the user is no longer scrolling, don't cache cells.
+        renderedCell = cellCache[key];
+
+        // If the user is no longer scrolling, don't cache cells.
         // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint.
       } else {
         renderedCell = cellRenderer(cellRendererParams);
@@ -120122,9 +120102,7 @@ function scrollbarSize(recalc) {
 var react_lifecycles_compat_es = __webpack_require__(62135);
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/utils/animationFrame.js
 /*:: type Callback = (timestamp: number) => void;*/
-
 /*:: type CancelAnimationFrame = (requestId: number) => void;*/
-
 /*:: type RequestAnimationFrame = (callback: Callback) => number;*/
 // Properly handle server-side rendering.
 var win;
@@ -120134,49 +120112,36 @@ if (typeof window !== 'undefined') {
   win = self;
 } else {
   win = {};
-} // requestAnimationFrame() shim by Paul Irish
-// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
+}
 
-var request = win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || win.oRequestAnimationFrame || win.msRequestAnimationFrame || function (callback
-/*: Callback*/) /*: RequestAnimationFrame*/
-{
-  return win
-  /*: any*/.setTimeout(callback, 1000 / 60);
-};
-var cancel = win.cancelAnimationFrame || win.webkitCancelAnimationFrame || win.mozCancelAnimationFrame || win.oCancelAnimationFrame || win.msCancelAnimationFrame || function (id
-/*: number*/) {
-  win
-  /*: any*/.clearTimeout(id);
-};
-var raf
-/*: RequestAnimationFrame*/ = request
-/*: any*/;
-var caf
-/*: CancelAnimationFrame*/ = cancel
-/*: any*/;
+// requestAnimationFrame() shim by Paul Irish
+// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
+var request = win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || win.oRequestAnimationFrame || win.msRequestAnimationFrame || function (callback /*: Callback*/) /*: RequestAnimationFrame*/{
+  return win /*: any*/.setTimeout(callback, 1000 / 60);
+};
+var cancel = win.cancelAnimationFrame || win.webkitCancelAnimationFrame || win.mozCancelAnimationFrame || win.oCancelAnimationFrame || win.msCancelAnimationFrame || function (id /*: number*/) {
+  win /*: any*/.clearTimeout(id);
+};
+var raf /*: RequestAnimationFrame*/ = request /*: any*/;
+var caf /*: CancelAnimationFrame*/ = cancel /*: any*/;
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/utils/requestAnimationTimeout.js
 
 /*:: export type AnimationTimeoutId = {
   id: number,
 };*/
-
-var cancelAnimationTimeout = function cancelAnimationTimeout(frame
-/*: AnimationTimeoutId*/) {
+var cancelAnimationTimeout = function cancelAnimationTimeout(frame /*: AnimationTimeoutId*/) {
   return caf(frame.id);
 };
+
 /**
  * Recursively calls requestAnimationFrame until a specified delay has been met or exceeded.
  * When the delay time has been reached the function you're timing out will be called.
  *
  * Credit: Joe Lambert (https://gist.github.com/joelambert/1002116#file-requesttimeout-js)
  */
-
-var requestAnimationTimeout = function requestAnimationTimeout(callback
-/*: Function*/, delay
-/*: number*/) /*: AnimationTimeoutId*/
-{
-  var start; // wait for end of processing current event handler, because event handler may be long
-
+var requestAnimationTimeout = function requestAnimationTimeout(callback /*: Function*/, delay /*: number*/) /*: AnimationTimeoutId*/{
+  var start;
+  // wait for end of processing current event handler, because event handler may be long
   Promise.resolve().then(function () {
     start = Date.now();
   });
@@ -120187,8 +120152,7 @@ var requestAnimationTimeout = function requestAnimationTimeout(callback
       frame.id = raf(timeout);
     }
   };
-  var frame
-  /*: AnimationTimeoutId*/ = {
+  var frame /*: AnimationTimeoutId*/ = {
     id: raf(timeout)
   };
   return frame;
@@ -120202,36 +120166,38 @@ function _extends2() { return _extends2 = Object.assign ? Object.assign.bind() :
 
 
 
-
-function Grid_ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+function Grid_ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-  return keys;
+  return t;
 }
-function Grid_objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
-      Grid_ownKeys(source, true).forEach(function (key) {
-        (0,defineProperty/* default */.A)(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      Grid_ownKeys(source).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+function Grid_objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? Grid_ownKeys(Object(t), !0).forEach(function (r) {
+      (0,defineProperty/* default */.A)(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : Grid_ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
   }
-  return target;
+  return e;
+}
+function Grid_callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, Grid_isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function Grid_isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (Grid_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
 }
-
 /*:: import type {
   CellRenderer,
   CellRangeRenderer,
@@ -120247,7 +120213,6 @@ function Grid_objectSpread(target) {
   CellCache,
   StyleCache,
 } from './types';*/
-
 /*:: import type {AnimationTimeoutId} from '../utils/requestAnimationTimeout';*/
 
 
@@ -120260,30 +120225,28 @@ function Grid_objectSpread(target) {
 
 
 
+
 /**
  * Specifies the number of milliseconds during which to disable pointer events while a scroll is in progress.
  * This improves performance and makes scrolling smoother.
  */
-
 var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;
+
 /**
  * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.
  * This prevents Grid from interrupting mouse-wheel animations (see issue #2).
  */
-
 var SCROLL_POSITION_CHANGE_REASONS = {
   OBSERVED: 'observed',
   REQUESTED: 'requested'
 };
-var renderNull
-/*: NoContentRenderer*/ = function renderNull() {
+var renderNull /*: NoContentRenderer*/ = function renderNull /*: NoContentRenderer*/() {
   return null;
 };
 /*:: type ScrollPosition = {
   scrollTop?: number,
   scrollLeft?: number,
 };*/
-
 /*:: type Props = {
   'aria-label': string,
   'aria-readonly'?: boolean,
@@ -120449,7 +120412,6 @@ var renderNull
   /** Width of Grid; this property determines the number of visible (vs virtualized) columns.  *-/
   width: number,
 };*/
-
 /*:: type InstanceProps = {
   prevColumnWidth: CellSize,
   prevRowHeight: CellSize,
@@ -120466,7 +120428,6 @@ var renderNull
   scrollbarSize: number,
   scrollbarSizeMeasured: boolean,
 };*/
-
 /*:: type State = {
   instanceProps: InstanceProps,
   isScrolling: boolean,
@@ -120477,54 +120438,49 @@ var renderNull
   scrollPositionChangeReason: 'observed' | 'requested' | null,
   needToResetStyleCache: boolean,
 };*/
-
 /**
  * Renders tabular data with virtualization along the vertical and horizontal axes.
  * Row heights and column widths must be known ahead of time and specified as properties.
  */
-var Grid = /*#__PURE__*/
-function (_React$PureComponent) {
-  _inherits(Grid, _React$PureComponent);
-
-  // Invokes onSectionRendered callback only when start/stop row or column indices change
-  function Grid(props
-  /*: Props*/) {
+var Grid = /*#__PURE__*/function (_React$PureComponent) {
+  function Grid(props /*: Props*/) {
     var _this;
     _classCallCheck(this, Grid);
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Grid).call(this, props));
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onGridRenderedMemoizer", createCallbackMemoizer());
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onScrollMemoizer", createCallbackMemoizer(false));
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_deferredInvalidateColumnIndex", null);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_deferredInvalidateRowIndex", null);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_recomputeScrollLeftFlag", false);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_recomputeScrollTopFlag", false);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_horizontalScrollBarSize", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_verticalScrollBarSize", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_scrollbarPresenceChanged", false);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_scrollingContainer", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_childrenToDisplay", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_columnStartIndex", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_columnStopIndex", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_rowStartIndex", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_rowStopIndex", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_renderedColumnStartIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_renderedColumnStopIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_renderedRowStartIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_renderedRowStopIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_initialScrollTop", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_initialScrollLeft", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_disablePointerEventsTimeoutId", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_styleCache", {});
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_cellCache", {});
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_debounceScrollEndedCallback", function () {
-      _this._disablePointerEventsTimeoutId = null; // isScrolling is used to determine if we reset styleCache
-
+    _this = Grid_callSuper(this, Grid, [props]);
+    // Invokes onSectionRendered callback only when start/stop row or column indices change
+    (0,defineProperty/* default */.A)(_this, "_onGridRenderedMemoizer", createCallbackMemoizer());
+    (0,defineProperty/* default */.A)(_this, "_onScrollMemoizer", createCallbackMemoizer(false));
+    (0,defineProperty/* default */.A)(_this, "_deferredInvalidateColumnIndex", null);
+    (0,defineProperty/* default */.A)(_this, "_deferredInvalidateRowIndex", null);
+    (0,defineProperty/* default */.A)(_this, "_recomputeScrollLeftFlag", false);
+    (0,defineProperty/* default */.A)(_this, "_recomputeScrollTopFlag", false);
+    (0,defineProperty/* default */.A)(_this, "_horizontalScrollBarSize", 0);
+    (0,defineProperty/* default */.A)(_this, "_verticalScrollBarSize", 0);
+    (0,defineProperty/* default */.A)(_this, "_scrollbarPresenceChanged", false);
+    (0,defineProperty/* default */.A)(_this, "_scrollingContainer", void 0);
+    (0,defineProperty/* default */.A)(_this, "_childrenToDisplay", void 0);
+    (0,defineProperty/* default */.A)(_this, "_columnStartIndex", void 0);
+    (0,defineProperty/* default */.A)(_this, "_columnStopIndex", void 0);
+    (0,defineProperty/* default */.A)(_this, "_rowStartIndex", void 0);
+    (0,defineProperty/* default */.A)(_this, "_rowStopIndex", void 0);
+    (0,defineProperty/* default */.A)(_this, "_renderedColumnStartIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_renderedColumnStopIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_renderedRowStartIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_renderedRowStopIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_initialScrollTop", void 0);
+    (0,defineProperty/* default */.A)(_this, "_initialScrollLeft", void 0);
+    (0,defineProperty/* default */.A)(_this, "_disablePointerEventsTimeoutId", void 0);
+    (0,defineProperty/* default */.A)(_this, "_styleCache", {});
+    (0,defineProperty/* default */.A)(_this, "_cellCache", {});
+    (0,defineProperty/* default */.A)(_this, "_debounceScrollEndedCallback", function () {
+      _this._disablePointerEventsTimeoutId = null;
+      // isScrolling is used to determine if we reset styleCache
       _this.setState({
         isScrolling: false,
         needToResetStyleCache: false
       });
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_invokeOnGridRenderedHelper", function () {
+    (0,defineProperty/* default */.A)(_this, "_invokeOnGridRenderedHelper", function () {
       var onSectionRendered = _this.props.onSectionRendered;
       _this._onGridRenderedMemoizer({
         callback: onSectionRendered,
@@ -120540,18 +120496,15 @@ function (_React$PureComponent) {
         }
       });
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_setScrollingContainerRef", function (ref
-    /*: Element*/) {
+    (0,defineProperty/* default */.A)(_this, "_setScrollingContainerRef", function (ref /*: Element*/) {
       _this._scrollingContainer = ref;
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onScroll", function (event
-    /*: Event*/) {
+    (0,defineProperty/* default */.A)(_this, "_onScroll", function (event /*: Event*/) {
       // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.
       // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.
       // See issue #404 for more information.
       if (event.target === _this._scrollingContainer) {
-        _this.handleScrollEvent(event.target
-        /*: any*/);
+        _this.handleScrollEvent(event.target /*: any*/);
       }
     });
     var columnSizeAndPositionManager = new ScalingCellSizeAndPositionManager({
@@ -120598,11 +120551,12 @@ function (_React$PureComponent) {
     }
     return _this;
   }
+
   /**
    * Gets offsets for a given cell and alignment.
    */
-
-  _createClass(Grid, [{
+  _inherits(Grid, _React$PureComponent);
+  return _createClass(Grid, [{
     key: "getOffsetForCell",
     value: function getOffsetForCell() {
       var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
@@ -120612,7 +120566,7 @@ function (_React$PureComponent) {
         columnIndex = _ref$columnIndex === void 0 ? this.props.scrollToColumn : _ref$columnIndex,
         _ref$rowIndex = _ref.rowIndex,
         rowIndex = _ref$rowIndex === void 0 ? this.props.scrollToRow : _ref$rowIndex;
-      var offsetProps = Grid_objectSpread({}, this.props, {
+      var offsetProps = Grid_objectSpread(Grid_objectSpread({}, this.props), {}, {
         scrollToAlignment: alignment,
         scrollToColumn: columnIndex,
         scrollToRow: rowIndex
@@ -120622,6 +120576,7 @@ function (_React$PureComponent) {
         scrollTop: this._getCalculatedScrollTop(offsetProps)
       };
     }
+
     /**
      * Gets estimated total rows' height.
      */
@@ -120630,6 +120585,7 @@ function (_React$PureComponent) {
     value: function getTotalRowsHeight() {
       return this.state.instanceProps.rowSizeAndPositionManager.getTotalSize();
     }
+
     /**
      * Gets estimated total columns' width.
      */
@@ -120638,51 +120594,53 @@ function (_React$PureComponent) {
     value: function getTotalColumnsWidth() {
       return this.state.instanceProps.columnSizeAndPositionManager.getTotalSize();
     }
+
     /**
      * This method handles a scroll event originating from an external scroll control.
      * It's an advanced method and should probably not be used unless you're implementing a custom scroll-bar solution.
      */
   }, {
     key: "handleScrollEvent",
-    value: function handleScrollEvent(_ref2) {
-      var _ref2$scrollLeft = _ref2.scrollLeft,
+    value: function handleScrollEvent(_ref2 /*:: */) {
+      var _ref2$scrollLeft = _ref2 /*:: */.scrollLeft,
         scrollLeftParam = _ref2$scrollLeft === void 0 ? 0 : _ref2$scrollLeft,
-        _ref2$scrollTop = _ref2.scrollTop,
+        _ref2$scrollTop = _ref2 /*:: */.scrollTop,
         scrollTopParam = _ref2$scrollTop === void 0 ? 0 : _ref2$scrollTop;
-
       // On iOS, we can arrive at negative offsets by swiping past the start.
       // To prevent flicker here, we make playing in the negative offset zone cause nothing to happen.
       if (scrollTopParam < 0) {
         return;
-      } // Prevent pointer events from interrupting a smooth scroll
+      }
 
+      // Prevent pointer events from interrupting a smooth scroll
       this._debounceScrollEnded();
       var _this$props = this.props,
         autoHeight = _this$props.autoHeight,
         autoWidth = _this$props.autoWidth,
         height = _this$props.height,
         width = _this$props.width;
-      var instanceProps = this.state.instanceProps; // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,
+      var instanceProps = this.state.instanceProps;
+
+      // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,
       // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.
       // This causes a series of rapid renders that is slow for long lists.
       // We can avoid that by doing some simple bounds checking to ensure that scroll offsets never exceed their bounds.
-
       var scrollbarSize = instanceProps.scrollbarSize;
       var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();
       var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();
       var scrollLeft = Math.min(Math.max(0, totalColumnsWidth - width + scrollbarSize), scrollLeftParam);
-      var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), scrollTopParam); // Certain devices (like Apple touchpad) rapid-fire duplicate events.
+      var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), scrollTopParam);
+
+      // Certain devices (like Apple touchpad) rapid-fire duplicate events.
       // Don't force a re-render if this is the case.
       // The mouse may move faster then the animation frame does.
       // Use requestAnimationFrame to avoid over-updating.
-
       if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) {
         // Track scrolling direction so we can more efficiently overscan rows to reduce empty space around the edges while scrolling.
         // Don't change direction for an axis unless scroll offset has changed.
         var scrollDirectionHorizontal = scrollLeft !== this.state.scrollLeft ? scrollLeft > this.state.scrollLeft ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD : this.state.scrollDirectionHorizontal;
         var scrollDirectionVertical = scrollTop !== this.state.scrollTop ? scrollTop > this.state.scrollTop ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD : this.state.scrollDirectionVertical;
-        var newState
-        /*: $Shape<State>*/ = {
+        var newState /*: $Shape<State>*/ = {
           isScrolling: true,
           scrollDirectionHorizontal: scrollDirectionHorizontal,
           scrollDirectionVertical: scrollDirectionVertical,
@@ -120704,6 +120662,7 @@ function (_React$PureComponent) {
         totalRowsHeight: totalRowsHeight
       });
     }
+
     /**
      * Invalidate Grid size and recompute visible cells.
      * This is a deferred wrapper for recomputeGridSize().
@@ -120713,12 +120672,13 @@ function (_React$PureComponent) {
     // @TODO (bvaughn) Add automated test coverage for this.
   }, {
     key: "invalidateCellSizeAfterRender",
-    value: function invalidateCellSizeAfterRender(_ref3) {
-      var columnIndex = _ref3.columnIndex,
-        rowIndex = _ref3.rowIndex;
+    value: function invalidateCellSizeAfterRender(_ref3 /*:: */) {
+      var columnIndex = _ref3 /*:: */.columnIndex,
+        rowIndex = _ref3 /*:: */.rowIndex;
       this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;
       this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;
     }
+
     /**
      * Pre-measure all columns and rows in a Grid.
      * Typically cells are only measured as needed and estimated sizes are used for cells that have not yet been measured.
@@ -120734,6 +120694,7 @@ function (_React$PureComponent) {
       instanceProps.columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1);
       instanceProps.rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1);
     }
+
     /**
      * Forced recompute of row heights and column widths.
      * This function should be called if dynamic column or row sizes have changed but nothing else has.
@@ -120752,37 +120713,41 @@ function (_React$PureComponent) {
         scrollToRow = _this$props3.scrollToRow;
       var instanceProps = this.state.instanceProps;
       instanceProps.columnSizeAndPositionManager.resetCell(columnIndex);
-      instanceProps.rowSizeAndPositionManager.resetCell(rowIndex); // Cell sizes may be determined by a function property.
+      instanceProps.rowSizeAndPositionManager.resetCell(rowIndex);
+
+      // Cell sizes may be determined by a function property.
       // In this case the cDU handler can't know if they changed.
       // Store this flag to let the next cDU pass know it needs to recompute the scroll offset.
-
       this._recomputeScrollLeftFlag = scrollToColumn >= 0 && (this.state.scrollDirectionHorizontal === SCROLL_DIRECTION_FORWARD ? columnIndex <= scrollToColumn : columnIndex >= scrollToColumn);
-      this._recomputeScrollTopFlag = scrollToRow >= 0 && (this.state.scrollDirectionVertical === SCROLL_DIRECTION_FORWARD ? rowIndex <= scrollToRow : rowIndex >= scrollToRow); // Clear cell cache in case we are scrolling;
-      // Invalid row heights likely mean invalid cached content as well.
+      this._recomputeScrollTopFlag = scrollToRow >= 0 && (this.state.scrollDirectionVertical === SCROLL_DIRECTION_FORWARD ? rowIndex <= scrollToRow : rowIndex >= scrollToRow);
 
+      // Clear cell cache in case we are scrolling;
+      // Invalid row heights likely mean invalid cached content as well.
       this._styleCache = {};
       this._cellCache = {};
       this.forceUpdate();
     }
+
     /**
      * Ensure column and row are visible.
      */
   }, {
     key: "scrollToCell",
-    value: function scrollToCell(_ref5) {
-      var columnIndex = _ref5.columnIndex,
-        rowIndex = _ref5.rowIndex;
+    value: function scrollToCell(_ref5 /*:: */) {
+      var columnIndex = _ref5 /*:: */.columnIndex,
+        rowIndex = _ref5 /*:: */.rowIndex;
       var columnCount = this.props.columnCount;
-      var props = this.props; // Don't adjust scroll offset for single-column grids (eg List, Table).
-      // This can cause a funky scroll offset because of the vertical scrollbar width.
+      var props = this.props;
 
+      // Don't adjust scroll offset for single-column grids (eg List, Table).
+      // This can cause a funky scroll offset because of the vertical scrollbar width.
       if (columnCount > 1 && columnIndex !== undefined) {
-        this._updateScrollLeftForScrollToColumn(Grid_objectSpread({}, props, {
+        this._updateScrollLeftForScrollToColumn(Grid_objectSpread(Grid_objectSpread({}, props), {}, {
           scrollToColumn: columnIndex
         }));
       }
       if (rowIndex !== undefined) {
-        this._updateScrollTopForScrollToRow(Grid_objectSpread({}, props, {
+        this._updateScrollTopForScrollToRow(Grid_objectSpread(Grid_objectSpread({}, props), {}, {
           scrollToRow: rowIndex
         }));
       }
@@ -120798,18 +120763,21 @@ function (_React$PureComponent) {
         scrollTop = _this$props4.scrollTop,
         scrollToRow = _this$props4.scrollToRow,
         width = _this$props4.width;
-      var instanceProps = this.state.instanceProps; // Reset initial offsets to be ignored in browser
+      var instanceProps = this.state.instanceProps;
 
+      // Reset initial offsets to be ignored in browser
       this._initialScrollTop = 0;
-      this._initialScrollLeft = 0; // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.
+      this._initialScrollLeft = 0;
+
+      // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.
       // We must do this at the start of the method as we may calculate and update scroll position below.
+      this._handleInvalidatedGridSize();
 
-      this._handleInvalidatedGridSize(); // If this component was first rendered server-side, scrollbar size will be undefined.
+      // If this component was first rendered server-side, scrollbar size will be undefined.
       // In that event we need to remeasure.
-
       if (!instanceProps.scrollbarSizeMeasured) {
         this.setState(function (prevState) {
-          var stateUpdate = Grid_objectSpread({}, prevState, {
+          var stateUpdate = Grid_objectSpread(Grid_objectSpread({}, prevState), {}, {
             needToResetStyleCache: false
           });
           stateUpdate.instanceProps.scrollbarSize = getScrollbarSize();
@@ -120827,8 +120795,9 @@ function (_React$PureComponent) {
           stateUpdate.needToResetStyleCache = false;
           this.setState(stateUpdate);
         }
-      } // refs don't work in `react-test-renderer`
+      }
 
+      // refs don't work in `react-test-renderer`
       if (this._scrollingContainer) {
         // setting the ref's scrollLeft and scrollTop.
         // Somehow in MultiGrid the main grid doesn't trigger a update on mount.
@@ -120838,19 +120807,22 @@ function (_React$PureComponent) {
         if (this._scrollingContainer.scrollTop !== this.state.scrollTop) {
           this._scrollingContainer.scrollTop = this.state.scrollTop;
         }
-      } // Don't update scroll offset if the size is 0; we don't render any cells in this case.
-      // Setting a state may cause us to later thing we've updated the offce when we haven't.
+      }
 
+      // Don't update scroll offset if the size is 0; we don't render any cells in this case.
+      // Setting a state may cause us to later thing we've updated the offce when we haven't.
       var sizeIsBiggerThanZero = height > 0 && width > 0;
       if (scrollToColumn >= 0 && sizeIsBiggerThanZero) {
         this._updateScrollLeftForScrollToColumn();
       }
       if (scrollToRow >= 0 && sizeIsBiggerThanZero) {
         this._updateScrollTopForScrollToRow();
-      } // Update onRowsRendered callback
+      }
 
-      this._invokeOnGridRenderedHelper(); // Initialize onScroll callback
+      // Update onRowsRendered callback
+      this._invokeOnGridRenderedHelper();
 
+      // Initialize onScroll callback
       this._invokeOnScrollMemoizer({
         scrollLeft: scrollLeft || 0,
         scrollTop: scrollTop || 0,
@@ -120859,6 +120831,7 @@ function (_React$PureComponent) {
       });
       this._maybeCallOnScrollbarPresenceChange();
     }
+
     /**
      * @private
      * This method updates scrollLeft/scrollTop in state for the following conditions:
@@ -120866,9 +120839,7 @@ function (_React$PureComponent) {
      */
   }, {
     key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps
-    /*: Props*/, prevState
-    /*: State*/) {
+    value: function componentDidUpdate(prevProps /*: Props*/, prevState /*: State*/) {
       var _this2 = this;
       var _this$props5 = this.props,
         autoHeight = _this$props5.autoHeight,
@@ -120884,19 +120855,21 @@ function (_React$PureComponent) {
         scrollLeft = _this$state.scrollLeft,
         scrollPositionChangeReason = _this$state.scrollPositionChangeReason,
         scrollTop = _this$state.scrollTop,
-        instanceProps = _this$state.instanceProps; // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.
+        instanceProps = _this$state.instanceProps;
+      // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.
       // We must do this at the start of the method as we may calculate and update scroll position below.
+      this._handleInvalidatedGridSize();
 
-      this._handleInvalidatedGridSize(); // Handle edge case where column or row count has only just increased over 0.
+      // Handle edge case where column or row count has only just increased over 0.
       // In this case we may have to restore a previously-specified scroll offset.
       // For more info see bvaughn/react-virtualized/issues/218
+      var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0;
 
-      var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0; // Make sure requested changes to :scrollLeft or :scrollTop get applied.
+      // Make sure requested changes to :scrollLeft or :scrollTop get applied.
       // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,
       // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread).
       // So we only set these when we require an adjustment of the scroll position.
       // See issue #2 for more information.
-
       if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {
         // @TRICKY :autoHeight and :autoWidth properties instructs Grid to leave :scrollTop and :scrollLeft management to an external HOC (eg WindowScroller).
         // In this case we should avoid checking scrollingContainer.scrollTop and scrollingContainer.scrollLeft since it forces layout/flow.
@@ -120906,13 +120879,15 @@ function (_React$PureComponent) {
         if (!autoHeight && scrollTop >= 0 && (scrollTop !== this._scrollingContainer.scrollTop || columnOrRowCountJustIncreasedFromZero)) {
           this._scrollingContainer.scrollTop = scrollTop;
         }
-      } // Special case where the previous size was 0:
+      }
+
+      // 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.
+      var sizeJustIncreasedFromZero = (prevProps.width === 0 || prevProps.height === 0) && height > 0 && width > 0;
 
-      var sizeJustIncreasedFromZero = (prevProps.width === 0 || prevProps.height === 0) && height > 0 && width > 0; // Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it
+      // Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it
       // @TODO Do we also need this check or can the one in componentWillUpdate() suffice?
-
       if (this._recomputeScrollLeftFlag) {
         this._recomputeScrollLeftFlag = false;
         this._updateScrollLeftForScrollToColumn(this.props);
@@ -120954,10 +120929,12 @@ function (_React$PureComponent) {
             return _this2._updateScrollTopForScrollToRow(_this2.props);
           }
         });
-      } // Update onRowsRendered callback if start/stop indices have changed
+      }
 
-      this._invokeOnGridRenderedHelper(); // Changes to :scrollLeft or :scrollTop should also notify :onScroll listeners
+      // 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();
@@ -120977,6 +120954,7 @@ function (_React$PureComponent) {
         cancelAnimationTimeout(this._disablePointerEventsTimeoutId);
       }
     }
+
     /**
      * This method updates scrollLeft/scrollTop in state for the following conditions:
      * 1) Empty content (0 rows or columns)
@@ -121005,8 +120983,7 @@ function (_React$PureComponent) {
         instanceProps = _this$state2.instanceProps,
         needToResetStyleCache = _this$state2.needToResetStyleCache;
       var isScrolling = this._isScrolling();
-      var gridStyle
-      /*: Object*/ = {
+      var gridStyle /*: Object*/ = {
         boxSizing: 'border-box',
         direction: 'ltr',
         height: autoHeight ? 'auto' : height,
@@ -121017,31 +120994,35 @@ function (_React$PureComponent) {
       };
       if (needToResetStyleCache) {
         this._styleCache = {};
-      } // calculate _styleCache here
-      // if state.isScrolling (not from _isScrolling) then reset
+      }
 
+      // calculate _styleCache here
+      // if state.isScrolling (not from _isScrolling) then reset
       if (!this.state.isScrolling) {
         this._resetStyleCache();
-      } // calculate children to render here
+      }
 
+      // calculate children to render here
       this._calculateChildrenToRender(this.props, this.state);
       var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();
-      var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize(); // Force browser to hide scrollbars when we know they aren't necessary.
+      var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();
+
+      // Force browser to hide scrollbars when we know they aren't necessary.
       // Otherwise once scrollbars appear they may not disappear again.
       // For more info see issue #116
-
       var verticalScrollBarSize = totalRowsHeight > height ? instanceProps.scrollbarSize : 0;
       var horizontalScrollBarSize = totalColumnsWidth > width ? instanceProps.scrollbarSize : 0;
       if (horizontalScrollBarSize !== this._horizontalScrollBarSize || verticalScrollBarSize !== this._verticalScrollBarSize) {
         this._horizontalScrollBarSize = horizontalScrollBarSize;
         this._verticalScrollBarSize = verticalScrollBarSize;
         this._scrollbarPresenceChanged = true;
-      } // Also explicitly init styles to 'auto' if scrollbars are required.
+      }
+
+      // Also explicitly init styles to 'auto' if scrollbars are required.
       // This works around an obscure edge case where external CSS styles have not yet been loaded,
       // But an initial scroll index of offset is set as an external prop.
       // Without this style, Grid would render the correct range of cells but would NOT update its internal offset.
       // This was originally reported via clauderic/react-infinite-calendar/issues/23
-
       gridStyle.overflowX = totalColumnsWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto';
       gridStyle.overflowY = totalRowsHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto';
       var childrenToDisplay = this._childrenToDisplay;
@@ -121055,7 +121036,7 @@ function (_React$PureComponent) {
         id: id,
         onScroll: this._onScroll,
         role: role,
-        style: Grid_objectSpread({}, gridStyle, {}, style),
+        style: Grid_objectSpread(Grid_objectSpread({}, gridStyle), style),
         tabIndex: tabIndex
       }), childrenToDisplay.length > 0 && /*#__PURE__*/react.createElement("div", {
         className: "ReactVirtualized__Grid__innerScrollContainer",
@@ -121071,14 +121052,13 @@ function (_React$PureComponent) {
         }, containerStyle)
       }, childrenToDisplay), showNoContentRenderer && noContentRenderer());
     }
+
     /* ---------------------------- Helper methods ---------------------------- */
   }, {
     key: "_calculateChildrenToRender",
     value: function _calculateChildrenToRender() {
-      var props
-      /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
-      var state
-      /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
+      var props /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
+      var state /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
       var cellRenderer = props.cellRenderer,
         cellRangeRenderer = props.cellRangeRenderer,
         columnCount = props.columnCount,
@@ -121096,8 +121076,9 @@ function (_React$PureComponent) {
       var scrollTop = this._initialScrollTop > 0 ? this._initialScrollTop : state.scrollTop;
       var scrollLeft = this._initialScrollLeft > 0 ? this._initialScrollLeft : state.scrollLeft;
       var isScrolling = this._isScrolling(props, state);
-      this._childrenToDisplay = []; // Render only enough columns and rows to cover the visible area of the grid.
+      this._childrenToDisplay = [];
 
+      // Render only enough columns and rows to cover the visible area of the grid.
       if (height > 0 && width > 0) {
         var visibleColumnIndices = instanceProps.columnSizeAndPositionManager.getVisibleCellRange({
           containerSize: width,
@@ -121114,8 +121095,9 @@ function (_React$PureComponent) {
         var verticalOffsetAdjustment = instanceProps.rowSizeAndPositionManager.getOffsetAdjustment({
           containerSize: height,
           offset: scrollTop
-        }); // Store for _invokeOnGridRenderedHelper()
+        });
 
+        // Store for _invokeOnGridRenderedHelper()
         this._renderedColumnStartIndex = visibleColumnIndices.start;
         this._renderedColumnStopIndex = visibleColumnIndices.stop;
         this._renderedRowStartIndex = visibleRowIndices.start;
@@ -121135,13 +121117,15 @@ function (_React$PureComponent) {
           scrollDirection: scrollDirectionVertical,
           startIndex: typeof visibleRowIndices.start === 'number' ? visibleRowIndices.start : 0,
           stopIndex: typeof visibleRowIndices.stop === 'number' ? visibleRowIndices.stop : -1
-        }); // Store for _invokeOnGridRenderedHelper()
+        });
 
+        // Store for _invokeOnGridRenderedHelper()
         var columnStartIndex = overscanColumnIndices.overscanStartIndex;
         var columnStopIndex = overscanColumnIndices.overscanStopIndex;
         var rowStartIndex = overscanRowIndices.overscanStartIndex;
-        var rowStopIndex = overscanRowIndices.overscanStopIndex; // Advanced use-cases (eg CellMeasurer) require batched measurements to determine accurate sizes.
+        var rowStopIndex = overscanRowIndices.overscanStopIndex;
 
+        // Advanced use-cases (eg CellMeasurer) require batched measurements to determine accurate sizes.
         if (deferredMeasurementCache) {
           // If rows have a dynamic height, scan the rows we are about to render.
           // If any have not yet been measured, then we need to render all columns initially,
@@ -121155,11 +121139,12 @@ function (_React$PureComponent) {
                 break;
               }
             }
-          } // If columns have a dynamic width, scan the columns we are about to render.
+          }
+
+          // If columns have a dynamic width, scan the columns we are about to render.
           // If any have not yet been measured, then we need to render all rows initially,
           // Because the width of the column is equal to the widest cell within that column,
           // (And so we can't know the width without measuring all row-cells first).
-
           if (!deferredMeasurementCache.hasFixedWidth()) {
             for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {
               if (!deferredMeasurementCache.has(0, columnIndex)) {
@@ -121190,14 +121175,16 @@ function (_React$PureComponent) {
           verticalOffsetAdjustment: verticalOffsetAdjustment,
           visibleColumnIndices: visibleColumnIndices,
           visibleRowIndices: visibleRowIndices
-        }); // update the indices
+        });
 
+        // update the indices
         this._columnStartIndex = columnStartIndex;
         this._columnStopIndex = columnStopIndex;
         this._rowStartIndex = rowStartIndex;
         this._rowStopIndex = rowStopIndex;
       }
     }
+
     /**
      * Sets an :isScrolling flag for a small window of time.
      * This flag is used to disable pointer events on the scrollable portion of the Grid.
@@ -121214,11 +121201,12 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_handleInvalidatedGridSize",
+    value:
     /**
      * Check for batched CellMeasurer size invalidations.
      * This will occur the first time one or more previously unmeasured cells are rendered.
      */
-    value: function _handleInvalidatedGridSize() {
+    function _handleInvalidatedGridSize() {
       if (typeof this._deferredInvalidateColumnIndex === 'number' && typeof this._deferredInvalidateRowIndex === 'number') {
         var columnIndex = this._deferredInvalidateColumnIndex;
         var rowIndex = this._deferredInvalidateRowIndex;
@@ -121232,12 +121220,12 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_invokeOnScrollMemoizer",
-    value: function _invokeOnScrollMemoizer(_ref6) {
+    value: function _invokeOnScrollMemoizer(_ref6 /*:: */) {
       var _this3 = this;
-      var scrollLeft = _ref6.scrollLeft,
-        scrollTop = _ref6.scrollTop,
-        totalColumnsWidth = _ref6.totalColumnsWidth,
-        totalRowsHeight = _ref6.totalRowsHeight;
+      var scrollLeft = _ref6 /*:: */.scrollLeft,
+        scrollTop = _ref6 /*:: */.scrollTop,
+        totalColumnsWidth = _ref6 /*:: */.totalColumnsWidth,
+        totalRowsHeight = _ref6 /*:: */.totalRowsHeight;
       this._onScrollMemoizer({
         callback: function callback(_ref7) {
           var scrollLeft = _ref7.scrollLeft,
@@ -121263,12 +121251,9 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_isScrolling",
-    value: function _isScrolling() /*: boolean*/
-    {
-      var props
-      /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
-      var state
-      /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
+    value: function _isScrolling() /*: boolean*/{
+      var props /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
+      var state /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
       // If isScrolling is defined in props, use it to override the value in state
       // This is a performance optimization for WindowScroller + Grid
       return Object.hasOwnProperty.call(props, 'isScrolling') ? Boolean(props.isScrolling) : Boolean(state.isScrolling);
@@ -121288,13 +121273,14 @@ function (_React$PureComponent) {
     }
   }, {
     key: "scrollToPosition",
+    value:
     /**
      * Scroll to the specified offset(s).
      * Useful for animating position changes.
      */
-    value: function scrollToPosition(_ref8) {
-      var scrollLeft = _ref8.scrollLeft,
-        scrollTop = _ref8.scrollTop;
+    function scrollToPosition(_ref8 /*:: */) {
+      var scrollLeft = _ref8 /*:: */.scrollLeft,
+        scrollTop = _ref8 /*:: */.scrollTop;
       var stateUpdate = Grid._getScrollToPositionStateUpdate({
         prevState: this.state,
         scrollLeft: scrollLeft,
@@ -121308,19 +121294,15 @@ function (_React$PureComponent) {
   }, {
     key: "_getCalculatedScrollLeft",
     value: function _getCalculatedScrollLeft() {
-      var props
-      /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
-      var state
-      /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
+      var props /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
+      var state /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
       return Grid._getCalculatedScrollLeft(props, state);
     }
   }, {
     key: "_updateScrollLeftForScrollToColumn",
     value: function _updateScrollLeftForScrollToColumn() {
-      var props
-      /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
-      var state
-      /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
+      var props /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
+      var state /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
       var stateUpdate = Grid._getScrollLeftForScrollToColumnStateUpdate(props, state);
       if (stateUpdate) {
         stateUpdate.needToResetStyleCache = false;
@@ -121330,10 +121312,8 @@ function (_React$PureComponent) {
   }, {
     key: "_getCalculatedScrollTop",
     value: function _getCalculatedScrollTop() {
-      var props
-      /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
-      var state
-      /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
+      var props /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
+      var state /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
       return Grid._getCalculatedScrollTop(props, state);
     }
   }, {
@@ -121341,16 +121321,18 @@ function (_React$PureComponent) {
     value: function _resetStyleCache() {
       var styleCache = this._styleCache;
       var cellCache = this._cellCache;
-      var isScrollingOptOut = this.props.isScrollingOptOut; // Reset cell and style caches once scrolling stops.
+      var isScrollingOptOut = this.props.isScrollingOptOut;
+
+      // Reset cell and style caches once scrolling stops.
       // This makes Grid simpler to use (since cells commonly change).
       // And it keeps the caches from growing too large.
       // Performance is most sensitive when a user is scrolling.
       // Don't clear visible cells from cellCache if isScrollingOptOut is specified.
       // This keeps the cellCache to a resonable size.
-
       this._cellCache = {};
-      this._styleCache = {}; // Copy over the visible cell styles so avoid unnecessary re-render.
+      this._styleCache = {};
 
+      // Copy over the visible cell styles so avoid unnecessary re-render.
       for (var rowIndex = this._rowStartIndex; rowIndex <= this._rowStopIndex; rowIndex++) {
         for (var columnIndex = this._columnStartIndex; columnIndex <= this._columnStopIndex; columnIndex++) {
           var key = "".concat(rowIndex, "-").concat(columnIndex);
@@ -121364,10 +121346,8 @@ function (_React$PureComponent) {
   }, {
     key: "_updateScrollTopForScrollToRow",
     value: function _updateScrollTopForScrollToRow() {
-      var props
-      /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
-      var state
-      /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
+      var props /*: Props*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
+      var state /*: State*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;
       var stateUpdate = Grid._getScrollTopForScrollToRowStateUpdate(props, state);
       if (stateUpdate) {
         stateUpdate.needToResetStyleCache = false;
@@ -121376,14 +121356,13 @@ function (_React$PureComponent) {
     }
   }], [{
     key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(nextProps
-    /*: Props*/, prevState
-    /*: State*/) /*: $Shape<State>*/
-    {
+    value: function getDerivedStateFromProps(nextProps /*: Props*/, prevState /*: State*/) /*: $Shape<State>*/{
       var newState = {};
       if (nextProps.columnCount === 0 && prevState.scrollLeft !== 0 || nextProps.rowCount === 0 && prevState.scrollTop !== 0) {
         newState.scrollLeft = 0;
-        newState.scrollTop = 0; // only use scroll{Left,Top} from props if scrollTo{Column,Row} isn't specified
+        newState.scrollTop = 0;
+
+        // only use scroll{Left,Top} from props if scrollTo{Column,Row} isn't specified
         // scrollTo{Column,Row} should override scroll{Left,Top}
       } else if (nextProps.scrollLeft !== prevState.scrollLeft && nextProps.scrollToColumn < 0 || nextProps.scrollTop !== prevState.scrollTop && nextProps.scrollToRow < 0) {
         _extends2(newState, Grid._getScrollToPositionStateUpdate({
@@ -121392,8 +121371,9 @@ function (_React$PureComponent) {
           scrollTop: nextProps.scrollTop
         }));
       }
-      var instanceProps = prevState.instanceProps; // Initially we should not clearStyleCache
+      var instanceProps = prevState.instanceProps;
 
+      // Initially we should not clearStyleCache
       newState.needToResetStyleCache = false;
       if (nextProps.columnWidth !== instanceProps.prevColumnWidth || nextProps.rowHeight !== instanceProps.prevRowHeight) {
         // Reset cache. set it to {} in render
@@ -121412,8 +121392,9 @@ function (_React$PureComponent) {
       if (instanceProps.prevColumnCount === 0 || instanceProps.prevRowCount === 0) {
         instanceProps.prevColumnCount = 0;
         instanceProps.prevRowCount = 0;
-      } // If scrolling is controlled outside this component, clear cache when scrolling stops
+      }
 
+      // If scrolling is controlled outside this component, clear cache when scrolling stops
       if (nextProps.autoHeight && nextProps.isScrolling === false && instanceProps.prevIsScrolling === true) {
         _extends2(newState, {
           isScrolling: false
@@ -121457,8 +121438,9 @@ function (_React$PureComponent) {
       instanceProps.prevRowCount = nextProps.rowCount;
       instanceProps.prevRowHeight = nextProps.rowHeight;
       instanceProps.prevScrollToColumn = nextProps.scrollToColumn;
-      instanceProps.prevScrollToRow = nextProps.scrollToRow; // getting scrollBarSize (moved from componentWillMount)
+      instanceProps.prevScrollToRow = nextProps.scrollToRow;
 
+      // getting scrollBarSize (moved from componentWillMount)
       instanceProps.scrollbarSize = nextProps.getScrollbarSize();
       if (instanceProps.scrollbarSize === undefined) {
         instanceProps.scrollbarSizeMeasured = false;
@@ -121467,33 +121449,30 @@ function (_React$PureComponent) {
         instanceProps.scrollbarSizeMeasured = true;
       }
       newState.instanceProps = instanceProps;
-      return Grid_objectSpread({}, newState, {}, maybeStateA, {}, maybeStateB);
+      return Grid_objectSpread(Grid_objectSpread(Grid_objectSpread({}, newState), maybeStateA), maybeStateB);
     }
   }, {
     key: "_getEstimatedColumnSize",
-    value: function _getEstimatedColumnSize(props
-    /*: Props*/) {
+    value: function _getEstimatedColumnSize(props /*: Props*/) {
       return typeof props.columnWidth === 'number' ? props.columnWidth : props.estimatedColumnSize;
     }
   }, {
     key: "_getEstimatedRowSize",
-    value: function _getEstimatedRowSize(props
-    /*: Props*/) {
+    value: function _getEstimatedRowSize(props /*: Props*/) {
       return typeof props.rowHeight === 'number' ? props.rowHeight : props.estimatedRowSize;
     }
   }, {
     key: "_getScrollToPositionStateUpdate",
+    value:
     /**
      * Get the updated state after scrolling to
      * scrollLeft and scrollTop
      */
-    value: function _getScrollToPositionStateUpdate(_ref9) /*: $Shape<State>*/
-    {
-      var prevState = _ref9.prevState,
-        scrollLeft = _ref9.scrollLeft,
-        scrollTop = _ref9.scrollTop;
-      var newState
-      /*: Object*/ = {
+    function _getScrollToPositionStateUpdate(_ref9 /*:: */) /*: $Shape<State>*/{
+      var prevState = _ref9 /*:: */.prevState,
+        scrollLeft = _ref9 /*:: */.scrollLeft,
+        scrollTop = _ref9 /*:: */.scrollTop;
+      var newState /*: Object*/ = {
         scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED
       };
       if (typeof scrollLeft === 'number' && scrollLeft >= 0) {
@@ -121511,19 +121490,14 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_wrapSizeGetter",
-    value: function _wrapSizeGetter(value
-    /*: CellSize*/) /*: CellSizeGetter*/
-    {
+    value: function _wrapSizeGetter(value /*: CellSize*/) /*: CellSizeGetter*/{
       return typeof value === 'function' ? value : function () {
-        return value
-        /*: any*/;
+        return value /*: any*/;
       };
     }
   }, {
     key: "_getCalculatedScrollLeft",
-    value: function _getCalculatedScrollLeft(nextProps
-    /*: Props*/, prevState
-    /*: State*/) {
+    value: function _getCalculatedScrollLeft(nextProps /*: Props*/, prevState /*: State*/) {
       var columnCount = nextProps.columnCount,
         height = nextProps.height,
         scrollToAlignment = nextProps.scrollToAlignment,
@@ -121547,10 +121521,7 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_getScrollLeftForScrollToColumnStateUpdate",
-    value: function _getScrollLeftForScrollToColumnStateUpdate(nextProps
-    /*: Props*/, prevState
-    /*: State*/) /*: $Shape<State>*/
-    {
+    value: function _getScrollLeftForScrollToColumnStateUpdate(nextProps /*: Props*/, prevState /*: State*/) /*: $Shape<State>*/{
       var scrollLeft = prevState.scrollLeft;
       var calculatedScrollLeft = Grid._getCalculatedScrollLeft(nextProps, prevState);
       if (typeof calculatedScrollLeft === 'number' && calculatedScrollLeft >= 0 && scrollLeft !== calculatedScrollLeft) {
@@ -121564,9 +121535,7 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_getCalculatedScrollTop",
-    value: function _getCalculatedScrollTop(nextProps
-    /*: Props*/, prevState
-    /*: State*/) {
+    value: function _getCalculatedScrollTop(nextProps /*: Props*/, prevState /*: State*/) {
       var height = nextProps.height,
         rowCount = nextProps.rowCount,
         scrollToAlignment = nextProps.scrollToAlignment,
@@ -121590,10 +121559,7 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_getScrollTopForScrollToRowStateUpdate",
-    value: function _getScrollTopForScrollToRowStateUpdate(nextProps
-    /*: Props*/, prevState
-    /*: State*/) /*: $Shape<State>*/
-    {
+    value: function _getScrollTopForScrollToRowStateUpdate(nextProps /*: Props*/, prevState /*: State*/) /*: $Shape<State>*/{
       var scrollTop = prevState.scrollTop;
       var calculatedScrollTop = Grid._getCalculatedScrollTop(nextProps, prevState);
       if (typeof calculatedScrollTop === 'number' && calculatedScrollTop >= 0 && scrollTop !== calculatedScrollTop) {
@@ -121606,7 +121572,6 @@ function (_React$PureComponent) {
       return {};
     }
   }]);
-  return Grid;
 }(react.PureComponent);
 (0,defineProperty/* default */.A)(Grid, "defaultProps", {
   'aria-label': 'grid',
@@ -121644,18 +121609,18 @@ var accessibilityOverscanIndicesGetter_SCROLL_DIRECTION_BACKWARD = (/* unused pu
 var accessibilityOverscanIndicesGetter_SCROLL_DIRECTION_FORWARD = 1;
 var accessibilityOverscanIndicesGetter_SCROLL_DIRECTION_HORIZONTAL = 'horizontal';
 var accessibilityOverscanIndicesGetter_SCROLL_DIRECTION_VERTICAL = 'vertical';
+
 /**
  * Calculates the number of cells to overscan before and after a specified range.
  * This function ensures that overscanning doesn't exceed the available cells.
  */
 
-function accessibilityOverscanIndicesGetter_defaultOverscanIndicesGetter(_ref) /*: OverscanIndices*/
-{
-  var cellCount = _ref.cellCount,
-    overscanCellsCount = _ref.overscanCellsCount,
-    scrollDirection = _ref.scrollDirection,
-    startIndex = _ref.startIndex,
-    stopIndex = _ref.stopIndex;
+function accessibilityOverscanIndicesGetter_defaultOverscanIndicesGetter(_ref /*:: */) /*: OverscanIndices*/{
+  var cellCount = _ref /*:: */.cellCount,
+    overscanCellsCount = _ref /*:: */.overscanCellsCount,
+    scrollDirection = _ref /*:: */.scrollDirection,
+    startIndex = _ref /*:: */.startIndex,
+    stopIndex = _ref /*:: */.stopIndex;
   // Make sure we render at least 1 cell extra before and after (except near boundaries)
   // This is necessary in order to support keyboard navigation (TAB/SHIFT+TAB) in some cases
   // For more info see issues #625
@@ -121696,36 +121661,38 @@ function accessibilityOverscanIndicesGetter_defaultOverscanIndicesGetter(_ref) /
 
 
 
-
-function Table_ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+function Table_ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-  return keys;
+  return t;
 }
-function Table_objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
-      Table_ownKeys(source, true).forEach(function (key) {
-        (0,defineProperty/* default */.A)(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      Table_ownKeys(source).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+function Table_objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? Table_ownKeys(Object(t), !0).forEach(function (r) {
+      (0,defineProperty/* default */.A)(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : Table_ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
   }
-  return target;
+  return e;
+}
+function Table_callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, Table_isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function Table_isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (Table_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
 }
-
 /*:: import type {CellPosition} from '../Grid';*/
 
 
@@ -121736,35 +121703,35 @@ function Table_objectSpread(target) {
 
 
 
+
 /**
  * Table component with fixed headers and virtualized rows for improved performance with large data sets.
  * This component expects explicit width, height, and padding parameters.
  */
-
-var Table = /*#__PURE__*/
-function (_React$PureComponent) {
-  _inherits(Table, _React$PureComponent);
+var Table = /*#__PURE__*/function (_React$PureComponent) {
   function Table(props) {
     var _this;
     _classCallCheck(this, Table);
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Table).call(this, props));
+    _this = Table_callSuper(this, Table, [props]);
     _this.state = {
       scrollbarWidth: 0
     };
-    _this._createColumn = _this._createColumn.bind((0,assertThisInitialized/* default */.A)(_this));
-    _this._createRow = _this._createRow.bind((0,assertThisInitialized/* default */.A)(_this));
-    _this._onScroll = _this._onScroll.bind((0,assertThisInitialized/* default */.A)(_this));
-    _this._onSectionRendered = _this._onSectionRendered.bind((0,assertThisInitialized/* default */.A)(_this));
-    _this._setRef = _this._setRef.bind((0,assertThisInitialized/* default */.A)(_this));
+    _this._createColumn = _this._createColumn.bind(_this);
+    _this._createRow = _this._createRow.bind(_this);
+    _this._onScroll = _this._onScroll.bind(_this);
+    _this._onSectionRendered = _this._onSectionRendered.bind(_this);
+    _this._setRef = _this._setRef.bind(_this);
     return _this;
   }
-  _createClass(Table, [{
+  _inherits(Table, _React$PureComponent);
+  return _createClass(Table, [{
     key: "forceUpdateGrid",
     value: function forceUpdateGrid() {
       if (this.Grid) {
         this.Grid.forceUpdate();
       }
     }
+
     /** See Grid#getOffsetForCell */
   }, {
     key: "getOffsetForRow",
@@ -121781,12 +121748,13 @@ function (_React$PureComponent) {
       }
       return 0;
     }
+
     /** CellMeasurer compatibility */
   }, {
     key: "invalidateCellSizeAfterRender",
-    value: function invalidateCellSizeAfterRender(_ref2) {
-      var columnIndex = _ref2.columnIndex,
-        rowIndex = _ref2.rowIndex;
+    value: function invalidateCellSizeAfterRender(_ref2 /*:: */) {
+      var columnIndex = _ref2 /*:: */.columnIndex,
+        rowIndex = _ref2 /*:: */.rowIndex;
       if (this.Grid) {
         this.Grid.invalidateCellSizeAfterRender({
           rowIndex: rowIndex,
@@ -121794,6 +121762,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#measureAllCells */
   }, {
     key: "measureAllRows",
@@ -121802,6 +121771,7 @@ function (_React$PureComponent) {
         this.Grid.measureAllCells();
       }
     }
+
     /** CellMeasurer compatibility */
   }, {
     key: "recomputeGridSize",
@@ -121818,6 +121788,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#recomputeGridSize */
   }, {
     key: "recomputeRowHeights",
@@ -121829,6 +121800,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#scrollToPosition */
   }, {
     key: "scrollToPosition",
@@ -121840,6 +121812,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#scrollToCell */
   }, {
     key: "scrollToRow",
@@ -121902,18 +121875,20 @@ function (_React$PureComponent) {
       }) : rowClassName;
       var rowStyleObject = typeof rowStyle === 'function' ? rowStyle({
         index: -1
-      }) : rowStyle; // Precompute and cache column styles before rendering rows and columns to speed things up
+      }) : rowStyle;
 
+      // Precompute and cache column styles before rendering rows and columns to speed things up
       this._cachedColumnStyles = [];
       react.Children.toArray(children).forEach(function (column, index) {
         var flexStyles = _this2._getFlexStyleForColumn(column, column.props.style);
         _this2._cachedColumnStyles[index] = Table_objectSpread({
           overflow: 'hidden'
         }, flexStyles);
-      }); // Note that we specify :rowCount, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid.
+      });
+
+      // Note that we specify :rowCount, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid.
       // This is done because Grid is a pure component and won't update unless its properties or state has changed.
       // Any property that should trigger a re-render of Grid then is specified here to avoid a stale display.
-
       return /*#__PURE__*/react.createElement("div", {
         "aria-label": this.props['aria-label'],
         "aria-labelledby": this.props['aria-labelledby'],
@@ -121949,7 +121924,7 @@ function (_React$PureComponent) {
         role: "rowgroup",
         scrollbarWidth: scrollbarWidth,
         scrollToRow: scrollToIndex,
-        style: Table_objectSpread({}, gridStyle, {
+        style: Table_objectSpread(Table_objectSpread({}, gridStyle), {}, {
           overflowX: 'hidden'
         })
       })));
@@ -121995,10 +121970,11 @@ function (_React$PureComponent) {
         });
       };
       var style = this._cachedColumnStyles[columnIndex];
-      var title = typeof renderedCell === 'string' ? renderedCell : null; // Avoid using object-spread syntax with multiple objects here,
+      var title = typeof renderedCell === 'string' ? renderedCell : null;
+
+      // Avoid using object-spread syntax with multiple objects here,
       // Since it results in an extra method call to 'babel-runtime/helpers/extends'
       // See PR https://github.com/bvaughn/react-virtualized/pull/942
-
       return /*#__PURE__*/react.createElement("div", {
         "aria-colindex": columnIndex + 1,
         "aria-describedby": id,
@@ -122030,12 +122006,13 @@ function (_React$PureComponent) {
         headerRenderer = _column$props2.headerRenderer,
         headerRole = _column$props2.headerRole,
         id = _column$props2.id,
-        label = _column$props2.label;
+        label = _column$props2.label,
+        preventAriaLabel = _column$props2.preventAriaLabel;
       var sortEnabled = !disableSort && sort;
       var classNames = clsx_m('ReactVirtualized__Table__headerColumn', headerClassName, column.props.headerClassName, {
         ReactVirtualized__Table__sortableHeaderColumn: sortEnabled
       });
-      var style = this._getFlexStyleForColumn(column, Table_objectSpread({}, headerStyle, {}, column.props.headerStyle));
+      var style = this._getFlexStyleForColumn(column, Table_objectSpread(Table_objectSpread({}, headerStyle), column.props.headerStyle));
       var renderedHeader = headerRenderer({
         columnData: columnData,
         dataKey: dataKey,
@@ -122044,13 +122021,22 @@ function (_React$PureComponent) {
         sortBy: sortBy,
         sortDirection: sortDirection
       });
-      var headerOnClick, headerOnKeyDown, headerTabIndex, headerAriaSort, headerAriaLabel;
+      var headerOnClick, headerOnKeyDown, headerTabIndex, headerAriaSort;
+      var headerAriaLabel = preventAriaLabel ? undefined : column.props['aria-label'] || label || dataKey;
       if (sortEnabled || onHeaderClick) {
         // If this is a sortable header, clicking it should update the table data's sorting.
-        var isFirstTimeSort = sortBy !== dataKey; // If this is the firstTime sort of this column, use the column default sort order.
-        // Otherwise, invert the direction of the sort.
+        var isFirstTimeSort = sortBy !== dataKey;
 
-        var newSortDirection = isFirstTimeSort ? defaultSortDirection : sortDirection === Table_SortDirection.DESC ? Table_SortDirection.ASC : Table_SortDirection.DESC;
+        // If this is the firstTime sort of this column, use the column default sort order.
+        // Otherwise, invert the direction of the sort.
+        var newSortDirection;
+        if (isFirstTimeSort) {
+          newSortDirection = defaultSortDirection;
+        } else if (sortDirection === Table_SortDirection.DESC) {
+          newSortDirection = Table_SortDirection.ASC;
+        } else {
+          newSortDirection = Table_SortDirection.DESC;
+        }
         var onClick = function onClick(event) {
           sortEnabled && sort({
             defaultSortDirection: defaultSortDirection,
@@ -122069,7 +122055,6 @@ function (_React$PureComponent) {
             onClick(event);
           }
         };
-        headerAriaLabel = column.props['aria-label'] || label || dataKey;
         headerAriaSort = 'none';
         headerTabIndex = 0;
         headerOnClick = onClick;
@@ -122077,10 +122062,11 @@ function (_React$PureComponent) {
       }
       if (sortBy === dataKey) {
         headerAriaSort = sortDirection === Table_SortDirection.ASC ? 'ascending' : 'descending';
-      } // Avoid using object-spread syntax with multiple objects here,
+      }
+
+      // Avoid using object-spread syntax with multiple objects here,
       // Since it results in an extra method call to 'babel-runtime/helpers/extends'
       // See PR https://github.com/bvaughn/react-virtualized/pull/942
-
       return /*#__PURE__*/react.createElement("div", {
         "aria-label": headerAriaLabel,
         "aria-sort": headerAriaSort,
@@ -122136,7 +122122,7 @@ function (_React$PureComponent) {
         });
       });
       var className = clsx_m('ReactVirtualized__Table__row', rowClass);
-      var flattenedStyle = Table_objectSpread({}, style, {
+      var flattenedStyle = Table_objectSpread(Table_objectSpread({}, style), {}, {
         height: this._getRowHeight(index),
         overflow: 'hidden',
         paddingRight: scrollbarWidth
@@ -122156,6 +122142,7 @@ function (_React$PureComponent) {
         style: flattenedStyle
       });
     }
+
     /**
      * Determines the flex-shrink, flex-grow, and width values for a cell (header or column).
      */
@@ -122164,7 +122151,7 @@ function (_React$PureComponent) {
     value: function _getFlexStyleForColumn(column) {
       var customStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var flexValue = "".concat(column.props.flexGrow, " ").concat(column.props.flexShrink, " ").concat(column.props.width, "px");
-      var style = Table_objectSpread({}, customStyle, {
+      var style = Table_objectSpread(Table_objectSpread({}, customStyle), {}, {
         flex: flexValue,
         msFlex: flexValue,
         WebkitFlex: flexValue
@@ -122242,7 +122229,6 @@ function (_React$PureComponent) {
       });
     }
   }]);
-  return Table;
 }(react.PureComponent);
 (0,defineProperty/* default */.A)(Table, "defaultProps", {
   disableHeader: false,
@@ -122297,6 +122283,7 @@ Table.propTypes =  false ? 0 : {};
  * 4) Add nonce for style element.
  * 5) Added support for injecting custom window object
  **/
+
 function createDetectElementResize(nonce, hostWindow) {
   // Check `document` and `window` in case of server-side rendering
   var _window;
@@ -122360,8 +122347,8 @@ function createDetectElementResize(nonce, hostWindow) {
         }
       });
     };
-    /* Detect CSS Animations support to detect element display/re-attach */
 
+    /* Detect CSS Animations support to detect element display/re-attach */
     var animation = false,
       keyframeprefix = '',
       animationstartevent = 'animationstart',
@@ -122432,8 +122419,8 @@ function createDetectElementResize(nonce, hostWindow) {
         element.appendChild(element.__resizeTriggers__);
         resetTriggers(element);
         element.addEventListener('scroll', scrollListener, true);
-        /* Listen for a css animation to detect element display/re-attach */
 
+        /* Listen for a css animation to detect element display/re-attach */
         if (animationstartevent) {
           element.__resizeTriggers__.__animationListener__ = function animationListener(e) {
             if (e.animationName == animationName) {
@@ -122459,7 +122446,8 @@ function createDetectElementResize(nonce, hostWindow) {
         }
         try {
           element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);
-        } catch (e) {// Preact compat; see developit/preact-compat/issues/228
+        } catch (e) {
+          // Preact compat; see developit/preact-compat/issues/228
         }
       }
     }
@@ -122476,34 +122464,37 @@ function createDetectElementResize(nonce, hostWindow) {
 
 
 
-
-function AutoSizer_ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+function AutoSizer_ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-  return keys;
+  return t;
 }
-function AutoSizer_objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
-      AutoSizer_ownKeys(source, true).forEach(function (key) {
-        (0,defineProperty/* default */.A)(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      AutoSizer_ownKeys(source).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+function AutoSizer_objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? AutoSizer_ownKeys(Object(t), !0).forEach(function (r) {
+      (0,defineProperty/* default */.A)(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : AutoSizer_ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
   }
-  return target;
+  return e;
+}
+function AutoSizer_callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, AutoSizer_isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function AutoSizer_isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (AutoSizer_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
 }
 
 
@@ -122511,7 +122502,6 @@ function AutoSizer_objectSpread(target) {
   height: number,
   width: number,
 };*/
-
 /*:: type Props = {
   /** Function responsible for rendering children.*-/
   children: Size => React.Element<*>,
@@ -122540,39 +122530,33 @@ function AutoSizer_objectSpread(target) {
   /** Optional inline style *-/
   style: ?Object,
 };*/
-
 /*:: type State = {
   height: number,
   width: number,
 };*/
-
 /*:: type ResizeHandler = (element: HTMLElement, onResize: () => void) => void;*/
-
 /*:: type DetectElementResize = {
   addResizeListener: ResizeHandler,
   removeResizeListener: ResizeHandler,
 };*/
-
-var AutoSizer = /*#__PURE__*/
-function (_React$Component) {
-  _inherits(AutoSizer, _React$Component);
+var AutoSizer = /*#__PURE__*/function (_React$Component) {
   function AutoSizer() {
-    var _getPrototypeOf2;
     var _this;
     _classCallCheck(this, AutoSizer);
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AutoSizer)).call.apply(_getPrototypeOf2, [this].concat(args)));
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "state", {
+    _this = AutoSizer_callSuper(this, AutoSizer, [].concat(args));
+    (0,defineProperty/* default */.A)(_this, "state", {
       height: _this.props.defaultHeight || 0,
       width: _this.props.defaultWidth || 0
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_parentNode", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_autoSizer", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_window", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_detectElementResize", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onResize", function () {
+    (0,defineProperty/* default */.A)(_this, "_parentNode", void 0);
+    (0,defineProperty/* default */.A)(_this, "_autoSizer", void 0);
+    (0,defineProperty/* default */.A)(_this, "_window", void 0);
+    // uses any instead of Window because Flow doesn't have window type
+    (0,defineProperty/* default */.A)(_this, "_detectElementResize", void 0);
+    (0,defineProperty/* default */.A)(_this, "_onResize", function () {
       var _this$props = _this.props,
         disableHeight = _this$props.disableHeight,
         disableWidth = _this$props.disableWidth,
@@ -122581,6 +122565,7 @@ function (_React$Component) {
         // Guard against AutoSizer component being removed from the DOM immediately after being added.
         // This can result in invalid style values which can result in NaN values if we don't handle them.
         // See issue #150 for more context.
+
         var height = _this._parentNode.offsetHeight || 0;
         var width = _this._parentNode.offsetWidth || 0;
         var win = _this._window || window;
@@ -122603,13 +122588,13 @@ function (_React$Component) {
         }
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_setRef", function (autoSizer
-    /*: ?HTMLElement*/) {
+    (0,defineProperty/* default */.A)(_this, "_setRef", function (autoSizer /*: ?HTMLElement*/) {
       _this._autoSizer = autoSizer;
     });
     return _this;
   }
-  _createClass(AutoSizer, [{
+  _inherits(AutoSizer, _React$Component);
+  return _createClass(AutoSizer, [{
     key: "componentDidMount",
     value: function componentDidMount() {
       var nonce = this.props.nonce;
@@ -122618,9 +122603,10 @@ function (_React$Component) {
         // This handles edge-cases where the component has already been unmounted before its ref has been set,
         // As well as libraries like react-lite which have a slightly different lifecycle.
         this._parentNode = this._autoSizer.parentNode;
-        this._window = this._autoSizer.parentNode.ownerDocument.defaultView; // Defer requiring resize handler in order to support server-side rendering.
-        // See issue #41
+        this._window = this._autoSizer.parentNode.ownerDocument.defaultView;
 
+        // Defer requiring resize handler in order to support server-side rendering.
+        // See issue #41
         this._detectElementResize = createDetectElementResize(nonce, this._window);
         this._detectElementResize.addResizeListener(this._parentNode, this._onResize);
         this._onResize();
@@ -122644,16 +122630,15 @@ function (_React$Component) {
         style = _this$props2.style;
       var _this$state = this.state,
         height = _this$state.height,
-        width = _this$state.width; // Outer div should not force width/height since that may prevent containers from shrinking.
+        width = _this$state.width;
+
+      // Outer div should not force width/height since that may prevent containers from shrinking.
       // Inner component should overflow and use calculated width/height.
       // See issue #68 for more information.
-
-      var outerStyle
-      /*: Object*/ = {
+      var outerStyle /*: Object*/ = {
         overflow: 'visible'
       };
-      var childParams
-      /*: Object*/ = {};
+      var childParams /*: Object*/ = {};
       if (!disableHeight) {
         outerStyle.height = 0;
         childParams.height = height;
@@ -122662,6 +122647,7 @@ function (_React$Component) {
         outerStyle.width = 0;
         childParams.width = width;
       }
+
       /**
        * TODO: Avoid rendering children before the initial measurements have been collected.
        * At best this would just be wasting cycles.
@@ -122678,11 +122664,10 @@ function (_React$Component) {
       return /*#__PURE__*/react.createElement("div", {
         className: className,
         ref: this._setRef,
-        style: AutoSizer_objectSpread({}, outerStyle, {}, style)
+        style: AutoSizer_objectSpread(AutoSizer_objectSpread({}, outerStyle), style)
       }, children(childParams));
     }
   }]);
-  return AutoSizer;
 }(react.Component);
 (0,defineProperty/* default */.A)(AutoSizer, "defaultProps", {
   onResize: function onResize() {},
@@ -130715,51 +130700,51 @@ progress_bar_ProgressBar_defineProperty(ProgressBar_ProgressBar, "defaultProps",
 
 
 
-
-function ArrowKeyStepper_ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+function ArrowKeyStepper_ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-  return keys;
+  return t;
 }
-function ArrowKeyStepper_objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
-      ArrowKeyStepper_ownKeys(source, true).forEach(function (key) {
-        (0,defineProperty/* default */.A)(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      ArrowKeyStepper_ownKeys(source).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+function ArrowKeyStepper_objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ArrowKeyStepper_ownKeys(Object(t), !0).forEach(function (r) {
+      (0,defineProperty/* default */.A)(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ArrowKeyStepper_ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
   }
-  return target;
+  return e;
+}
+function ArrowKeyStepper_callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, ArrowKeyStepper_isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function ArrowKeyStepper_isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (ArrowKeyStepper_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
 }
-
 /*:: import type {RenderedSection} from '../Grid';*/
-
 /*:: import type {ScrollIndices} from './types';*/
 
 
+
 /**
  * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time.
  */
-
 /*:: type ChildrenParams = {
   onSectionRendered: (params: RenderedSection) => void,
   scrollToColumn: number,
   scrollToRow: number,
 };*/
-
 /*:: type Props = {
   children: (params: ChildrenParams) => React.Element<*>,
   className?: string,
@@ -130772,26 +130757,21 @@ function ArrowKeyStepper_objectSpread(target) {
   scrollToColumn: number,
   scrollToRow: number,
 };*/
-
 /*:: type State = ScrollIndices & {
   instanceProps: {
     prevScrollToColumn: number,
     prevScrollToRow: number,
   },
 };*/
-
-var ArrowKeyStepper = /*#__PURE__*/
-function (_React$PureComponent) {
-  _inherits(ArrowKeyStepper, _React$PureComponent);
+var ArrowKeyStepper = /*#__PURE__*/function (_React$PureComponent) {
   function ArrowKeyStepper() {
-    var _getPrototypeOf2;
     var _this;
     _classCallCheck(this, ArrowKeyStepper);
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ArrowKeyStepper)).call.apply(_getPrototypeOf2, [this].concat(args)));
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "state", {
+    _this = ArrowKeyStepper_callSuper(this, ArrowKeyStepper, [].concat(args));
+    (0,defineProperty/* default */.A)(_this, "state", {
       scrollToColumn: 0,
       scrollToRow: 0,
       instanceProps: {
@@ -130799,12 +130779,11 @@ function (_React$PureComponent) {
         prevScrollToRow: 0
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_columnStartIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_columnStopIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_rowStartIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_rowStopIndex", 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onKeyDown", function (event
-    /*: KeyboardEvent*/) {
+    (0,defineProperty/* default */.A)(_this, "_columnStartIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_columnStopIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_rowStartIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_rowStopIndex", 0);
+    (0,defineProperty/* default */.A)(_this, "_onKeyDown", function (event /*: KeyboardEvent*/) {
       var _this$props = _this.props,
         columnCount = _this$props.columnCount,
         disabled = _this$props.disabled,
@@ -130818,9 +130797,10 @@ function (_React$PureComponent) {
         scrollToRowPrevious = _this$_getScrollState.scrollToRow;
       var _this$_getScrollState2 = _this._getScrollState(),
         scrollToColumn = _this$_getScrollState2.scrollToColumn,
-        scrollToRow = _this$_getScrollState2.scrollToRow; // The above cases all prevent default event event behavior.
-      // This is to keep the grid from scrolling after the snap-to update.
+        scrollToRow = _this$_getScrollState2.scrollToRow;
 
+      // The above cases all prevent default event event behavior.
+      // This is to keep the grid from scrolling after the snap-to update.
       switch (event.key) {
         case 'ArrowDown':
           scrollToRow = mode === 'cells' ? Math.min(scrollToRow + 1, rowCount - 1) : Math.min(_this._rowStopIndex + 1, rowCount - 1);
@@ -130843,11 +130823,11 @@ function (_React$PureComponent) {
         });
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onSectionRendered", function (_ref) {
-      var columnStartIndex = _ref.columnStartIndex,
-        columnStopIndex = _ref.columnStopIndex,
-        rowStartIndex = _ref.rowStartIndex,
-        rowStopIndex = _ref.rowStopIndex;
+    (0,defineProperty/* default */.A)(_this, "_onSectionRendered", function (_ref /*:: */) {
+      var columnStartIndex = _ref /*:: */.columnStartIndex,
+        columnStopIndex = _ref /*:: */.columnStopIndex,
+        rowStartIndex = _ref /*:: */.rowStartIndex,
+        rowStopIndex = _ref /*:: */.rowStopIndex;
       _this._columnStartIndex = columnStartIndex;
       _this._columnStopIndex = columnStopIndex;
       _this._rowStartIndex = rowStartIndex;
@@ -130855,11 +130835,12 @@ function (_React$PureComponent) {
     });
     return _this;
   }
-  _createClass(ArrowKeyStepper, [{
+  _inherits(ArrowKeyStepper, _React$PureComponent);
+  return _createClass(ArrowKeyStepper, [{
     key: "setScrollIndexes",
-    value: function setScrollIndexes(_ref2) {
-      var scrollToColumn = _ref2.scrollToColumn,
-        scrollToRow = _ref2.scrollToRow;
+    value: function setScrollIndexes(_ref2 /*:: */) {
+      var scrollToColumn = _ref2 /*:: */.scrollToColumn,
+        scrollToRow = _ref2 /*:: */.scrollToRow;
       this.setState({
         scrollToRow: scrollToRow,
         scrollToColumn: scrollToColumn
@@ -130890,9 +130871,9 @@ function (_React$PureComponent) {
     }
   }, {
     key: "_updateScrollState",
-    value: function _updateScrollState(_ref3) {
-      var scrollToColumn = _ref3.scrollToColumn,
-        scrollToRow = _ref3.scrollToRow;
+    value: function _updateScrollState(_ref3 /*:: */) {
+      var scrollToColumn = _ref3 /*:: */.scrollToColumn,
+        scrollToRow = _ref3 /*:: */.scrollToRow;
       var _this$props3 = this.props,
         isControlled = _this$props3.isControlled,
         onScrollToChange = _this$props3.onScrollToChange;
@@ -130911,15 +130892,12 @@ function (_React$PureComponent) {
     }
   }], [{
     key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(nextProps
-    /*: Props*/, prevState
-    /*: State*/) /*: $Shape<State>*/
-    {
+    value: function getDerivedStateFromProps(nextProps /*: Props*/, prevState /*: State*/) /*: $Shape<State>*/{
       if (nextProps.isControlled) {
         return {};
       }
       if (nextProps.scrollToColumn !== prevState.instanceProps.prevScrollToColumn || nextProps.scrollToRow !== prevState.instanceProps.prevScrollToRow) {
-        return ArrowKeyStepper_objectSpread({}, prevState, {
+        return ArrowKeyStepper_objectSpread(ArrowKeyStepper_objectSpread({}, prevState), {}, {
           scrollToColumn: nextProps.scrollToColumn,
           scrollToRow: nextProps.scrollToRow,
           instanceProps: {
@@ -130931,7 +130909,6 @@ function (_React$PureComponent) {
       return {};
     }
   }]);
-  return ArrowKeyStepper;
 }(react.PureComponent);
 (0,defineProperty/* default */.A)(ArrowKeyStepper, "defaultProps", {
   disabled: false,
@@ -130953,18 +130930,25 @@ function (_React$PureComponent) {
 
 
 
-
+function CellMeasurer_callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, CellMeasurer_isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function CellMeasurer_isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (CellMeasurer_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
+}
 
 
 /*:: import type {CellMeasureCache} from './types';*/
-
 /*:: type Children = (params: {measure: () => void}) => React.Element<*>;*/
-
 /*:: type Cell = {
   columnIndex: number,
   rowIndex: number,
 };*/
-
 /*:: type Props = {
   cache: CellMeasureCache,
   children: Children | React.Element<*>,
@@ -130976,25 +130960,21 @@ function (_React$PureComponent) {
   },
   rowIndex?: number,
 };*/
-
 /**
  * Wraps a cell and measures its rendered content.
  * Measurements are stored in a per-cell cache.
  * Cached-content is not be re-measured.
  */
-var CellMeasurer_CellMeasurer = /*#__PURE__*/
-function (_React$PureComponent) {
-  _inherits(CellMeasurer, _React$PureComponent);
+var CellMeasurer_CellMeasurer = /*#__PURE__*/function (_React$PureComponent) {
   function CellMeasurer() {
-    var _getPrototypeOf2;
     var _this;
     _classCallCheck(this, CellMeasurer);
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CellMeasurer)).call.apply(_getPrototypeOf2, [this].concat(args)));
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_child", void 0);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_measure", function () {
+    _this = CellMeasurer_callSuper(this, CellMeasurer, [].concat(args));
+    (0,defineProperty/* default */.A)(_this, "_child", void 0);
+    (0,defineProperty/* default */.A)(_this, "_measure", function () {
       var _this$props = _this.props,
         cache = _this$props.cache,
         _this$props$columnInd = _this$props.columnIndex,
@@ -131015,7 +130995,7 @@ function (_React$PureComponent) {
         }
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_registerChild", function (element) {
+    (0,defineProperty/* default */.A)(_this, "_registerChild", function (element) {
       if (element && !(element instanceof Element)) {
         console.warn('CellMeasurer registerChild expects to be passed Element or null');
       }
@@ -131026,7 +131006,8 @@ function (_React$PureComponent) {
     });
     return _this;
   }
-  _createClass(CellMeasurer, [{
+  _inherits(CellMeasurer, _React$PureComponent);
+  return _createClass(CellMeasurer, [{
     key: "componentDidMount",
     value: function componentDidMount() {
       this._maybeMeasureCell();
@@ -131049,11 +131030,15 @@ function (_React$PureComponent) {
     key: "_getCellMeasurements",
     value: function _getCellMeasurements() {
       var cache = this.props.cache;
-      var node = this._child || (0,react_dom.findDOMNode)(this); // TODO Check for a bad combination of fixedWidth and missing numeric width or vice versa with height
+      var node = this._child || (0,react_dom.findDOMNode)(this);
+
+      // TODO Check for a bad combination of fixedWidth and missing numeric width or vice versa with height
 
       if (node && node.ownerDocument && node.ownerDocument.defaultView && node instanceof node.ownerDocument.defaultView.HTMLElement) {
         var styleWidth = node.style.width;
-        var styleHeight = node.style.height; // If we are re-measuring a cell that has already been measured,
+        var styleHeight = node.style.height;
+
+        // If we are re-measuring a cell that has already been measured,
         // It will have a hard-coded width/height from the previous measurement.
         // The fact that we are measuring indicates this measurement is probably stale,
         // So explicitly clear it out (eg set to "auto") so we can recalculate.
@@ -131062,7 +131047,6 @@ function (_React$PureComponent) {
         // Explicitly clear width/height before measuring to avoid being tainted by another Grid.
         // eg top/left Grid renders before bottom/right Grid
         // Since the CellMeasurerCache is shared between them this taints derived cell size values.
-
         if (!cache.hasFixedWidth()) {
           node.style.width = 'auto';
         }
@@ -131070,8 +131054,9 @@ function (_React$PureComponent) {
           node.style.height = 'auto';
         }
         var height = Math.ceil(node.offsetHeight);
-        var width = Math.ceil(node.offsetWidth); // Reset after measuring to avoid breaking styles; see #660
+        var width = Math.ceil(node.offsetWidth);
 
+        // Reset after measuring to avoid breaking styles; see #660
         if (styleWidth) {
           node.style.width = styleWidth;
         }
@@ -131103,8 +131088,9 @@ function (_React$PureComponent) {
         var _this$_getCellMeasure2 = this._getCellMeasurements(),
           height = _this$_getCellMeasure2.height,
           width = _this$_getCellMeasure2.width;
-        cache.set(rowIndex, columnIndex, width, height); // If size has changed, let Grid know to re-render.
+        cache.set(rowIndex, columnIndex, width, height);
 
+        // If size has changed, let Grid know to re-render.
         if (parent && typeof parent.invalidateCellSizeAfterRender === 'function') {
           parent.invalidateCellSizeAfterRender({
             columnIndex: columnIndex,
@@ -131114,9 +131100,7 @@ function (_React$PureComponent) {
       }
     }
   }]);
-  return CellMeasurer;
 }(react.PureComponent); // Used for DEV mode warning check
-
 (0,defineProperty/* default */.A)(CellMeasurer_CellMeasurer, "__internalCellMeasurerFlag", false);
 
 if (false) {}
@@ -131124,14 +131108,13 @@ if (false) {}
 
 
 
-
 /*:: import type {CellMeasureCache} from './types';*/
 var DEFAULT_HEIGHT = 30;
-var DEFAULT_WIDTH = 100; // Enables more intelligent mapping of a given column and row index to an item ID.
-// This prevents a cell cache from being invalidated when its parent collection is modified.
+var DEFAULT_WIDTH = 100;
 
+// Enables more intelligent mapping of a given column and row index to an item ID.
+// This prevents a cell cache from being invalidated when its parent collection is modified.
 /*:: type KeyMapper = (rowIndex: number, columnIndex: number) => any;*/
-
 /*:: type CellMeasurerCacheParams = {
   defaultHeight?: number,
   defaultWidth?: number,
@@ -131141,24 +131124,19 @@ var DEFAULT_WIDTH = 100; // Enables more intelligent mapping of a given column a
   minWidth?: number,
   keyMapper?: KeyMapper,
 };*/
-
 /*:: type Cache = {
   [key: any]: number,
 };*/
-
 /*:: type IndexParam = {
   index: number,
 };*/
-
 /**
  * Caches measurements for a given cell.
  */
-var CellMeasurerCache = /*#__PURE__*/
-function () {
+var CellMeasurerCache = /*#__PURE__*/function () {
   function CellMeasurerCache() {
     var _this = this;
-    var params
-    /*: CellMeasurerCacheParams*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var params /*: CellMeasurerCacheParams*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     _classCallCheck(this, CellMeasurerCache);
     (0,defineProperty/* default */.A)(this, "_cellHeightCache", {});
     (0,defineProperty/* default */.A)(this, "_cellWidthCache", {});
@@ -131173,13 +131151,13 @@ function () {
     (0,defineProperty/* default */.A)(this, "_hasFixedWidth", void 0);
     (0,defineProperty/* default */.A)(this, "_columnCount", 0);
     (0,defineProperty/* default */.A)(this, "_rowCount", 0);
-    (0,defineProperty/* default */.A)(this, "columnWidth", function (_ref) {
-      var index = _ref.index;
+    (0,defineProperty/* default */.A)(this, "columnWidth", function (_ref /*:: */) {
+      var index = _ref /*:: */.index;
       var key = _this._keyMapper(0, index);
       return _this._columnWidthCache[key] !== undefined ? _this._columnWidthCache[key] : _this._defaultWidth;
     });
-    (0,defineProperty/* default */.A)(this, "rowHeight", function (_ref2) {
-      var index = _ref2.index;
+    (0,defineProperty/* default */.A)(this, "rowHeight", function (_ref2 /*:: */) {
+      var index = _ref2 /*:: */.index;
       var key = _this._keyMapper(index, 0);
       return _this._rowHeightCache[key] !== undefined ? _this._rowHeightCache[key] : _this._defaultHeight;
     });
@@ -131199,12 +131177,10 @@ function () {
     this._defaultWidth = Math.max(this._minWidth, typeof defaultWidth === 'number' ? defaultWidth : DEFAULT_WIDTH);
     if (false) {}
   }
-  _createClass(CellMeasurerCache, [{
+  return _createClass(CellMeasurerCache, [{
     key: "clear",
-    value: function clear(rowIndex
-    /*: number*/) {
-      var columnIndex
-      /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    value: function clear(rowIndex /*: number*/) {
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       var key = this._keyMapper(rowIndex, columnIndex);
       delete this._cellHeightCache[key];
       delete this._cellWidthCache[key];
@@ -131220,25 +131196,30 @@ function () {
       this._rowCount = 0;
       this._columnCount = 0;
     }
+  }, {
+    key: "defaultHeight",
+    get: function get() /*: number*/{
+      return this._defaultHeight;
+    }
+  }, {
+    key: "defaultWidth",
+    get: function get() /*: number*/{
+      return this._defaultWidth;
+    }
   }, {
     key: "hasFixedHeight",
-    value: function hasFixedHeight() /*: boolean*/
-    {
+    value: function hasFixedHeight() /*: boolean*/{
       return this._hasFixedHeight;
     }
   }, {
     key: "hasFixedWidth",
-    value: function hasFixedWidth() /*: boolean*/
-    {
+    value: function hasFixedWidth() /*: boolean*/{
       return this._hasFixedWidth;
     }
   }, {
     key: "getHeight",
-    value: function getHeight(rowIndex
-    /*: number*/) /*: number*/
-    {
-      var columnIndex
-      /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    value: function getHeight(rowIndex /*: number*/) /*: number*/{
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       if (this._hasFixedHeight) {
         return this._defaultHeight;
       } else {
@@ -131248,11 +131229,8 @@ function () {
     }
   }, {
     key: "getWidth",
-    value: function getWidth(rowIndex
-    /*: number*/) /*: number*/
-    {
-      var columnIndex
-      /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    value: function getWidth(rowIndex /*: number*/) /*: number*/{
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       if (this._hasFixedWidth) {
         return this._defaultWidth;
       } else {
@@ -131262,39 +131240,30 @@ function () {
     }
   }, {
     key: "has",
-    value: function has(rowIndex
-    /*: number*/) /*: boolean*/
-    {
-      var columnIndex
-      /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    value: function has(rowIndex /*: number*/) /*: boolean*/{
+      var columnIndex /*: number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       var key = this._keyMapper(rowIndex, columnIndex);
       return this._cellHeightCache[key] !== undefined;
     }
   }, {
     key: "set",
-    value: function set(rowIndex
-    /*: number*/, columnIndex
-    /*: number*/, width
-    /*: number*/, height
-    /*: number*/) /*: void*/
-    {
+    value: function set(rowIndex /*: number*/, columnIndex /*: number*/, width /*: number*/, height /*: number*/) /*: void*/{
       var key = this._keyMapper(rowIndex, columnIndex);
       if (columnIndex >= this._columnCount) {
         this._columnCount = columnIndex + 1;
       }
       if (rowIndex >= this._rowCount) {
         this._rowCount = rowIndex + 1;
-      } // Size is cached per cell so we don't have to re-measure if cells are re-ordered.
+      }
 
+      // 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;
       this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);
     }
   }, {
     key: "_updateCachedColumnAndRowSizes",
-    value: function _updateCachedColumnAndRowSizes(rowIndex
-    /*: number*/, columnIndex
-    /*: number*/) {
+    value: function _updateCachedColumnAndRowSizes(rowIndex /*: number*/, columnIndex /*: number*/) {
       // :columnWidth and :rowHeight are derived based on all cells in a column/row.
       // Pre-cache these derived values for faster lookup later.
       // Reads are expected to occur more frequently than writes in this case.
@@ -131316,25 +131285,10 @@ function () {
         this._rowHeightCache[rowKey] = rowHeight;
       }
     }
-  }, {
-    key: "defaultHeight",
-    get: function get() /*: number*/
-    {
-      return this._defaultHeight;
-    }
-  }, {
-    key: "defaultWidth",
-    get: function get() /*: number*/
-    {
-      return this._defaultWidth;
-    }
   }]);
-  return CellMeasurerCache;
 }();
 
-function defaultKeyMapper(rowIndex
-/*: number*/, columnIndex
-/*: number*/) {
+function defaultKeyMapper(rowIndex /*: number*/, columnIndex /*: number*/) {
   return "".concat(rowIndex, "-").concat(columnIndex);
 }
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/CellMeasurer/index.js
@@ -132706,32 +132660,28 @@ var isString_default = /*#__PURE__*/__webpack_require__.n(isString);
   columnIndexOffset: number,
   rowIndexOffset: number,
 };*/
-
 /*:: type IndexParam = {
   index: number,
 };*/
-
 /**
  * Caches measurements for a given cell.
  */
-var CellMeasurerCacheDecorator = /*#__PURE__*/
-function () {
+var CellMeasurerCacheDecorator = /*#__PURE__*/function () {
   function CellMeasurerCacheDecorator() {
     var _this = this;
-    var params
-    /*: CellMeasurerCacheDecoratorParams*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var params /*: CellMeasurerCacheDecoratorParams*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     _classCallCheck(this, CellMeasurerCacheDecorator);
     (0,defineProperty/* default */.A)(this, "_cellMeasurerCache", void 0);
     (0,defineProperty/* default */.A)(this, "_columnIndexOffset", void 0);
     (0,defineProperty/* default */.A)(this, "_rowIndexOffset", void 0);
-    (0,defineProperty/* default */.A)(this, "columnWidth", function (_ref) {
-      var index = _ref.index;
+    (0,defineProperty/* default */.A)(this, "columnWidth", function (_ref /*:: */) {
+      var index = _ref /*:: */.index;
       _this._cellMeasurerCache.columnWidth({
         index: index + _this._columnIndexOffset
       });
     });
-    (0,defineProperty/* default */.A)(this, "rowHeight", function (_ref2) {
-      var index = _ref2.index;
+    (0,defineProperty/* default */.A)(this, "rowHeight", function (_ref2 /*:: */) {
+      var index = _ref2 /*:: */.index;
       _this._cellMeasurerCache.rowHeight({
         index: index + _this._rowIndexOffset
       });
@@ -132745,85 +132695,60 @@ function () {
     this._columnIndexOffset = columnIndexOffset;
     this._rowIndexOffset = rowIndexOffset;
   }
-  _createClass(CellMeasurerCacheDecorator, [{
+  return _createClass(CellMeasurerCacheDecorator, [{
     key: "clear",
-    value: function clear(rowIndex
-    /*: number*/, columnIndex
-    /*: number*/) /*: void*/
-    {
+    value: function clear(rowIndex /*: number*/, columnIndex /*: number*/) /*: void*/{
       this._cellMeasurerCache.clear(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
     }
   }, {
     key: "clearAll",
-    value: function clearAll() /*: void*/
-    {
+    value: function clearAll() /*: void*/{
       this._cellMeasurerCache.clearAll();
     }
+  }, {
+    key: "defaultHeight",
+    get: function get() /*: number*/{
+      return this._cellMeasurerCache.defaultHeight;
+    }
+  }, {
+    key: "defaultWidth",
+    get: function get() /*: number*/{
+      return this._cellMeasurerCache.defaultWidth;
+    }
   }, {
     key: "hasFixedHeight",
-    value: function hasFixedHeight() /*: boolean*/
-    {
+    value: function hasFixedHeight() /*: boolean*/{
       return this._cellMeasurerCache.hasFixedHeight();
     }
   }, {
     key: "hasFixedWidth",
-    value: function hasFixedWidth() /*: boolean*/
-    {
+    value: function hasFixedWidth() /*: boolean*/{
       return this._cellMeasurerCache.hasFixedWidth();
     }
   }, {
     key: "getHeight",
-    value: function getHeight(rowIndex
-    /*: number*/) /*: ?number*/
-    {
-      var columnIndex
-      /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    value: function getHeight(rowIndex /*: number*/) /*: ?number*/{
+      var columnIndex /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       return this._cellMeasurerCache.getHeight(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
     }
   }, {
     key: "getWidth",
-    value: function getWidth(rowIndex
-    /*: number*/) /*: ?number*/
-    {
-      var columnIndex
-      /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    value: function getWidth(rowIndex /*: number*/) /*: ?number*/{
+      var columnIndex /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       return this._cellMeasurerCache.getWidth(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
     }
   }, {
     key: "has",
-    value: function has(rowIndex
-    /*: number*/) /*: boolean*/
-    {
-      var columnIndex
-      /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    value: function has(rowIndex /*: number*/) /*: boolean*/{
+      var columnIndex /*: ?number*/ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       return this._cellMeasurerCache.has(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);
     }
   }, {
     key: "set",
-    value: function set(rowIndex
-    /*: number*/, columnIndex
-    /*: number*/, width
-    /*: number*/, height
-    /*: number*/) /*: void*/
-    {
-      this._cellMeasurerCache.set(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset, width
-      /*: number*/, height
-      /*: number*/);
-    }
-  }, {
-    key: "defaultHeight",
-    get: function get() /*: number*/
-    {
-      return this._cellMeasurerCache.defaultHeight;
-    }
-  }, {
-    key: "defaultWidth",
-    get: function get() /*: number*/
-    {
-      return this._cellMeasurerCache.defaultWidth;
+    value: function set(rowIndex /*: number*/, columnIndex /*: number*/, width /*: number*/, height /*: number*/) /*: void*/{
+      this._cellMeasurerCache.set(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset, width /*: number*/, height /*: number*/);
     }
   }]);
-  return CellMeasurerCacheDecorator;
 }();
 
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/MultiGrid/MultiGrid.js
@@ -132835,34 +132760,41 @@ function () {
 
 
 
-
-function MultiGrid_ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+var MultiGrid_excluded = ["rowIndex"],
+  MultiGrid_excluded2 = ["columnIndex", "rowIndex"],
+  _excluded3 = ["columnIndex"],
+  _excluded4 = ["onScroll", "onSectionRendered", "onScrollbarPresenceChange", "scrollLeft", "scrollToColumn", "scrollTop", "scrollToRow"];
+function MultiGrid_ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-  return keys;
+  return t;
 }
-function MultiGrid_objectSpread(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-    if (i % 2) {
-      MultiGrid_ownKeys(source, true).forEach(function (key) {
-        (0,defineProperty/* default */.A)(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      MultiGrid_ownKeys(source).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+function MultiGrid_objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? MultiGrid_ownKeys(Object(t), !0).forEach(function (r) {
+      (0,defineProperty/* default */.A)(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : MultiGrid_ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
   }
-  return target;
+  return e;
+}
+function MultiGrid_callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, MultiGrid_isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function MultiGrid_isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (MultiGrid_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
 }
 
 
@@ -132870,6 +132802,7 @@ function MultiGrid_objectSpread(target) {
 
 
 var SCROLLBAR_SIZE_BUFFER = 20;
+
 /**
  * Renders 1, 2, or 4 Grids depending on configuration.
  * A main (body) Grid will always be rendered.
@@ -132877,32 +132810,29 @@ var SCROLLBAR_SIZE_BUFFER = 20;
  * If no sticky columns, only 1 sticky header Grid will be rendered.
  * If sticky columns, 2 sticky header Grids will be rendered.
  */
-
-var MultiGrid = /*#__PURE__*/
-function (_React$PureComponent) {
-  _inherits(MultiGrid, _React$PureComponent);
+var MultiGrid = /*#__PURE__*/function (_React$PureComponent) {
   function MultiGrid(props, context) {
     var _this;
     _classCallCheck(this, MultiGrid);
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(MultiGrid).call(this, props, context));
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "state", {
+    _this = MultiGrid_callSuper(this, MultiGrid, [props, context]);
+    (0,defineProperty/* default */.A)(_this, "state", {
       scrollLeft: 0,
       scrollTop: 0,
       scrollbarSize: 0,
       showHorizontalScrollbar: false,
       showVerticalScrollbar: false
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_deferredInvalidateColumnIndex", null);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_deferredInvalidateRowIndex", null);
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_bottomLeftGridRef", function (ref) {
+    (0,defineProperty/* default */.A)(_this, "_deferredInvalidateColumnIndex", null);
+    (0,defineProperty/* default */.A)(_this, "_deferredInvalidateRowIndex", null);
+    (0,defineProperty/* default */.A)(_this, "_bottomLeftGridRef", function (ref) {
       _this._bottomLeftGrid = ref;
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_bottomRightGridRef", function (ref) {
+    (0,defineProperty/* default */.A)(_this, "_bottomRightGridRef", function (ref) {
       _this._bottomRightGrid = ref;
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_cellRendererBottomLeftGrid", function (_ref) {
+    (0,defineProperty/* default */.A)(_this, "_cellRendererBottomLeftGrid", function (_ref) {
       var rowIndex = _ref.rowIndex,
-        rest = objectWithoutProperties_objectWithoutProperties(_ref, ["rowIndex"]);
+        rest = objectWithoutProperties_objectWithoutProperties(_ref, MultiGrid_excluded);
       var _this$props = _this.props,
         cellRenderer = _this$props.cellRenderer,
         fixedRowCount = _this$props.fixedRowCount,
@@ -132910,34 +132840,34 @@ function (_React$PureComponent) {
       if (rowIndex === rowCount - fixedRowCount) {
         return /*#__PURE__*/react.createElement("div", {
           key: rest.key,
-          style: MultiGrid_objectSpread({}, rest.style, {
+          style: MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest.style), {}, {
             height: SCROLLBAR_SIZE_BUFFER
           })
         });
       } else {
-        return cellRenderer(MultiGrid_objectSpread({}, rest, {
-          parent: (0,assertThisInitialized/* default */.A)(_this),
+        return cellRenderer(MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest), {}, {
+          parent: _this,
           rowIndex: rowIndex + fixedRowCount
         }));
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_cellRendererBottomRightGrid", function (_ref2) {
+    (0,defineProperty/* default */.A)(_this, "_cellRendererBottomRightGrid", function (_ref2) {
       var columnIndex = _ref2.columnIndex,
         rowIndex = _ref2.rowIndex,
-        rest = objectWithoutProperties_objectWithoutProperties(_ref2, ["columnIndex", "rowIndex"]);
+        rest = objectWithoutProperties_objectWithoutProperties(_ref2, MultiGrid_excluded2);
       var _this$props2 = _this.props,
         cellRenderer = _this$props2.cellRenderer,
         fixedColumnCount = _this$props2.fixedColumnCount,
         fixedRowCount = _this$props2.fixedRowCount;
-      return cellRenderer(MultiGrid_objectSpread({}, rest, {
+      return cellRenderer(MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest), {}, {
         columnIndex: columnIndex + fixedColumnCount,
-        parent: (0,assertThisInitialized/* default */.A)(_this),
+        parent: _this,
         rowIndex: rowIndex + fixedRowCount
       }));
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_cellRendererTopRightGrid", function (_ref3) {
+    (0,defineProperty/* default */.A)(_this, "_cellRendererTopRightGrid", function (_ref3) {
       var columnIndex = _ref3.columnIndex,
-        rest = objectWithoutProperties_objectWithoutProperties(_ref3, ["columnIndex"]);
+        rest = objectWithoutProperties_objectWithoutProperties(_ref3, _excluded3);
       var _this$props3 = _this.props,
         cellRenderer = _this$props3.cellRenderer,
         columnCount = _this$props3.columnCount,
@@ -132945,18 +132875,18 @@ function (_React$PureComponent) {
       if (columnIndex === columnCount - fixedColumnCount) {
         return /*#__PURE__*/react.createElement("div", {
           key: rest.key,
-          style: MultiGrid_objectSpread({}, rest.style, {
+          style: MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest.style), {}, {
             width: SCROLLBAR_SIZE_BUFFER
           })
         });
       } else {
-        return cellRenderer(MultiGrid_objectSpread({}, rest, {
+        return cellRenderer(MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest), {}, {
           columnIndex: columnIndex + fixedColumnCount,
-          parent: (0,assertThisInitialized/* default */.A)(_this)
+          parent: _this
         }));
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_columnWidthRightGrid", function (_ref4) {
+    (0,defineProperty/* default */.A)(_this, "_columnWidthRightGrid", function (_ref4) {
       var index = _ref4.index;
       var _this$props4 = _this.props,
         columnCount = _this$props4.columnCount,
@@ -132964,11 +132894,12 @@ function (_React$PureComponent) {
         columnWidth = _this$props4.columnWidth;
       var _this$state = _this.state,
         scrollbarSize = _this$state.scrollbarSize,
-        showHorizontalScrollbar = _this$state.showHorizontalScrollbar; // An extra cell is added to the count
+        showHorizontalScrollbar = _this$state.showHorizontalScrollbar;
+
+      // An extra cell is added to the count
       // This gives the smaller Grid extra room for offset,
       // In case the main (bottom right) Grid has a scrollbar
       // If no scrollbar, the extra space is overflow:hidden anyway
-
       if (showHorizontalScrollbar && index === columnCount - fixedColumnCount) {
         return scrollbarSize;
       }
@@ -132976,7 +132907,7 @@ function (_React$PureComponent) {
         index: index + fixedColumnCount
       }) : columnWidth;
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onScroll", function (scrollInfo) {
+    (0,defineProperty/* default */.A)(_this, "_onScroll", function (scrollInfo) {
       var scrollLeft = scrollInfo.scrollLeft,
         scrollTop = scrollInfo.scrollTop;
       _this.setState({
@@ -132988,7 +132919,7 @@ function (_React$PureComponent) {
         onScroll(scrollInfo);
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onScrollbarPresenceChange", function (_ref5) {
+    (0,defineProperty/* default */.A)(_this, "_onScrollbarPresenceChange", function (_ref5) {
       var horizontal = _ref5.horizontal,
         size = _ref5.size,
         vertical = _ref5.vertical;
@@ -133011,21 +132942,21 @@ function (_React$PureComponent) {
         }
       }
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onScrollLeft", function (scrollInfo) {
+    (0,defineProperty/* default */.A)(_this, "_onScrollLeft", function (scrollInfo) {
       var scrollLeft = scrollInfo.scrollLeft;
       _this._onScroll({
         scrollLeft: scrollLeft,
         scrollTop: _this.state.scrollTop
       });
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_onScrollTop", function (scrollInfo) {
+    (0,defineProperty/* default */.A)(_this, "_onScrollTop", function (scrollInfo) {
       var scrollTop = scrollInfo.scrollTop;
       _this._onScroll({
         scrollTop: scrollTop,
         scrollLeft: _this.state.scrollLeft
       });
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_rowHeightBottomGrid", function (_ref6) {
+    (0,defineProperty/* default */.A)(_this, "_rowHeightBottomGrid", function (_ref6) {
       var index = _ref6.index;
       var _this$props5 = _this.props,
         fixedRowCount = _this$props5.fixedRowCount,
@@ -133033,11 +132964,12 @@ function (_React$PureComponent) {
         rowHeight = _this$props5.rowHeight;
       var _this$state3 = _this.state,
         scrollbarSize = _this$state3.scrollbarSize,
-        showVerticalScrollbar = _this$state3.showVerticalScrollbar; // An extra cell is added to the count
+        showVerticalScrollbar = _this$state3.showVerticalScrollbar;
+
+      // An extra cell is added to the count
       // This gives the smaller Grid extra room for offset,
       // In case the main (bottom right) Grid has a scrollbar
       // If no scrollbar, the extra space is overflow:hidden anyway
-
       if (showVerticalScrollbar && index === rowCount - fixedRowCount) {
         return scrollbarSize;
       }
@@ -133045,10 +132977,10 @@ function (_React$PureComponent) {
         index: index + fixedRowCount
       }) : rowHeight;
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_topLeftGridRef", function (ref) {
+    (0,defineProperty/* default */.A)(_this, "_topLeftGridRef", function (ref) {
       _this._topLeftGrid = ref;
     });
-    (0,defineProperty/* default */.A)((0,assertThisInitialized/* default */.A)(_this), "_topRightGridRef", function (ref) {
+    (0,defineProperty/* default */.A)(_this, "_topRightGridRef", function (ref) {
       _this._topRightGrid = ref;
     });
     var deferredMeasurementCache = props.deferredMeasurementCache,
@@ -133074,7 +133006,8 @@ function (_React$PureComponent) {
     }
     return _this;
   }
-  _createClass(MultiGrid, [{
+  _inherits(MultiGrid, _React$PureComponent);
+  return _createClass(MultiGrid, [{
     key: "forceUpdateGrids",
     value: function forceUpdateGrids() {
       this._bottomLeftGrid && this._bottomLeftGrid.forceUpdate();
@@ -133082,6 +133015,7 @@ function (_React$PureComponent) {
       this._topLeftGrid && this._topLeftGrid.forceUpdate();
       this._topRightGrid && this._topRightGrid.forceUpdate();
     }
+
     /** See Grid#invalidateCellSizeAfterRender */
   }, {
     key: "invalidateCellSizeAfterRender",
@@ -133094,6 +133028,7 @@ function (_React$PureComponent) {
       this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;
       this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;
     }
+
     /** See Grid#measureAllCells */
   }, {
     key: "measureAllCells",
@@ -133103,6 +133038,7 @@ function (_React$PureComponent) {
       this._topLeftGrid && this._topLeftGrid.measureAllCells();
       this._topRightGrid && this._topRightGrid.measureAllCells();
     }
+
     /** See Grid#recomputeGridSize */
   }, {
     key: "recomputeGridSize",
@@ -133171,14 +133107,17 @@ function (_React$PureComponent) {
         scrollToColumn = _this$props8.scrollToColumn,
         scrollTopProp = _this$props8.scrollTop,
         scrollToRow = _this$props8.scrollToRow,
-        rest = objectWithoutProperties_objectWithoutProperties(_this$props8, ["onScroll", "onSectionRendered", "onScrollbarPresenceChange", "scrollLeft", "scrollToColumn", "scrollTop", "scrollToRow"]);
-      this._prepareForRender(); // Don't render any of our Grids if there are no cells.
+        rest = objectWithoutProperties_objectWithoutProperties(_this$props8, _excluded4);
+      this._prepareForRender();
+
+      // Don't render any of our Grids if there are no cells.
       // This mirrors what Grid does,
       // And prevents us from recording inaccurage measurements when used with CellMeasurer.
-
       if (this.props.width === 0 || this.props.height === 0) {
         return null;
-      } // scrollTop and scrollLeft props are explicitly filtered out and ignored
+      }
+
+      // scrollTop and scrollLeft props are explicitly filtered out and ignored
 
       var _this$state4 = this.state,
         scrollLeft = _this$state4.scrollLeft,
@@ -133187,15 +133126,15 @@ function (_React$PureComponent) {
         style: this._containerOuterStyle
       }, /*#__PURE__*/react.createElement("div", {
         style: this._containerTopStyle
-      }, this._renderTopLeftGrid(rest), this._renderTopRightGrid(MultiGrid_objectSpread({}, rest, {
+      }, this._renderTopLeftGrid(rest), this._renderTopRightGrid(MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest), {}, {
         onScroll: onScroll,
         scrollLeft: scrollLeft
       }))), /*#__PURE__*/react.createElement("div", {
         style: this._containerBottomStyle
-      }, this._renderBottomLeftGrid(MultiGrid_objectSpread({}, rest, {
+      }, this._renderBottomLeftGrid(MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest), {}, {
         onScroll: onScroll,
         scrollTop: scrollTop
-      })), this._renderBottomRightGrid(MultiGrid_objectSpread({}, rest, {
+      })), this._renderBottomRightGrid(MultiGrid_objectSpread(MultiGrid_objectSpread({}, rest), {}, {
         onScroll: onScroll,
         onSectionRendered: onSectionRendered,
         scrollLeft: scrollLeft,
@@ -133273,6 +133212,7 @@ function (_React$PureComponent) {
         this.forceUpdate();
       }
     }
+
     /**
      * Avoid recreating inline styles each render; this bypasses Grid's shallowCompare.
      * This method recalculates styles only when specific props change.
@@ -133412,7 +133352,7 @@ function (_React$PureComponent) {
       if (hideBottomLeftGridScrollbar) {
         return /*#__PURE__*/react.createElement("div", {
           className: "BottomLeftGrid_ScrollWrapper",
-          style: MultiGrid_objectSpread({}, this._bottomLeftGridStyle, {
+          style: MultiGrid_objectSpread(MultiGrid_objectSpread({}, this._bottomLeftGridStyle), {}, {
             height: height,
             width: width,
             overflowY: 'hidden'
@@ -133490,7 +133430,7 @@ function (_React$PureComponent) {
         style = this._topRightGridStyle;
       if (hideTopRightGridScrollbar) {
         gridHeight = height + additionalHeight;
-        style = MultiGrid_objectSpread({}, this._topRightGridStyle, {
+        style = MultiGrid_objectSpread(MultiGrid_objectSpread({}, this._topRightGridStyle), {}, {
           left: 0
         });
       }
@@ -133512,7 +133452,7 @@ function (_React$PureComponent) {
       if (hideTopRightGridScrollbar) {
         return /*#__PURE__*/react.createElement("div", {
           className: "TopRightGrid_ScrollWrapper",
-          style: MultiGrid_objectSpread({}, this._topRightGridStyle, {
+          style: MultiGrid_objectSpread(MultiGrid_objectSpread({}, this._topRightGridStyle), {}, {
             height: height,
             width: width,
             overflowX: 'hidden'
@@ -133533,7 +133473,6 @@ function (_React$PureComponent) {
       return null;
     }
   }]);
-  return MultiGrid;
 }(react.PureComponent);
 (0,defineProperty/* default */.A)(MultiGrid, "defaultProps", {
   classNameBottomLeftGrid: '',