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

package/dist/uploader.js

@@ -44866,11 +44866,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"
@@ -44912,10 +44911,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', {
@@ -44941,15 +44940,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",
@@ -44968,22 +44966,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
   };
@@ -45042,11 +45039,6 @@ function defaultRowRenderer(_ref) {
     style: style
   }), columns);
 }
-;// 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");
-}
-
 ;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
 function _typeof(o) {
   "@babel/helpers - typeof";
@@ -45058,6 +45050,46 @@ function _typeof(o) {
   }, _typeof(o);
 }
 
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+
+;// 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, toPropertyKey(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");
+}
+
 ;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
 function _assertThisInitialized(e) {
   if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -45095,27 +45127,6 @@ function _inherits(t, e) {
   }), e && _setPrototypeOf(t, e);
 }
 
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-
-function toPrimitive(t, r) {
-  if ("object" != _typeof(t) || !t) return t;
-  var e = t[Symbol.toPrimitive];
-  if (void 0 !== e) {
-    var i = e.call(t, r || "default");
-    if ("object" != _typeof(i)) return i;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return ("string" === r ? String : Number)(t);
-}
-
-;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-
-
-function toPropertyKey(t) {
-  var i = toPrimitive(t, "string");
-  return "symbol" == _typeof(i) ? i : i + "";
-}
-
 ;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
 
 function defineProperty_defineProperty(e, r, t) {
@@ -45129,14 +45140,12 @@ function defineProperty_defineProperty(e, r, t) {
 
 ;// 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 {
@@ -45145,15 +45154,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 {
@@ -45167,6 +45175,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;
+  })();
+}
+
+
 
 
 
@@ -45175,15 +45196,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);
 defineProperty_defineProperty(Column, "defaultProps", {
   cellDataGetter: defaultCellDataGetter,
@@ -45198,25 +45217,10 @@ defineProperty_defineProperty(Column, "defaultProps", {
 });
 
 Column.propTypes =  false ? 0 : {};
-;// 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, toPropertyKey(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,
@@ -45245,23 +45249,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();
     }
@@ -45285,54 +45289,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
     defineProperty_defineProperty(this, "_cellSizeAndPositionData", {});
+    // Measurements for cells up to this index can be trusted; cells afterward should be estimated.
     defineProperty_defineProperty(this, "_lastMeasuredIndex", -1);
+    // Used in deferred mode to track which cells have been queued for measurement.
     defineProperty_defineProperty(this, "_lastBatchedIndex", -1);
     defineProperty_defineProperty(this, "_cellCount", void 0);
     defineProperty_defineProperty(this, "_cellSizeGetter", void 0);
@@ -45341,37 +45337,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;
     }
   }, {
@@ -45379,15 +45372,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));
       }
@@ -45397,9 +45389,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) {
@@ -45422,13 +45415,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.
@@ -45436,14 +45429,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.
@@ -45457,13 +45450,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;
       }
@@ -45490,9 +45482,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();
@@ -45513,6 +45503,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.
@@ -45520,18 +45511,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;
@@ -45551,10 +45536,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;
@@ -45562,6 +45544,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.
      *
@@ -45570,14 +45553,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);
@@ -45592,7 +45574,6 @@ function () {
       }
     }
   }]);
-  return CellSizeAndPositionManager;
 }();
 
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/Grid/utils/maxElementSize.js
@@ -45604,8 +45585,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;
@@ -45618,7 +45598,7 @@ var getMaxElementSize = function getMaxElementSize() /*: number*/
 
 
 
-
+var ScalingCellSizeAndPositionManager_excluded = ["maxScrollSize"];
 /*:: import type {Alignment, CellSizeGetter, VisibleCellRange} from '../types';*/
 
 
@@ -45626,35 +45606,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);
     defineProperty_defineProperty(this, "_cellSizeAndPositionManager", void 0);
     defineProperty_defineProperty(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;
     }
   }, {
@@ -45669,32 +45649,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({
@@ -45706,8 +45683,7 @@ function () {
     }
   }, {
     key: "getSizeAndPositionOfCell",
-    value: function getSizeAndPositionOfCell(index
-    /*: number*/) {
+    value: function getSizeAndPositionOfCell(index /*: number*/) {
       return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);
     }
   }, {
@@ -45715,22 +45691,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
@@ -45746,13 +45723,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
@@ -45764,25 +45741,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) {
@@ -45798,10 +45772,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) {
@@ -45816,7 +45789,6 @@ function () {
       }
     }
   }]);
-  return ScalingCellSizeAndPositionManager;
 }();
 
 ;// CONCATENATED MODULE: ./node_modules/@box/react-virtualized/dist/es/utils/createCallbackMemoizer.js
@@ -45851,18 +45823,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),
@@ -45878,11 +45850,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,
@@ -45920,28 +45892,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.
@@ -45956,35 +45930,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++) {
@@ -45993,8 +45969,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 {
@@ -46031,7 +46008,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.
@@ -46041,12 +46020,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);
@@ -46093,9 +46073,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;
@@ -46105,49 +46083,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);
+// 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 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*/;
+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();
   });
@@ -46158,8 +46123,7 @@ var requestAnimationTimeout = function requestAnimationTimeout(callback
       frame.id = raf(timeout);
     }
   };
-  var frame
-  /*: AnimationTimeoutId*/ = {
+  var frame /*: AnimationTimeoutId*/ = {
     id: raf(timeout)
   };
   return frame;
@@ -46173,36 +46137,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) {
-        defineProperty_defineProperty(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) {
+      defineProperty_defineProperty(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,
@@ -46218,7 +46184,6 @@ function Grid_objectSpread(target) {
   CellCache,
   StyleCache,
 } from './types';*/
-
 /*:: import type {AnimationTimeoutId} from '../utils/requestAnimationTimeout';*/
 
 
@@ -46231,30 +46196,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,
@@ -46420,7 +46383,6 @@ var renderNull
   /** Width of Grid; this property determines the number of visible (vs virtualized) columns.  *-/
   width: number,
 };*/
-
 /*:: type InstanceProps = {
   prevColumnWidth: CellSize,
   prevRowHeight: CellSize,
@@ -46437,7 +46399,6 @@ var renderNull
   scrollbarSize: number,
   scrollbarSizeMeasured: boolean,
 };*/
-
 /*:: type State = {
   instanceProps: InstanceProps,
   isScrolling: boolean,
@@ -46448,54 +46409,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));
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_onGridRenderedMemoizer", createCallbackMemoizer());
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_onScrollMemoizer", createCallbackMemoizer(false));
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_deferredInvalidateColumnIndex", null);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_deferredInvalidateRowIndex", null);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_recomputeScrollLeftFlag", false);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_recomputeScrollTopFlag", false);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_horizontalScrollBarSize", 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_verticalScrollBarSize", 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_scrollbarPresenceChanged", false);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_scrollingContainer", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_childrenToDisplay", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_columnStartIndex", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_columnStopIndex", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_rowStartIndex", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_rowStopIndex", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_renderedColumnStartIndex", 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_renderedColumnStopIndex", 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_renderedRowStartIndex", 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_renderedRowStopIndex", 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_initialScrollTop", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_initialScrollLeft", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_disablePointerEventsTimeoutId", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_styleCache", {});
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_cellCache", {});
-    defineProperty_defineProperty(_assertThisInitialized(_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
+    defineProperty_defineProperty(_this, "_onGridRenderedMemoizer", createCallbackMemoizer());
+    defineProperty_defineProperty(_this, "_onScrollMemoizer", createCallbackMemoizer(false));
+    defineProperty_defineProperty(_this, "_deferredInvalidateColumnIndex", null);
+    defineProperty_defineProperty(_this, "_deferredInvalidateRowIndex", null);
+    defineProperty_defineProperty(_this, "_recomputeScrollLeftFlag", false);
+    defineProperty_defineProperty(_this, "_recomputeScrollTopFlag", false);
+    defineProperty_defineProperty(_this, "_horizontalScrollBarSize", 0);
+    defineProperty_defineProperty(_this, "_verticalScrollBarSize", 0);
+    defineProperty_defineProperty(_this, "_scrollbarPresenceChanged", false);
+    defineProperty_defineProperty(_this, "_scrollingContainer", void 0);
+    defineProperty_defineProperty(_this, "_childrenToDisplay", void 0);
+    defineProperty_defineProperty(_this, "_columnStartIndex", void 0);
+    defineProperty_defineProperty(_this, "_columnStopIndex", void 0);
+    defineProperty_defineProperty(_this, "_rowStartIndex", void 0);
+    defineProperty_defineProperty(_this, "_rowStopIndex", void 0);
+    defineProperty_defineProperty(_this, "_renderedColumnStartIndex", 0);
+    defineProperty_defineProperty(_this, "_renderedColumnStopIndex", 0);
+    defineProperty_defineProperty(_this, "_renderedRowStartIndex", 0);
+    defineProperty_defineProperty(_this, "_renderedRowStopIndex", 0);
+    defineProperty_defineProperty(_this, "_initialScrollTop", void 0);
+    defineProperty_defineProperty(_this, "_initialScrollLeft", void 0);
+    defineProperty_defineProperty(_this, "_disablePointerEventsTimeoutId", void 0);
+    defineProperty_defineProperty(_this, "_styleCache", {});
+    defineProperty_defineProperty(_this, "_cellCache", {});
+    defineProperty_defineProperty(_this, "_debounceScrollEndedCallback", function () {
+      _this._disablePointerEventsTimeoutId = null;
+      // isScrolling is used to determine if we reset styleCache
       _this.setState({
         isScrolling: false,
         needToResetStyleCache: false
       });
     });
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_invokeOnGridRenderedHelper", function () {
+    defineProperty_defineProperty(_this, "_invokeOnGridRenderedHelper", function () {
       var onSectionRendered = _this.props.onSectionRendered;
       _this._onGridRenderedMemoizer({
         callback: onSectionRendered,
@@ -46511,18 +46467,15 @@ function (_React$PureComponent) {
         }
       });
     });
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_setScrollingContainerRef", function (ref
-    /*: Element*/) {
+    defineProperty_defineProperty(_this, "_setScrollingContainerRef", function (ref /*: Element*/) {
       _this._scrollingContainer = ref;
     });
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_onScroll", function (event
-    /*: Event*/) {
+    defineProperty_defineProperty(_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({
@@ -46569,11 +46522,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] : {},
@@ -46583,7 +46537,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
@@ -46593,6 +46547,7 @@ function (_React$PureComponent) {
         scrollTop: this._getCalculatedScrollTop(offsetProps)
       };
     }
+
     /**
      * Gets estimated total rows' height.
      */
@@ -46601,6 +46556,7 @@ function (_React$PureComponent) {
     value: function getTotalRowsHeight() {
       return this.state.instanceProps.rowSizeAndPositionManager.getTotalSize();
     }
+
     /**
      * Gets estimated total columns' width.
      */
@@ -46609,51 +46565,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,
@@ -46675,6 +46633,7 @@ function (_React$PureComponent) {
         totalRowsHeight: totalRowsHeight
       });
     }
+
     /**
      * Invalidate Grid size and recompute visible cells.
      * This is a deferred wrapper for recomputeGridSize().
@@ -46684,12 +46643,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.
@@ -46705,6 +46665,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.
@@ -46723,37 +46684,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
         }));
       }
@@ -46769,18 +46734,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();
@@ -46798,8 +46766,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.
@@ -46809,19 +46778,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,
@@ -46830,6 +46802,7 @@ function (_React$PureComponent) {
       });
       this._maybeCallOnScrollbarPresenceChange();
     }
+
     /**
      * @private
      * This method updates scrollLeft/scrollTop in state for the following conditions:
@@ -46837,9 +46810,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,
@@ -46855,19 +46826,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.
@@ -46877,13 +46850,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);
@@ -46925,10 +46900,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();
@@ -46948,6 +46925,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)
@@ -46976,8 +46954,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,
@@ -46988,31 +46965,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;
@@ -47026,7 +47007,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",
@@ -47042,14 +47023,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,
@@ -47067,8 +47047,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,
@@ -47085,8 +47066,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;
@@ -47106,13 +47088,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,
@@ -47126,11 +47110,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)) {
@@ -47161,14 +47146,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.
@@ -47185,11 +47172,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;
@@ -47203,12 +47191,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,
@@ -47234,12 +47222,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);
@@ -47259,13 +47244,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,
@@ -47279,19 +47265,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;
@@ -47301,10 +47283,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);
     }
   }, {
@@ -47312,16 +47292,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);
@@ -47335,10 +47317,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;
@@ -47347,14 +47327,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({
@@ -47363,8 +47342,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
@@ -47383,8 +47363,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
@@ -47428,8 +47409,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;
@@ -47438,33 +47420,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) {
@@ -47482,19 +47461,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,
@@ -47518,10 +47492,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) {
@@ -47535,9 +47506,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,
@@ -47561,10 +47530,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) {
@@ -47577,7 +47543,6 @@ function (_React$PureComponent) {
       return {};
     }
   }]);
-  return Grid;
 }(react.PureComponent);
 defineProperty_defineProperty(Grid, "defaultProps", {
   'aria-label': 'grid',
@@ -47615,18 +47580,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
@@ -47667,36 +47632,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) {
-        defineProperty_defineProperty(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) {
+      defineProperty_defineProperty(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';*/
 
 
@@ -47707,35 +47674,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_Table = /*#__PURE__*/
-function (_React$PureComponent) {
-  _inherits(Table, _React$PureComponent);
+var Table_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(_assertThisInitialized(_this));
-    _this._createRow = _this._createRow.bind(_assertThisInitialized(_this));
-    _this._onScroll = _this._onScroll.bind(_assertThisInitialized(_this));
-    _this._onSectionRendered = _this._onSectionRendered.bind(_assertThisInitialized(_this));
-    _this._setRef = _this._setRef.bind(_assertThisInitialized(_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",
@@ -47752,12 +47719,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,
@@ -47765,6 +47733,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#measureAllCells */
   }, {
     key: "measureAllRows",
@@ -47773,6 +47742,7 @@ function (_React$PureComponent) {
         this.Grid.measureAllCells();
       }
     }
+
     /** CellMeasurer compatibility */
   }, {
     key: "recomputeGridSize",
@@ -47789,6 +47759,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#recomputeGridSize */
   }, {
     key: "recomputeRowHeights",
@@ -47800,6 +47771,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#scrollToPosition */
   }, {
     key: "scrollToPosition",
@@ -47811,6 +47783,7 @@ function (_React$PureComponent) {
         });
       }
     }
+
     /** See Grid#scrollToCell */
   }, {
     key: "scrollToRow",
@@ -47873,18 +47846,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'],
@@ -47920,7 +47895,7 @@ function (_React$PureComponent) {
         role: "rowgroup",
         scrollbarWidth: scrollbarWidth,
         scrollToRow: scrollToIndex,
-        style: Table_objectSpread({}, gridStyle, {
+        style: Table_objectSpread(Table_objectSpread({}, gridStyle), {}, {
           overflowX: 'hidden'
         })
       })));
@@ -47966,10 +47941,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,
@@ -48001,12 +47977,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,
@@ -48015,13 +47992,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,
@@ -48040,7 +48026,6 @@ function (_React$PureComponent) {
             onClick(event);
           }
         };
-        headerAriaLabel = column.props['aria-label'] || label || dataKey;
         headerAriaSort = 'none';
         headerTabIndex = 0;
         headerOnClick = onClick;
@@ -48048,10 +48033,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,
@@ -48107,7 +48093,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
@@ -48127,6 +48113,7 @@ function (_React$PureComponent) {
         style: flattenedStyle
       });
     }
+
     /**
      * Determines the flex-shrink, flex-grow, and width values for a cell (header or column).
      */
@@ -48135,7 +48122,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
@@ -48213,7 +48200,6 @@ function (_React$PureComponent) {
       });
     }
   }]);
-  return Table;
 }(react.PureComponent);
 defineProperty_defineProperty(Table_Table, "defaultProps", {
   disableHeader: false,
@@ -48268,6 +48254,7 @@ Table_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;
@@ -48331,8 +48318,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',
@@ -48403,8 +48390,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) {
@@ -48430,7 +48417,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
         }
       }
     }
@@ -48447,34 +48435,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) {
-        defineProperty_defineProperty(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) {
+      defineProperty_defineProperty(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;
+  })();
 }
 
 
@@ -48482,7 +48473,6 @@ function AutoSizer_objectSpread(target) {
   height: number,
   width: number,
 };*/
-
 /*:: type Props = {
   /** Function responsible for rendering children.*-/
   children: Size => React.Element<*>,
@@ -48511,39 +48501,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)));
-    defineProperty_defineProperty(_assertThisInitialized(_this), "state", {
+    _this = AutoSizer_callSuper(this, AutoSizer, [].concat(args));
+    defineProperty_defineProperty(_this, "state", {
       height: _this.props.defaultHeight || 0,
       width: _this.props.defaultWidth || 0
     });
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_parentNode", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_autoSizer", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_window", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_detectElementResize", void 0);
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_onResize", function () {
+    defineProperty_defineProperty(_this, "_parentNode", void 0);
+    defineProperty_defineProperty(_this, "_autoSizer", void 0);
+    defineProperty_defineProperty(_this, "_window", void 0);
+    // uses any instead of Window because Flow doesn't have window type
+    defineProperty_defineProperty(_this, "_detectElementResize", void 0);
+    defineProperty_defineProperty(_this, "_onResize", function () {
       var _this$props = _this.props,
         disableHeight = _this$props.disableHeight,
         disableWidth = _this$props.disableWidth,
@@ -48552,6 +48536,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;
@@ -48574,13 +48559,13 @@ function (_React$Component) {
         }
       }
     });
-    defineProperty_defineProperty(_assertThisInitialized(_this), "_setRef", function (autoSizer
-    /*: ?HTMLElement*/) {
+    defineProperty_defineProperty(_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;
@@ -48589,9 +48574,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();
@@ -48615,16 +48601,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;
@@ -48633,6 +48618,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.
@@ -48649,11 +48635,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);
 defineProperty_defineProperty(AutoSizer, "defaultProps", {
   onResize: function onResize() {},